memorix 1.6.3 → 1.7.1

package/dist/index.js

@@ -2685,29 +2685,29 @@ function sharedAgentIds(record80) {
     return [];
   }
 }
-function canReadObservation(record80, reader) {
-  if (!reader) return true;
-  const sameProject = reader.projectId === record80.projectId;
+function canReadObservation(record80, reader2) {
+  if (!reader2) return true;
+  const sameProject = reader2.projectId === record80.projectId;
   const visibility = resolveObservationVisibility(record80);
-  if (visibility === "project") return !reader.projectId || sameProject;
-  if (!sameProject || !reader.agentId) return false;
-  if (visibility === "team") return reader.isTeamMember === true;
-  return record80.createdByAgentId === reader.agentId || sharedAgentIds(record80).includes(reader.agentId);
-}
-function canManageObservation(record80, reader) {
-  if (!reader) return true;
-  if (!reader.projectId || reader.projectId !== record80.projectId) return false;
+  if (visibility === "project") return !reader2.projectId || sameProject;
+  if (!sameProject || !reader2.agentId) return false;
+  if (visibility === "team") return reader2.isTeamMember === true;
+  return record80.createdByAgentId === reader2.agentId || sharedAgentIds(record80).includes(reader2.agentId);
+}
+function canManageObservation(record80, reader2) {
+  if (!reader2) return true;
+  if (!reader2.projectId || reader2.projectId !== record80.projectId) return false;
   switch (resolveObservationVisibility(record80)) {
     case "project":
       return true;
     case "team":
-      return reader.isTeamMember === true;
+      return reader2.isTeamMember === true;
     case "personal":
-      return Boolean(reader.agentId && record80.createdByAgentId === reader.agentId);
+      return Boolean(reader2.agentId && record80.createdByAgentId === reader2.agentId);
   }
 }
-function filterReadableObservations(observations2, reader) {
-  return reader ? observations2.filter((observation) => canReadObservation(observation, reader)) : [...observations2];
+function filterReadableObservations(observations2, reader2) {
+  return reader2 ? observations2.filter((observation) => canReadObservation(observation, reader2)) : [...observations2];
 }
 var init_visibility = __esm({
   "src/memory/visibility.ts"() {
@@ -5704,8 +5704,8 @@ async function readResponseText(response, signal, maxBytes = MAX_LLM_RESPONSE_BY
   if (contentLength && Number(contentLength) > maxBytes) {
     throw new Error(`LLM response too large (${contentLength} bytes)`);
   }
-  const reader = response.body?.getReader();
-  if (!reader) {
+  const reader2 = response.body?.getReader();
+  if (!reader2) {
     signal?.throwIfAborted();
     return response.text();
   }
@@ -5713,19 +5713,19 @@ async function readResponseText(response, signal, maxBytes = MAX_LLM_RESPONSE_BY
   const chunks = [];
   let bytesRead = 0;
   const abortReader = () => {
-    void reader.cancel(signal?.reason).catch(() => void 0);
+    void reader2.cancel(signal?.reason).catch(() => void 0);
   };
   signal?.addEventListener("abort", abortReader, { once: true });
   try {
     while (true) {
       signal?.throwIfAborted();
-      const { value, done } = await reader.read();
+      const { value, done } = await reader2.read();
       if (done) break;
       signal?.throwIfAborted();
       if (!value) continue;
       bytesRead += value.byteLength;
       if (bytesRead > maxBytes) {
-        await reader.cancel("response too large").catch(() => void 0);
+        await reader2.cancel("response too large").catch(() => void 0);
         throw new Error(`LLM response exceeded ${maxBytes} bytes`);
       }
       chunks.push(decoder.decode(value, { stream: true }));
@@ -5735,7 +5735,7 @@ async function readResponseText(response, signal, maxBytes = MAX_LLM_RESPONSE_BY
     return chunks.join("");
   } finally {
     signal?.removeEventListener("abort", abortReader);
-    reader.releaseLock();
+    reader2.releaseLock();
   }
 }
 async function readResponseJson(response, signal, maxBytes = MAX_LLM_RESPONSE_BYTES) {
@@ -6065,8 +6065,8 @@ async function* callOpenAIWithToolsStream(messages, tools) {
     const error = await response.text().catch(() => "unknown error");
     throw new Error(`LLM streaming API error (${response.status}): ${error}`);
   }
-  const reader = response.body?.getReader();
-  if (!reader) throw new Error("No response body for streaming");
+  const reader2 = response.body?.getReader();
+  if (!reader2) throw new Error("No response body for streaming");
   const decoder = new TextDecoder();
   let fullContent = "";
   const toolCallMap = /* @__PURE__ */ new Map();
@@ -6074,7 +6074,7 @@ async function* callOpenAIWithToolsStream(messages, tools) {
   let buffer = "";
   try {
     while (true) {
-      const { done, value } = await reader.read();
+      const { done, value } = await reader2.read();
       if (done) break;
       buffer += decoder.decode(value, { stream: true });
       const lines = buffer.split("\n");
@@ -6116,7 +6116,7 @@ async function* callOpenAIWithToolsStream(messages, tools) {
       }
     }
   } finally {
-    reader.releaseLock();
+    reader2.releaseLock();
   }
   const toolCalls = [...toolCallMap.values()].map((tc) => ({
     id: tc.id,
@@ -6197,8 +6197,8 @@ async function* callAnthropicWithToolsStream(messages, tools) {
     const error = await response.text().catch(() => "unknown error");
     throw new Error(`Anthropic streaming API error (${response.status}): ${error}`);
   }
-  const reader = response.body?.getReader();
-  if (!reader) throw new Error("No response body for streaming");
+  const reader2 = response.body?.getReader();
+  if (!reader2) throw new Error("No response body for streaming");
   const decoder = new TextDecoder();
   let fullContent = "";
   const toolCalls = [];
@@ -6209,7 +6209,7 @@ async function* callAnthropicWithToolsStream(messages, tools) {
   let buffer = "";
   try {
     while (true) {
-      const { done, value } = await reader.read();
+      const { done, value } = await reader2.read();
       if (done) break;
       buffer += decoder.decode(value, { stream: true });
       const lines = buffer.split("\n");
@@ -6257,7 +6257,7 @@ async function* callAnthropicWithToolsStream(messages, tools) {
       }
     }
   } finally {
-    reader.releaseLock();
+    reader2.releaseLock();
   }
   const mappedStopReason = stopReason === "tool_use" ? "tool_use" : stopReason === "end_turn" ? "end_turn" : "unknown";
   yield {
@@ -7664,11 +7664,11 @@ async function getObservationsByIds(ids, projectId) {
   }
   return results;
 }
-async function getTimeline(anchorId, projectId, depthBefore = 3, depthAfter = 3, reader) {
+async function getTimeline(anchorId, projectId, depthBefore = 3, depthAfter = 3, reader2) {
   const { withFreshIndex: withFreshIndex2 } = await Promise.resolve().then(() => (init_freshness(), freshness_exports));
   const { getAllObservations: getAllObservations2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
   const rawObs = await withFreshIndex2(() => getAllObservations2());
-  const allObs = (projectId ? rawObs.filter((o) => o.projectId === projectId) : rawObs).filter((observation) => canReadObservation(observation, reader));
+  const allObs = (projectId ? rawObs.filter((o) => o.projectId === projectId) : rawObs).filter((observation) => canReadObservation(observation, reader2));
   const sorted = allObs.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
   const anchorIndex = sorted.findIndex((o) => o.id === anchorId);
   if (anchorIndex === -1) {
@@ -18893,12 +18893,12 @@ async function readBoundedImageResponse(response) {
   }
   if (!response.body)
     throw new Error("MiniMax image generation returned an empty image response");
-  const reader = response.body.getReader();
+  const reader2 = response.body.getReader();
   const chunks = [];
   let total = 0;
   try {
     while (true) {
-      const { done, value } = await reader.read();
+      const { done, value } = await reader2.read();
       if (done)
         break;
       if (!value)
@@ -18910,7 +18910,7 @@ async function readBoundedImageResponse(response) {
       chunks.push(value);
     }
   } finally {
-    reader.releaseLock();
+    reader2.releaseLock();
   }
   return Buffer.concat(chunks);
 }
@@ -19434,22 +19434,22 @@ function ReadableStreamFrom(iterable) {
 function ReadableStreamToAsyncIterable(stream2) {
   if (stream2[Symbol.asyncIterator])
     return stream2;
-  const reader = stream2.getReader();
+  const reader2 = stream2.getReader();
   return {
     async next() {
       try {
-        const result = await reader.read();
+        const result = await reader2.read();
         if (result?.done)
-          reader.releaseLock();
+          reader2.releaseLock();
         return result;
       } catch (e2) {
-        reader.releaseLock();
+        reader2.releaseLock();
         throw e2;
       }
     },
     async return() {
-      const cancelPromise = reader.cancel();
-      reader.releaseLock();
+      const cancelPromise = reader2.cancel();
+      reader2.releaseLock();
       await cancelPromise;
       return { done: true, value: void 0 };
     },
@@ -19465,9 +19465,9 @@ async function CancelReadableStream(stream2) {
     await stream2[Symbol.asyncIterator]().return?.();
     return;
   }
-  const reader = stream2.getReader();
-  const cancelPromise = reader.cancel();
-  reader.releaseLock();
+  const reader2 = stream2.getReader();
+  const cancelPromise = reader2.cancel();
+  reader2.releaseLock();
   await cancelPromise;
 }
 var init_shims = __esm({
@@ -22206,31 +22206,31 @@ var init_ChatCompletionStream = __esm({
         const readQueue = [];
         let done = false;
         this.on("chunk", (chunk) => {
-          const reader = readQueue.shift();
-          if (reader) {
-            reader.resolve(chunk);
+          const reader2 = readQueue.shift();
+          if (reader2) {
+            reader2.resolve(chunk);
           } else {
             pushQueue.push(chunk);
           }
         });
         this.on("end", () => {
           done = true;
-          for (const reader of readQueue) {
-            reader.resolve(void 0);
+          for (const reader2 of readQueue) {
+            reader2.resolve(void 0);
           }
           readQueue.length = 0;
         });
         this.on("abort", (err) => {
           done = true;
-          for (const reader of readQueue) {
-            reader.reject(err);
+          for (const reader2 of readQueue) {
+            reader2.reject(err);
           }
           readQueue.length = 0;
         });
         this.on("error", (err) => {
           done = true;
-          for (const reader of readQueue) {
-            reader.reject(err);
+          for (const reader2 of readQueue) {
+            reader2.reject(err);
           }
           readQueue.length = 0;
         });
@@ -23189,31 +23189,31 @@ var init_AssistantStream = __esm({
         const readQueue = [];
         let done = false;
         this.on("event", (event) => {
-          const reader = readQueue.shift();
-          if (reader) {
-            reader.resolve(event);
+          const reader2 = readQueue.shift();
+          if (reader2) {
+            reader2.resolve(event);
           } else {
             pushQueue.push(event);
           }
         });
         this.on("end", () => {
           done = true;
-          for (const reader of readQueue) {
-            reader.resolve(void 0);
+          for (const reader2 of readQueue) {
+            reader2.resolve(void 0);
           }
           readQueue.length = 0;
         });
         this.on("abort", (err) => {
           done = true;
-          for (const reader of readQueue) {
-            reader.reject(err);
+          for (const reader2 of readQueue) {
+            reader2.reject(err);
           }
           readQueue.length = 0;
         });
         this.on("error", (err) => {
           done = true;
-          for (const reader of readQueue) {
-            reader.reject(err);
+          for (const reader2 of readQueue) {
+            reader2.reject(err);
           }
           readQueue.length = 0;
         });
@@ -25478,31 +25478,31 @@ var init_ResponseStream = __esm({
         const readQueue = [];
         let done = false;
         this.on("event", (event) => {
-          const reader = readQueue.shift();
-          if (reader) {
-            reader.resolve(event);
+          const reader2 = readQueue.shift();
+          if (reader2) {
+            reader2.resolve(event);
           } else {
             pushQueue.push(event);
           }
         });
         this.on("end", () => {
           done = true;
-          for (const reader of readQueue) {
-            reader.resolve(void 0);
+          for (const reader2 of readQueue) {
+            reader2.resolve(void 0);
           }
           readQueue.length = 0;
         });
         this.on("abort", (err) => {
           done = true;
-          for (const reader of readQueue) {
-            reader.reject(err);
+          for (const reader2 of readQueue) {
+            reader2.reject(err);
           }
           readQueue.length = 0;
         });
         this.on("error", (err) => {
           done = true;
-          for (const reader of readQueue) {
-            reader.reject(err);
+          for (const reader2 of readQueue) {
+            reader2.reject(err);
           }
           readQueue.length = 0;
         });
@@ -46218,22 +46218,22 @@ function ReadableStreamFrom2(iterable) {
 function ReadableStreamToAsyncIterable2(stream2) {
   if (stream2[Symbol.asyncIterator])
     return stream2;
-  const reader = stream2.getReader();
+  const reader2 = stream2.getReader();
   return {
     async next() {
       try {
-        const result = await reader.read();
+        const result = await reader2.read();
         if (result?.done)
-          reader.releaseLock();
+          reader2.releaseLock();
         return result;
       } catch (e2) {
-        reader.releaseLock();
+        reader2.releaseLock();
         throw e2;
       }
     },
     async return() {
-      const cancelPromise = reader.cancel();
-      reader.releaseLock();
+      const cancelPromise = reader2.cancel();
+      reader2.releaseLock();
       await cancelPromise;
       return { done: true, value: void 0 };
     },
@@ -46249,9 +46249,9 @@ async function CancelReadableStream2(stream2) {
     await stream2[Symbol.asyncIterator]().return?.();
     return;
   }
-  const reader = stream2.getReader();
-  const cancelPromise = reader.cancel();
-  reader.releaseLock();
+  const reader2 = stream2.getReader();
+  const cancelPromise = reader2.cancel();
+  reader2.releaseLock();
   await cancelPromise;
 }
 var init_shims2 = __esm({
@@ -49278,31 +49278,31 @@ var init_BetaMessageStream = __esm({
         const readQueue = [];
         let done = false;
         this.on("streamEvent", (event) => {
-          const reader = readQueue.shift();
-          if (reader) {
-            reader.resolve(event);
+          const reader2 = readQueue.shift();
+          if (reader2) {
+            reader2.resolve(event);
           } else {
             pushQueue.push(event);
           }
         });
         this.on("end", () => {
           done = true;
-          for (const reader of readQueue) {
-            reader.resolve(void 0);
+          for (const reader2 of readQueue) {
+            reader2.resolve(void 0);
           }
           readQueue.length = 0;
         });
         this.on("abort", (err) => {
           done = true;
-          for (const reader of readQueue) {
-            reader.reject(err);
+          for (const reader2 of readQueue) {
+            reader2.reject(err);
           }
           readQueue.length = 0;
         });
         this.on("error", (err) => {
           done = true;
-          for (const reader of readQueue) {
-            reader.reject(err);
+          for (const reader2 of readQueue) {
+            reader2.reject(err);
           }
           readQueue.length = 0;
         });
@@ -51714,31 +51714,31 @@ var init_MessageStream = __esm({
         const readQueue = [];
         let done = false;
         this.on("streamEvent", (event) => {
-          const reader = readQueue.shift();
-          if (reader) {
-            reader.resolve(event);
+          const reader2 = readQueue.shift();
+          if (reader2) {
+            reader2.resolve(event);
           } else {
             pushQueue.push(event);
           }
         });
         this.on("end", () => {
           done = true;
-          for (const reader of readQueue) {
-            reader.resolve(void 0);
+          for (const reader2 of readQueue) {
+            reader2.resolve(void 0);
           }
           readQueue.length = 0;
         });
         this.on("abort", (err) => {
           done = true;
-          for (const reader of readQueue) {
-            reader.reject(err);
+          for (const reader2 of readQueue) {
+            reader2.reject(err);
           }
           readQueue.length = 0;
         });
         this.on("error", (err) => {
           done = true;
-          for (const reader of readQueue) {
-            reader.reject(err);
+          for (const reader2 of readQueue) {
+            reader2.reject(err);
           }
           readQueue.length = 0;
         });
@@ -53408,7 +53408,7 @@ function consumeLine(text2) {
   };
 }
 async function* iterateSseMessages(body, signal) {
-  const reader = body.getReader();
+  const reader2 = body.getReader();
   const decoder = new TextDecoder();
   const state = { event: null, data: [], raw: [] };
   let buffer = "";
@@ -53417,7 +53417,7 @@ async function* iterateSseMessages(body, signal) {
       if (signal?.aborted) {
         throw new Error("Request was aborted");
       }
-      const { value, done } = await reader.read();
+      const { value, done } = await reader2.read();
       if (done) {
         break;
       }
@@ -53453,7 +53453,7 @@ async function* iterateSseMessages(body, signal) {
       yield trailingEvent;
     }
   } finally {
-    reader.releaseLock();
+    reader2.releaseLock();
   }
 }
 async function* iterateAnthropicEvents(response, signal) {
@@ -56296,7 +56296,7 @@ var require_supports_color = __commonJS({
         return 1;
       }
       if ("CI" in env2) {
-        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE", "DRONE"].some((sign) => sign in env2) || env2.CI_NAME === "codeship") {
+        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE", "DRONE"].some((sign2) => sign2 in env2) || env2.CI_NAME === "codeship") {
           return 1;
         }
         return min;
@@ -57225,68 +57225,68 @@ var require_ponyfill_es2018 = __commonJS({
       const CancelSteps = /* @__PURE__ */ Symbol("[[CancelSteps]]");
       const PullSteps = /* @__PURE__ */ Symbol("[[PullSteps]]");
       const ReleaseSteps = /* @__PURE__ */ Symbol("[[ReleaseSteps]]");
-      function ReadableStreamReaderGenericInitialize(reader, stream2) {
-        reader._ownerReadableStream = stream2;
-        stream2._reader = reader;
+      function ReadableStreamReaderGenericInitialize(reader2, stream2) {
+        reader2._ownerReadableStream = stream2;
+        stream2._reader = reader2;
         if (stream2._state === "readable") {
-          defaultReaderClosedPromiseInitialize(reader);
+          defaultReaderClosedPromiseInitialize(reader2);
         } else if (stream2._state === "closed") {
-          defaultReaderClosedPromiseInitializeAsResolved(reader);
+          defaultReaderClosedPromiseInitializeAsResolved(reader2);
         } else {
-          defaultReaderClosedPromiseInitializeAsRejected(reader, stream2._storedError);
+          defaultReaderClosedPromiseInitializeAsRejected(reader2, stream2._storedError);
         }
       }
-      function ReadableStreamReaderGenericCancel(reader, reason) {
-        const stream2 = reader._ownerReadableStream;
+      function ReadableStreamReaderGenericCancel(reader2, reason) {
+        const stream2 = reader2._ownerReadableStream;
         return ReadableStreamCancel(stream2, reason);
       }
-      function ReadableStreamReaderGenericRelease(reader) {
-        const stream2 = reader._ownerReadableStream;
+      function ReadableStreamReaderGenericRelease(reader2) {
+        const stream2 = reader2._ownerReadableStream;
         if (stream2._state === "readable") {
-          defaultReaderClosedPromiseReject(reader, new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`));
+          defaultReaderClosedPromiseReject(reader2, new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`));
         } else {
-          defaultReaderClosedPromiseResetToRejected(reader, new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`));
+          defaultReaderClosedPromiseResetToRejected(reader2, new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`));
         }
         stream2._readableStreamController[ReleaseSteps]();
         stream2._reader = void 0;
-        reader._ownerReadableStream = void 0;
+        reader2._ownerReadableStream = void 0;
       }
       function readerLockException(name) {
         return new TypeError("Cannot " + name + " a stream using a released reader");
       }
-      function defaultReaderClosedPromiseInitialize(reader) {
-        reader._closedPromise = newPromise((resolve2, reject) => {
-          reader._closedPromise_resolve = resolve2;
-          reader._closedPromise_reject = reject;
+      function defaultReaderClosedPromiseInitialize(reader2) {
+        reader2._closedPromise = newPromise((resolve2, reject) => {
+          reader2._closedPromise_resolve = resolve2;
+          reader2._closedPromise_reject = reject;
         });
       }
-      function defaultReaderClosedPromiseInitializeAsRejected(reader, reason) {
-        defaultReaderClosedPromiseInitialize(reader);
-        defaultReaderClosedPromiseReject(reader, reason);
+      function defaultReaderClosedPromiseInitializeAsRejected(reader2, reason) {
+        defaultReaderClosedPromiseInitialize(reader2);
+        defaultReaderClosedPromiseReject(reader2, reason);
       }
-      function defaultReaderClosedPromiseInitializeAsResolved(reader) {
-        defaultReaderClosedPromiseInitialize(reader);
-        defaultReaderClosedPromiseResolve(reader);
+      function defaultReaderClosedPromiseInitializeAsResolved(reader2) {
+        defaultReaderClosedPromiseInitialize(reader2);
+        defaultReaderClosedPromiseResolve(reader2);
       }
-      function defaultReaderClosedPromiseReject(reader, reason) {
-        if (reader._closedPromise_reject === void 0) {
+      function defaultReaderClosedPromiseReject(reader2, reason) {
+        if (reader2._closedPromise_reject === void 0) {
           return;
         }
-        setPromiseIsHandledToTrue(reader._closedPromise);
-        reader._closedPromise_reject(reason);
-        reader._closedPromise_resolve = void 0;
-        reader._closedPromise_reject = void 0;
+        setPromiseIsHandledToTrue(reader2._closedPromise);
+        reader2._closedPromise_reject(reason);
+        reader2._closedPromise_resolve = void 0;
+        reader2._closedPromise_reject = void 0;
       }
-      function defaultReaderClosedPromiseResetToRejected(reader, reason) {
-        defaultReaderClosedPromiseInitializeAsRejected(reader, reason);
+      function defaultReaderClosedPromiseResetToRejected(reader2, reason) {
+        defaultReaderClosedPromiseInitializeAsRejected(reader2, reason);
       }
-      function defaultReaderClosedPromiseResolve(reader) {
-        if (reader._closedPromise_resolve === void 0) {
+      function defaultReaderClosedPromiseResolve(reader2) {
+        if (reader2._closedPromise_resolve === void 0) {
           return;
         }
-        reader._closedPromise_resolve(void 0);
-        reader._closedPromise_resolve = void 0;
-        reader._closedPromise_reject = void 0;
+        reader2._closedPromise_resolve(void 0);
+        reader2._closedPromise_resolve = void 0;
+        reader2._closedPromise_reject = void 0;
       }
       const NumberIsFinite = Number.isFinite || function(x2) {
         return typeof x2 === "number" && isFinite(x2);
@@ -57363,8 +57363,8 @@ var require_ponyfill_es2018 = __commonJS({
         stream2._reader._readRequests.push(readRequest);
       }
       function ReadableStreamFulfillReadRequest(stream2, chunk, done) {
-        const reader = stream2._reader;
-        const readRequest = reader._readRequests.shift();
+        const reader2 = stream2._reader;
+        const readRequest = reader2._readRequests.shift();
         if (done) {
           readRequest._closeSteps();
         } else {
@@ -57375,11 +57375,11 @@ var require_ponyfill_es2018 = __commonJS({
         return stream2._reader._readRequests.length;
       }
       function ReadableStreamHasDefaultReader(stream2) {
-        const reader = stream2._reader;
-        if (reader === void 0) {
+        const reader2 = stream2._reader;
+        if (reader2 === void 0) {
           return false;
         }
-        if (!IsReadableStreamDefaultReader(reader)) {
+        if (!IsReadableStreamDefaultReader(reader2)) {
           return false;
         }
         return true;
@@ -57485,8 +57485,8 @@ var require_ponyfill_es2018 = __commonJS({
         }
         return x2 instanceof ReadableStreamDefaultReader;
       }
-      function ReadableStreamDefaultReaderRead(reader, readRequest) {
-        const stream2 = reader._ownerReadableStream;
+      function ReadableStreamDefaultReaderRead(reader2, readRequest) {
+        const stream2 = reader2._ownerReadableStream;
         stream2._disturbed = true;
         if (stream2._state === "closed") {
           readRequest._closeSteps();
@@ -57496,14 +57496,14 @@ var require_ponyfill_es2018 = __commonJS({
           stream2._readableStreamController[PullSteps](readRequest);
         }
       }
-      function ReadableStreamDefaultReaderRelease(reader) {
-        ReadableStreamReaderGenericRelease(reader);
+      function ReadableStreamDefaultReaderRelease(reader2) {
+        ReadableStreamReaderGenericRelease(reader2);
         const e2 = new TypeError("Reader was released");
-        ReadableStreamDefaultReaderErrorReadRequests(reader, e2);
+        ReadableStreamDefaultReaderErrorReadRequests(reader2, e2);
       }
-      function ReadableStreamDefaultReaderErrorReadRequests(reader, e2) {
-        const readRequests = reader._readRequests;
-        reader._readRequests = new SimpleQueue();
+      function ReadableStreamDefaultReaderErrorReadRequests(reader2, e2) {
+        const readRequests = reader2._readRequests;
+        reader2._readRequests = new SimpleQueue();
         readRequests.forEach((readRequest) => {
           readRequest._errorSteps(e2);
         });
@@ -57514,10 +57514,10 @@ var require_ponyfill_es2018 = __commonJS({
       const AsyncIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf(async function* () {
       }).prototype);
       class ReadableStreamAsyncIteratorImpl {
-        constructor(reader, preventCancel) {
+        constructor(reader2, preventCancel) {
           this._ongoingPromise = void 0;
           this._isFinished = false;
-          this._reader = reader;
+          this._reader = reader2;
           this._preventCancel = preventCancel;
         }
         next() {
@@ -57533,7 +57533,7 @@ var require_ponyfill_es2018 = __commonJS({
           if (this._isFinished) {
             return Promise.resolve({ value: void 0, done: true });
           }
-          const reader = this._reader;
+          const reader2 = this._reader;
           let resolvePromise;
           let rejectPromise;
           const promise = newPromise((resolve2, reject) => {
@@ -57548,17 +57548,17 @@ var require_ponyfill_es2018 = __commonJS({
             _closeSteps: () => {
               this._ongoingPromise = void 0;
               this._isFinished = true;
-              ReadableStreamReaderGenericRelease(reader);
+              ReadableStreamReaderGenericRelease(reader2);
               resolvePromise({ value: void 0, done: true });
             },
             _errorSteps: (reason) => {
               this._ongoingPromise = void 0;
               this._isFinished = true;
-              ReadableStreamReaderGenericRelease(reader);
+              ReadableStreamReaderGenericRelease(reader2);
               rejectPromise(reason);
             }
           };
-          ReadableStreamDefaultReaderRead(reader, readRequest);
+          ReadableStreamDefaultReaderRead(reader2, readRequest);
           return promise;
         }
         _returnSteps(value) {
@@ -57566,13 +57566,13 @@ var require_ponyfill_es2018 = __commonJS({
             return Promise.resolve({ value, done: true });
           }
           this._isFinished = true;
-          const reader = this._reader;
+          const reader2 = this._reader;
           if (!this._preventCancel) {
-            const result = ReadableStreamReaderGenericCancel(reader, value);
-            ReadableStreamReaderGenericRelease(reader);
+            const result = ReadableStreamReaderGenericCancel(reader2, value);
+            ReadableStreamReaderGenericRelease(reader2);
             return transformPromiseWith(result, () => ({ value, done: true }));
           }
-          ReadableStreamReaderGenericRelease(reader);
+          ReadableStreamReaderGenericRelease(reader2);
           return promiseResolvedWith({ value, done: true });
         }
       }
@@ -57592,8 +57592,8 @@ var require_ponyfill_es2018 = __commonJS({
       };
       Object.setPrototypeOf(ReadableStreamAsyncIteratorPrototype, AsyncIteratorPrototype);
       function AcquireReadableStreamAsyncIterator(stream2, preventCancel) {
-        const reader = AcquireReadableStreamDefaultReader(stream2);
-        const impl = new ReadableStreamAsyncIteratorImpl(reader, preventCancel);
+        const reader2 = AcquireReadableStreamDefaultReader(stream2);
+        const impl = new ReadableStreamAsyncIteratorImpl(reader2, preventCancel);
         const iterator = Object.create(ReadableStreamAsyncIteratorPrototype);
         iterator._asyncIteratorImpl = impl;
         return iterator;
@@ -58097,12 +58097,12 @@ var require_ponyfill_es2018 = __commonJS({
         }
       }
       function ReadableByteStreamControllerProcessReadRequestsUsingQueue(controller) {
-        const reader = controller._controlledReadableByteStream._reader;
-        while (reader._readRequests.length > 0) {
+        const reader2 = controller._controlledReadableByteStream._reader;
+        while (reader2._readRequests.length > 0) {
           if (controller._queueTotalSize === 0) {
             return;
           }
-          const readRequest = reader._readRequests.shift();
+          const readRequest = reader2._readRequests.shift();
           ReadableByteStreamControllerFillReadRequestFromQueue(controller, readRequest);
         }
       }
@@ -58462,8 +58462,8 @@ var require_ponyfill_es2018 = __commonJS({
         stream2._reader._readIntoRequests.push(readIntoRequest);
       }
       function ReadableStreamFulfillReadIntoRequest(stream2, chunk, done) {
-        const reader = stream2._reader;
-        const readIntoRequest = reader._readIntoRequests.shift();
+        const reader2 = stream2._reader;
+        const readIntoRequest = reader2._readIntoRequests.shift();
         if (done) {
           readIntoRequest._closeSteps(chunk);
         } else {
@@ -58474,11 +58474,11 @@ var require_ponyfill_es2018 = __commonJS({
         return stream2._reader._readIntoRequests.length;
       }
       function ReadableStreamHasBYOBReader(stream2) {
-        const reader = stream2._reader;
-        if (reader === void 0) {
+        const reader2 = stream2._reader;
+        if (reader2 === void 0) {
           return false;
         }
-        if (!IsReadableStreamBYOBReader(reader)) {
+        if (!IsReadableStreamBYOBReader(reader2)) {
           return false;
         }
         return true;
@@ -58611,8 +58611,8 @@ var require_ponyfill_es2018 = __commonJS({
         }
         return x2 instanceof ReadableStreamBYOBReader;
       }
-      function ReadableStreamBYOBReaderRead(reader, view, min, readIntoRequest) {
-        const stream2 = reader._ownerReadableStream;
+      function ReadableStreamBYOBReaderRead(reader2, view, min, readIntoRequest) {
+        const stream2 = reader2._ownerReadableStream;
         stream2._disturbed = true;
         if (stream2._state === "errored") {
           readIntoRequest._errorSteps(stream2._storedError);
@@ -58620,14 +58620,14 @@ var require_ponyfill_es2018 = __commonJS({
           ReadableByteStreamControllerPullInto(stream2._readableStreamController, view, min, readIntoRequest);
         }
       }
-      function ReadableStreamBYOBReaderRelease(reader) {
-        ReadableStreamReaderGenericRelease(reader);
+      function ReadableStreamBYOBReaderRelease(reader2) {
+        ReadableStreamReaderGenericRelease(reader2);
         const e2 = new TypeError("Reader was released");
-        ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e2);
+        ReadableStreamBYOBReaderErrorReadIntoRequests(reader2, e2);
       }
-      function ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e2) {
-        const readIntoRequests = reader._readIntoRequests;
-        reader._readIntoRequests = new SimpleQueue();
+      function ReadableStreamBYOBReaderErrorReadIntoRequests(reader2, e2) {
+        const readIntoRequests = reader2._readIntoRequests;
+        reader2._readIntoRequests = new SimpleQueue();
         readIntoRequests.forEach((readIntoRequest) => {
           readIntoRequest._errorSteps(e2);
         });
@@ -59642,7 +59642,7 @@ var require_ponyfill_es2018 = __commonJS({
       }
       const DOMException3 = getFromGlobal() || createPolyfill();
       function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventCancel, signal) {
-        const reader = AcquireReadableStreamDefaultReader(source);
+        const reader2 = AcquireReadableStreamDefaultReader(source);
         const writer = AcquireWritableStreamDefaultWriter(dest);
         source._disturbed = true;
         let shuttingDown = false;
@@ -59695,7 +59695,7 @@ var require_ponyfill_es2018 = __commonJS({
             }
             return PerformPromiseThen(writer._readyPromise, () => {
               return newPromise((resolveRead, rejectRead) => {
-                ReadableStreamDefaultReaderRead(reader, {
+                ReadableStreamDefaultReaderRead(reader2, {
                   _chunkSteps: (chunk) => {
                     currentWrite = PerformPromiseThen(WritableStreamDefaultWriterWrite(writer, chunk), void 0, noop5);
                     resolveRead(false);
@@ -59706,7 +59706,7 @@ var require_ponyfill_es2018 = __commonJS({
               });
             });
           }
-          isOrBecomesErrored(source, reader._closedPromise, (storedError) => {
+          isOrBecomesErrored(source, reader2._closedPromise, (storedError) => {
             if (!preventAbort) {
               shutdownWithAction(() => WritableStreamAbort(dest, storedError), true, storedError);
             } else {
@@ -59722,7 +59722,7 @@ var require_ponyfill_es2018 = __commonJS({
             }
             return null;
           });
-          isOrBecomesClosed(source, reader._closedPromise, () => {
+          isOrBecomesClosed(source, reader2._closedPromise, () => {
             if (!preventClose) {
               shutdownWithAction(() => WritableStreamDefaultWriterCloseWithErrorPropagation(writer));
             } else {
@@ -59785,7 +59785,7 @@ var require_ponyfill_es2018 = __commonJS({
           }
           function finalize(isError, error) {
             WritableStreamDefaultWriterRelease(writer);
-            ReadableStreamReaderGenericRelease(reader);
+            ReadableStreamReaderGenericRelease(reader2);
             if (signal !== void 0) {
               signal.removeEventListener("abort", abortAlgorithm);
             }
@@ -60063,7 +60063,7 @@ var require_ponyfill_es2018 = __commonJS({
         return ReadableStreamDefaultTee(stream2);
       }
       function ReadableStreamDefaultTee(stream2, cloneForBranch2) {
-        const reader = AcquireReadableStreamDefaultReader(stream2);
+        const reader2 = AcquireReadableStreamDefaultReader(stream2);
         let reading = false;
         let readAgain = false;
         let canceled1 = false;
@@ -60116,7 +60116,7 @@ var require_ponyfill_es2018 = __commonJS({
               reading = false;
             }
           };
-          ReadableStreamDefaultReaderRead(reader, readRequest);
+          ReadableStreamDefaultReaderRead(reader2, readRequest);
           return promiseResolvedWith(void 0);
         }
         function cancel1Algorithm(reason) {
@@ -60143,7 +60143,7 @@ var require_ponyfill_es2018 = __commonJS({
         }
         branch1 = CreateReadableStream(startAlgorithm, pullAlgorithm, cancel1Algorithm);
         branch2 = CreateReadableStream(startAlgorithm, pullAlgorithm, cancel2Algorithm);
-        uponRejection(reader._closedPromise, (r2) => {
+        uponRejection(reader2._closedPromise, (r2) => {
           ReadableStreamDefaultControllerError(branch1._readableStreamController, r2);
           ReadableStreamDefaultControllerError(branch2._readableStreamController, r2);
           if (!canceled1 || !canceled2) {
@@ -60154,7 +60154,7 @@ var require_ponyfill_es2018 = __commonJS({
         return [branch1, branch2];
       }
       function ReadableByteStreamTee(stream2) {
-        let reader = AcquireReadableStreamDefaultReader(stream2);
+        let reader2 = AcquireReadableStreamDefaultReader(stream2);
         let reading = false;
         let readAgainForBranch1 = false;
         let readAgainForBranch2 = false;
@@ -60170,7 +60170,7 @@ var require_ponyfill_es2018 = __commonJS({
         });
         function forwardReaderError(thisReader) {
           uponRejection(thisReader._closedPromise, (r2) => {
-            if (thisReader !== reader) {
+            if (thisReader !== reader2) {
               return null;
             }
             ReadableByteStreamControllerError(branch1._readableStreamController, r2);
@@ -60182,10 +60182,10 @@ var require_ponyfill_es2018 = __commonJS({
           });
         }
         function pullWithDefaultReader() {
-          if (IsReadableStreamBYOBReader(reader)) {
-            ReadableStreamReaderGenericRelease(reader);
-            reader = AcquireReadableStreamDefaultReader(stream2);
-            forwardReaderError(reader);
+          if (IsReadableStreamBYOBReader(reader2)) {
+            ReadableStreamReaderGenericRelease(reader2);
+            reader2 = AcquireReadableStreamDefaultReader(stream2);
+            forwardReaderError(reader2);
           }
           const readRequest = {
             _chunkSteps: (chunk) => {
@@ -60240,13 +60240,13 @@ var require_ponyfill_es2018 = __commonJS({
               reading = false;
             }
           };
-          ReadableStreamDefaultReaderRead(reader, readRequest);
+          ReadableStreamDefaultReaderRead(reader2, readRequest);
         }
         function pullWithBYOBReader(view, forBranch2) {
-          if (IsReadableStreamDefaultReader(reader)) {
-            ReadableStreamReaderGenericRelease(reader);
-            reader = AcquireReadableStreamBYOBReader(stream2);
-            forwardReaderError(reader);
+          if (IsReadableStreamDefaultReader(reader2)) {
+            ReadableStreamReaderGenericRelease(reader2);
+            reader2 = AcquireReadableStreamBYOBReader(stream2);
+            forwardReaderError(reader2);
           }
           const byobBranch = forBranch2 ? branch2 : branch1;
           const otherBranch = forBranch2 ? branch1 : branch2;
@@ -60308,7 +60308,7 @@ var require_ponyfill_es2018 = __commonJS({
               reading = false;
             }
           };
-          ReadableStreamBYOBReaderRead(reader, view, 1, readIntoRequest);
+          ReadableStreamBYOBReaderRead(reader2, view, 1, readIntoRequest);
         }
         function pull1Algorithm() {
           if (reading) {
@@ -60363,7 +60363,7 @@ var require_ponyfill_es2018 = __commonJS({
         }
         branch1 = CreateReadableByteStream(startAlgorithm, pull1Algorithm, cancel1Algorithm);
         branch2 = CreateReadableByteStream(startAlgorithm, pull2Algorithm, cancel2Algorithm);
-        forwardReaderError(reader);
+        forwardReaderError(reader2);
         return [branch1, branch2];
       }
       function isReadableStreamLike(stream2) {
@@ -60428,13 +60428,13 @@ var require_ponyfill_es2018 = __commonJS({
         stream2 = CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, 0);
         return stream2;
       }
-      function ReadableStreamFromDefaultReader(reader) {
+      function ReadableStreamFromDefaultReader(reader2) {
         let stream2;
         const startAlgorithm = noop5;
         function pullAlgorithm() {
           let readPromise;
           try {
-            readPromise = reader.read();
+            readPromise = reader2.read();
           } catch (e2) {
             return promiseRejectedWith(e2);
           }
@@ -60452,7 +60452,7 @@ var require_ponyfill_es2018 = __commonJS({
         }
         function cancelAlgorithm(reason) {
           try {
-            return promiseResolvedWith(reader.cancel(reason));
+            return promiseResolvedWith(reader2.cancel(reason));
           } catch (e2) {
             return promiseRejectedWith(e2);
           }
@@ -60740,10 +60740,10 @@ var require_ponyfill_es2018 = __commonJS({
           return promiseRejectedWith(stream2._storedError);
         }
         ReadableStreamClose(stream2);
-        const reader = stream2._reader;
-        if (reader !== void 0 && IsReadableStreamBYOBReader(reader)) {
-          const readIntoRequests = reader._readIntoRequests;
-          reader._readIntoRequests = new SimpleQueue();
+        const reader2 = stream2._reader;
+        if (reader2 !== void 0 && IsReadableStreamBYOBReader(reader2)) {
+          const readIntoRequests = reader2._readIntoRequests;
+          reader2._readIntoRequests = new SimpleQueue();
           readIntoRequests.forEach((readIntoRequest) => {
             readIntoRequest._closeSteps(void 0);
           });
@@ -60753,14 +60753,14 @@ var require_ponyfill_es2018 = __commonJS({
       }
       function ReadableStreamClose(stream2) {
         stream2._state = "closed";
-        const reader = stream2._reader;
-        if (reader === void 0) {
+        const reader2 = stream2._reader;
+        if (reader2 === void 0) {
           return;
         }
-        defaultReaderClosedPromiseResolve(reader);
-        if (IsReadableStreamDefaultReader(reader)) {
-          const readRequests = reader._readRequests;
-          reader._readRequests = new SimpleQueue();
+        defaultReaderClosedPromiseResolve(reader2);
+        if (IsReadableStreamDefaultReader(reader2)) {
+          const readRequests = reader2._readRequests;
+          reader2._readRequests = new SimpleQueue();
           readRequests.forEach((readRequest) => {
             readRequest._closeSteps();
           });
@@ -60769,15 +60769,15 @@ var require_ponyfill_es2018 = __commonJS({
       function ReadableStreamError(stream2, e2) {
         stream2._state = "errored";
         stream2._storedError = e2;
-        const reader = stream2._reader;
-        if (reader === void 0) {
+        const reader2 = stream2._reader;
+        if (reader2 === void 0) {
           return;
         }
-        defaultReaderClosedPromiseReject(reader, e2);
-        if (IsReadableStreamDefaultReader(reader)) {
-          ReadableStreamDefaultReaderErrorReadRequests(reader, e2);
+        defaultReaderClosedPromiseReject(reader2, e2);
+        if (IsReadableStreamDefaultReader(reader2)) {
+          ReadableStreamDefaultReaderErrorReadRequests(reader2, e2);
         } else {
-          ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e2);
+          ReadableStreamBYOBReaderErrorReadIntoRequests(reader2, e2);
         }
       }
       function streamBrandCheckException$1(name) {
@@ -64417,7 +64417,7 @@ var require_bignumber = __commonJS({
             }
             return arr.reverse();
           }
-          return function(str2, baseIn, baseOut, sign, callerIsToString) {
+          return function(str2, baseIn, baseOut, sign2, callerIsToString) {
             var alphabet, d, e2, k, r2, x2, xc, y, i2 = str2.indexOf("."), dp = DECIMAL_PLACES, rm2 = ROUNDING_MODE;
             if (i2 >= 0) {
               k = POW_PRECISION;
@@ -64443,7 +64443,7 @@ var require_bignumber = __commonJS({
             } else {
               x2.c = xc;
               x2.e = e2;
-              x2.s = sign;
+              x2.s = sign2;
               x2 = div(x2, y, dp, rm2, baseOut);
               xc = x2.c;
               r2 = x2.r;
@@ -68662,7 +68662,7 @@ var require_jwa = __commonJS({
       return thing;
     }
     function createHmacSigner(bits) {
-      return function sign(thing, secret) {
+      return function sign2(thing, secret) {
         checkIsSecretKey(secret);
         thing = normalizeInput(thing);
         var hmac = crypto2.createHmac("sha" + bits, secret);
@@ -68671,25 +68671,25 @@ var require_jwa = __commonJS({
       };
     }
     var bufferEqual;
-    var timingSafeEqual = "timingSafeEqual" in crypto2 ? function timingSafeEqual2(a, b) {
+    var timingSafeEqual2 = "timingSafeEqual" in crypto2 ? function timingSafeEqual3(a, b) {
       if (a.byteLength !== b.byteLength) {
         return false;
       }
       return crypto2.timingSafeEqual(a, b);
-    } : function timingSafeEqual2(a, b) {
+    } : function timingSafeEqual3(a, b) {
       if (!bufferEqual) {
         bufferEqual = require_buffer_equal_constant_time();
       }
       return bufferEqual(a, b);
     };
     function createHmacVerifier(bits) {
-      return function verify(thing, signature, secret) {
+      return function verify2(thing, signature, secret) {
         var computedSig = createHmacSigner(bits)(thing, secret);
-        return timingSafeEqual(Buffer5.from(signature), Buffer5.from(computedSig));
+        return timingSafeEqual2(Buffer5.from(signature), Buffer5.from(computedSig));
       };
     }
     function createKeySigner(bits) {
-      return function sign(thing, privateKey) {
+      return function sign2(thing, privateKey) {
         checkIsPrivateKey(privateKey);
         thing = normalizeInput(thing);
         var signer = crypto2.createSign("RSA-SHA" + bits);
@@ -68698,7 +68698,7 @@ var require_jwa = __commonJS({
       };
     }
     function createKeyVerifier(bits) {
-      return function verify(thing, signature, publicKey) {
+      return function verify2(thing, signature, publicKey) {
         checkIsPublicKey(publicKey);
         thing = normalizeInput(thing);
         signature = toBase64(signature);
@@ -68708,7 +68708,7 @@ var require_jwa = __commonJS({
       };
     }
     function createPSSKeySigner(bits) {
-      return function sign(thing, privateKey) {
+      return function sign2(thing, privateKey) {
         checkIsPrivateKey(privateKey);
         thing = normalizeInput(thing);
         var signer = crypto2.createSign("RSA-SHA" + bits);
@@ -68721,7 +68721,7 @@ var require_jwa = __commonJS({
       };
     }
     function createPSSKeyVerifier(bits) {
-      return function verify(thing, signature, publicKey) {
+      return function verify2(thing, signature, publicKey) {
         checkIsPublicKey(publicKey);
         thing = normalizeInput(thing);
         signature = toBase64(signature);
@@ -68736,7 +68736,7 @@ var require_jwa = __commonJS({
     }
     function createECDSASigner(bits) {
       var inner = createKeySigner(bits);
-      return function sign() {
+      return function sign2() {
         var signature = inner.apply(null, arguments);
         signature = formatEcdsa.derToJose(signature, "ES" + bits);
         return signature;
@@ -68744,19 +68744,19 @@ var require_jwa = __commonJS({
     }
     function createECDSAVerifer(bits) {
       var inner = createKeyVerifier(bits);
-      return function verify(thing, signature, publicKey) {
+      return function verify2(thing, signature, publicKey) {
         signature = formatEcdsa.joseToDer(signature, "ES" + bits).toString("base64");
         var result = inner(thing, signature, publicKey);
         return result;
       };
     }
     function createNoneSigner() {
-      return function sign() {
+      return function sign2() {
         return "";
       };
     }
     function createNoneVerifier() {
-      return function verify(thing, signature) {
+      return function verify2(thing, signature) {
         return signature === "";
       };
     }
@@ -68857,7 +68857,7 @@ var require_sign_stream = __commonJS({
       }.bind(this));
     }
     util.inherits(SignStream, Stream6);
-    SignStream.prototype.sign = function sign() {
+    SignStream.prototype.sign = function sign2() {
       try {
         var signature = jwsSign({
           header: this.header,
@@ -68976,7 +68976,7 @@ var require_verify_stream = __commonJS({
       }.bind(this));
     }
     util.inherits(VerifyStream, Stream6);
-    VerifyStream.prototype.verify = function verify() {
+    VerifyStream.prototype.verify = function verify2() {
       try {
         var valid = jwsVerify(this.signature.buffer, this.algorithm, this.key.buffer);
         var obj = jwsDecode(this.signature.buffer, this.encoding);
@@ -71333,14 +71333,14 @@ var require_awsrequestsigner = __commonJS({
       }
     };
     exports.AwsRequestSigner = AwsRequestSigner;
-    async function sign(crypto2, key, msg) {
+    async function sign2(crypto2, key, msg) {
       return await crypto2.signWithHmacSha256(key, msg);
     }
     async function getSigningKey(crypto2, key, dateStamp, region, serviceName) {
-      const kDate = await sign(crypto2, `AWS4${key}`, dateStamp);
-      const kRegion = await sign(crypto2, kDate, region);
-      const kService = await sign(crypto2, kRegion, serviceName);
-      const kSigning = await sign(crypto2, kService, "aws4_request");
+      const kDate = await sign2(crypto2, `AWS4${key}`, dateStamp);
+      const kRegion = await sign2(crypto2, kDate, region);
+      const kService = await sign2(crypto2, kRegion, serviceName);
+      const kSigning = await sign2(crypto2, kService, "aws4_request");
       return kSigning;
     }
     async function generateAuthenticationHeaderMap(options) {
@@ -71384,7 +71384,7 @@ ${amzDate}
 ${credentialScope}
 ` + await options.crypto.sha256DigestHex(canonicalRequest);
       const signingKey = await getSigningKey(options.crypto, options.securityCredentials.secretAccessKey, dateStamp, options.region, serviceName);
-      const signature = await sign(options.crypto, signingKey, stringToSign);
+      const signature = await sign2(options.crypto, signingKey, stringToSign);
       const authorizationHeader = `${AWS_ALGORITHM} Credential=${options.securityCredentials.accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${(0, crypto_1.fromArrayBufferToHex)(signature)}`;
       return {
         // Do not return x-amz-date if date is available.
@@ -73369,8 +73369,8 @@ var require_googleauth = __commonJS({
         }
         const crypto2 = (0, crypto_1.createCrypto)();
         if (client instanceof jwtclient_1.JWT && client.key) {
-          const sign = await crypto2.sign(client.key, data);
-          return sign;
+          const sign2 = await crypto2.sign(client.key, data);
+          return sign2;
         }
         const creds = await this.getCredentials();
         if (!creds.client_email) {
@@ -76053,7 +76053,7 @@ var require_websocket = __commonJS({
     var http3 = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes, createHash: createHash16 } = __require("crypto");
+    var { randomBytes: randomBytes2, createHash: createHash16 } = __require("crypto");
     var { Duplex, Readable: Readable2 } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -76591,7 +76591,7 @@ var require_websocket = __commonJS({
         }
       }
       const defaultPort = isSecure ? 443 : 80;
-      const key = randomBytes(16).toString("base64");
+      const key = randomBytes2(16).toString("base64");
       const request = isSecure ? https2.request : http3.request;
       const protocolSet = /* @__PURE__ */ new Set();
       let perMessageDeflate;
@@ -86902,22 +86902,22 @@ function ReadableStreamFrom3(iterable) {
 function ReadableStreamToAsyncIterable3(stream2) {
   if (stream2[Symbol.asyncIterator])
     return stream2;
-  const reader = stream2.getReader();
+  const reader2 = stream2.getReader();
   return {
     async next() {
       try {
-        const result = await reader.read();
+        const result = await reader2.read();
         if (result === null || result === void 0 ? void 0 : result.done)
-          reader.releaseLock();
+          reader2.releaseLock();
         return result;
       } catch (e2) {
-        reader.releaseLock();
+        reader2.releaseLock();
         throw e2;
       }
     },
     async return() {
-      const cancelPromise = reader.cancel();
-      reader.releaseLock();
+      const cancelPromise = reader2.cancel();
+      reader2.releaseLock();
       await cancelPromise;
       return { done: true, value: void 0 };
     },
@@ -86934,9 +86934,9 @@ async function CancelReadableStream3(stream2) {
     await ((_b = (_a5 = stream2[Symbol.asyncIterator]()).return) === null || _b === void 0 ? void 0 : _b.call(_a5));
     return;
   }
-  const reader = stream2.getReader();
-  const cancelPromise = reader.cancel();
-  reader.releaseLock();
+  const reader2 = stream2.getReader();
+  const cancelPromise = reader2.cancel();
+  reader2.releaseLock();
   await cancelPromise;
 }
 function stringifyQuery3(query) {
@@ -90810,9 +90810,9 @@ var init_node = __esm({
       processStreamResponse(response) {
         return __asyncGenerator(this, arguments, function* processStreamResponse_1() {
           var _a5;
-          const reader = (_a5 = response === null || response === void 0 ? void 0 : response.body) === null || _a5 === void 0 ? void 0 : _a5.getReader();
+          const reader2 = (_a5 = response === null || response === void 0 ? void 0 : response.body) === null || _a5 === void 0 ? void 0 : _a5.getReader();
           const decoder = new TextDecoder("utf-8");
-          if (!reader) {
+          if (!reader2) {
             throw new Error("Response body is empty");
           }
           try {
@@ -90820,7 +90820,7 @@ var init_node = __esm({
             const dataPrefix = "data:";
             const delimiters = ["\n\n", "\r\r", "\r\n\r\n"];
             while (true) {
-              const { done, value } = yield __await(reader.read());
+              const { done, value } = yield __await(reader2.read());
               if (done) {
                 if (buffer.trim().length > 0) {
                   throw new Error("Incomplete JSON segment at the end");
@@ -90884,7 +90884,7 @@ var init_node = __esm({
               }
             }
           } finally {
-            reader.releaseLock();
+            reader2.releaseLock();
           }
         });
       }
@@ -96592,12 +96592,12 @@ var init_config3 = __esm({
 
 // node_modules/@mistralai/mistralai/esm/lib/files.js
 async function readableStreamToArrayBuffer(readable) {
-  const reader = readable.getReader();
+  const reader2 = readable.getReader();
   const chunks = [];
   let totalLength = 0;
   let done = false;
   while (!done) {
-    const { value, done: doneReading } = await reader.read();
+    const { value, done: doneReading } = await reader2.read();
     if (doneReading) {
       done = true;
     } else {
@@ -111681,24 +111681,24 @@ var init_event_streams = __esm({
         const fn = ReadableStream.prototype[Symbol.asyncIterator];
         if (typeof fn === "function")
           return fn.call(this);
-        const reader = this.getReader();
+        const reader2 = this.getReader();
         return {
           next: async () => {
-            const r2 = await reader.read();
+            const r2 = await reader2.read();
             if (r2.done) {
-              reader.releaseLock();
+              reader2.releaseLock();
               return { done: true, value: void 0 };
             }
             return { done: false, value: r2.value };
           },
           throw: async (e2) => {
-            await reader.cancel(e2);
-            reader.releaseLock();
+            await reader2.cancel(e2);
+            reader2.releaseLock();
             return { done: true, value: void 0 };
           },
           return: async () => {
-            await reader.cancel("done");
-            reader.releaseLock();
+            await reader2.cancel("done");
+            reader2.releaseLock();
             return { done: true, value: void 0 };
           },
           [Symbol.asyncIterator]() {
@@ -135220,11 +135220,11 @@ function normalizeCodexStatus(status) {
 async function* parseSSE(response, signal) {
   if (!response.body)
     return;
-  const reader = response.body.getReader();
+  const reader2 = response.body.getReader();
   const decoder = new TextDecoder();
   let buffer = "";
   const onAbort = () => {
-    void reader.cancel().catch(() => {
+    void reader2.cancel().catch(() => {
     });
   };
   signal?.addEventListener("abort", onAbort, { once: true });
@@ -135233,7 +135233,7 @@ async function* parseSSE(response, signal) {
       if (signal?.aborted) {
         throw new Error("Request was aborted");
       }
-      const { done, value } = await reader.read();
+      const { done, value } = await reader2.read();
       if (signal?.aborted) {
         throw new Error("Request was aborted");
       }
@@ -135264,11 +135264,11 @@ async function* parseSSE(response, signal) {
   } finally {
     signal?.removeEventListener("abort", onAbort);
     try {
-      await reader.cancel();
+      await reader2.cancel();
     } catch {
     }
     try {
-      reader.releaseLock();
+      reader2.releaseLock();
     } catch {
     }
   }
@@ -144031,12 +144031,12 @@ async function readBoundedBody(response, maxBytes) {
     throw new Error(`Provider media download exceeds the ${maxBytes}-byte limit`);
   }
   if (!response.body) throw new Error("Provider media download returned an empty response");
-  const reader = response.body.getReader();
+  const reader2 = response.body.getReader();
   const chunks = [];
   let total = 0;
   try {
     while (true) {
-      const { done, value } = await reader.read();
+      const { done, value } = await reader2.read();
       if (done) break;
       if (!value) continue;
       total += value.byteLength;
@@ -144044,7 +144044,7 @@ async function readBoundedBody(response, maxBytes) {
       chunks.push(value);
     }
   } finally {
-    reader.releaseLock();
+    reader2.releaseLock();
   }
   if (total === 0) throw new Error("Provider media download returned an empty response");
   return Buffer.concat(chunks);
@@ -144893,7 +144893,7 @@ async function archiveExpiredBatch(_projectDir, options) {
   const nextCursor = hasMore && scanned.length > 0 ? scanned[scanned.length - 1].id : void 0;
   return nextCursor === void 0 ? { archived, scanned: scanned.length } : { archived, scanned: scanned.length, nextCursor };
 }
-async function archiveExpired(projectDir2, referenceTime, accessMap, projectId, reader) {
+async function archiveExpired(projectDir2, referenceTime, accessMap, projectId, reader2) {
   const store = getObservationStore();
   if (projectId) {
     let afterId;
@@ -144904,13 +144904,13 @@ async function archiveExpired(projectDir2, referenceTime, accessMap, projectId,
         afterId,
         referenceTime,
         accessMap,
-        reader
+        reader: reader2
       });
       archived += batch.archived;
       afterId = batch.nextCursor;
     } while (afterId !== void 0);
     const remainingObservations = await store.loadByProject(projectId, { status: "active" });
-    const remaining = reader ? remainingObservations.filter((observation) => canManageObservation(observation, reader)).length : remainingObservations.length;
+    const remaining = reader2 ? remainingObservations.filter((observation) => canManageObservation(observation, reader2)).length : remainingObservations.length;
     return { archived, remaining };
   }
   return await store.atomic(async (tx) => {
@@ -145366,21 +145366,21 @@ function assertPortableEvidence(scope, portability, evidence) {
     throw new Error("Portable user memory may only use manual or user-confirmed evidence; project code, Git, observation, test, session, claim, and workflow evidence must remain project-bound.");
   }
 }
-function requireTeamReader(scope, reader) {
-  if (scope === "team" && reader?.isTeamMember !== true) {
+function requireTeamReader(scope, reader2) {
+  if (scope === "team" && reader2?.isTeamMember !== true) {
     throw new Error("Team long-term memory requires an explicit active team identity for this project.");
   }
 }
-function matchesScope(memory, reader) {
-  if (memory.scope === "project") return memory.originProjectId === reader.projectId;
+function matchesScope(memory, reader2) {
+  if (memory.scope === "project") return memory.originProjectId === reader2.projectId;
   if (memory.scope === "team") {
-    return memory.originProjectId === reader.projectId && reader.isTeamMember === true;
+    return memory.originProjectId === reader2.projectId && reader2.isTeamMember === true;
   }
-  if (!reader.ownerId || memory.ownerId !== reader.ownerId) return false;
-  return memory.portability === "portable" || memory.originProjectId === reader.projectId;
+  if (!reader2.ownerId || memory.ownerId !== reader2.ownerId) return false;
+  return memory.portability === "portable" || memory.originProjectId === reader2.projectId;
 }
-function canReadLongTermMemory(memory, reader) {
-  return matchesScope(memory, reader);
+function canReadLongTermMemory(memory, reader2) {
+  return matchesScope(memory, reader2);
 }
 function isEligibleLongTermMemory(memory) {
   return memory.state === "qualified" || memory.state === "approved";
@@ -145766,14 +145766,14 @@ async function selectLongTermMemoriesForTask(input) {
   const task = input.task?.trim();
   if (!task) return [];
   const owner = await resolveLocalMemoryOwner(input.dataDir, { create: false });
-  const reader = {
+  const reader2 = {
     projectId: input.projectId,
     ...owner ? { ownerId: owner.id } : {},
     ...input.agentId ? { agentId: input.agentId } : {},
     ...input.isTeamMember ? { isTeamMember: true } : {}
   };
   const store = await createStore(input.dataDir);
-  const eligible = store.list({ limit: 1e3 }).filter((memory) => isEligibleLongTermMemory(memory) && canReadLongTermMemory(memory, reader));
+  const eligible = store.list({ limit: 1e3 }).filter((memory) => isEligibleLongTermMemory(memory) && canReadLongTermMemory(memory, reader2));
   let selected = eligible.map((memory) => {
     const ranked = scoreForTask(memory, task);
     return ranked ? {
@@ -152637,8 +152637,8 @@ This project does have stored Memorix memories, but none matched the current que
   const totalTokens = countTextTokens(formatted);
   return { entries, formatted, totalTokens };
 }
-async function compactTimeline(anchorId, projectId, depthBefore = 3, depthAfter = 3, reader, surface = "mcp") {
-  const result = await getTimeline(anchorId, projectId, depthBefore, depthAfter, reader);
+async function compactTimeline(anchorId, projectId, depthBefore = 3, depthAfter = 3, reader2, surface = "mcp") {
+  const result = await getTimeline(anchorId, projectId, depthBefore, depthAfter, reader2);
   const timeline = {
     anchorId,
     anchorEntry: result.anchor,
@@ -152987,7 +152987,7 @@ function auditMemoryQuality(observations2, options) {
   const lowEvidence = active.filter((obs) => evidenceScore(obs) <= 2).map((obs) => makeEntry(obs, `Low evidence score (${evidenceScore(obs)}/5)`));
   const hookNoise = active.filter((obs) => isHookNoise(obs) || isCommandLog(obs)).map((obs) => makeEntry(obs, isCommandLog(obs) ? "Command log noise" : "Hook-generated noise"));
   const orphans = active.filter((obs) => isOrphan(obs)).map((obs) => makeEntry(obs, "Weakly connected or isolated memory"));
-  const retentionCandidates = active.filter((obs) => getRetentionZone({
+  const retentionCandidates2 = active.filter((obs) => getRetentionZone({
     id: `obs-${obs.id}`,
     observationId: obs.id,
     entityName: obs.entityName,
@@ -153027,7 +153027,7 @@ function auditMemoryQuality(observations2, options) {
   if (orphans.length > 0) {
     recommendations.push("Promote or attach isolated memories only if they have clear evidence value.");
   }
-  if (retentionCandidates.length > 0) {
+  if (retentionCandidates2.length > 0) {
     recommendations.push("Run `memorix retention stale` or `memorix retention archive` to inspect aged memories.");
   }
   if (recommendations.length === 0) {
@@ -153041,7 +153041,7 @@ function auditMemoryQuality(observations2, options) {
       lowEvidence,
       hookNoise,
       orphans,
-      retentionCandidates
+      retentionCandidates: retentionCandidates2
     },
     recommendations
   };
@@ -156033,6 +156033,125 @@ var init_tool_profile = __esm({
   }
 });
 
+// src/memory/deduplication.ts
+function chronological(left, right) {
+  const byTime = new Date(left.createdAt).getTime() - new Date(right.createdAt).getTime();
+  return byTime || left.id - right.id;
+}
+function actionFromDecision(older, newer, decision) {
+  let resolveId;
+  let keepId;
+  if (decision.action === "NONE") {
+    resolveId = newer.id;
+    keepId = older.id;
+  } else if (decision.action === "UPDATE") {
+    resolveId = decision.targetId ?? older.id;
+    keepId = resolveId === newer.id ? older.id : newer.id;
+  } else if (decision.action === "DELETE") {
+    resolveId = decision.targetId ?? older.id;
+    keepId = resolveId === newer.id ? older.id : newer.id;
+  } else {
+    return null;
+  }
+  const records = /* @__PURE__ */ new Map([[older.id, older], [newer.id, newer]]);
+  const resolved = records.get(resolveId);
+  const kept = records.get(keepId);
+  if (!resolved || !kept || resolved.id === kept.id) return null;
+  return {
+    resolveId,
+    keepId,
+    entityName: newer.entityName,
+    resolveTitle: resolved.title,
+    keepTitle: kept.title,
+    reason: decision.reason,
+    decision: decision.action,
+    usedLLM: decision.usedLLM
+  };
+}
+async function planMemoryDeduplication(observations2, options = {}) {
+  const limit2 = Math.min(100, Math.max(2, Math.floor(options.limit ?? 20)));
+  const candidates = observations2.filter((observation) => (observation.status ?? "active") === "active").sort(chronological).slice(-limit2);
+  const byEntity = /* @__PURE__ */ new Map();
+  for (const observation of candidates) {
+    const group = byEntity.get(observation.entityName) ?? [];
+    group.push(observation);
+    byEntity.set(observation.entityName, group);
+  }
+  const decide = options.decide ?? deduplicateMemory;
+  const actions = /* @__PURE__ */ new Map();
+  let comparisons = 0;
+  let failedComparisons = 0;
+  for (const group of byEntity.values()) {
+    if (group.length < 2) continue;
+    group.sort(chronological);
+    for (let index = 0; index < group.length; index += 1) {
+      for (let compareIndex = index + 1; compareIndex < group.length; compareIndex += 1) {
+        const older = group[index];
+        const newer = group[compareIndex];
+        comparisons += 1;
+        let decision;
+        try {
+          decision = await decide(
+            { title: newer.title, narrative: newer.narrative, facts: newer.facts },
+            [{ id: older.id, title: older.title, narrative: older.narrative, facts: older.facts.join("\n") }]
+          );
+        } catch {
+          failedComparisons += 1;
+          continue;
+        }
+        if (!decision) continue;
+        const action = actionFromDecision(older, newer, decision);
+        if (action && !actions.has(action.resolveId)) actions.set(action.resolveId, action);
+      }
+    }
+  }
+  const planned = [...actions.values()];
+  for (const [entityName, group] of byEntity) {
+    const resolvedIds = new Set(
+      planned.filter((action) => action.entityName === entityName).map((action) => action.resolveId)
+    );
+    if (group.length > 0 && group.every((observation) => resolvedIds.has(observation.id))) {
+      const survivor = group[group.length - 1];
+      const unsafeIndex = planned.findIndex((action) => action.resolveId === survivor.id);
+      if (unsafeIndex >= 0) planned.splice(unsafeIndex, 1);
+    }
+  }
+  return {
+    scanned: candidates.length,
+    entities: byEntity.size,
+    comparisons,
+    failedComparisons,
+    actions: planned,
+    resolveIds: planned.map((action) => action.resolveId)
+  };
+}
+async function applyDeduplicationPlan(store, projectId, resolveIds, reader2 = { projectId }) {
+  const uniqueIds = [...new Set(resolveIds)];
+  const manageable = [];
+  const skipped = [];
+  for (const id of uniqueIds) {
+    const observation = await store.getById(id);
+    if (observation && observation.projectId === projectId && (observation.status ?? "active") === "active" && canManageObservation(observation, reader2)) {
+      manageable.push(id);
+    } else {
+      skipped.push(id);
+    }
+  }
+  const resolved = skipped.length > 0 || manageable.length === 0 ? [] : await store.atomic(async (tx) => {
+    const updates = await Promise.all(manageable.map((id) => tx.setStatus(id, "resolved", "active")));
+    return manageable.filter((_, index) => updates[index]);
+  });
+  return { resolved, skipped };
+}
+var init_deduplication = __esm({
+  "src/memory/deduplication.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_memory_manager();
+    init_visibility();
+  }
+});
+
 // src/memory/formation/extract.ts
 function extractFacts2(narrative, existingFacts) {
   const existingLower = new Set(existingFacts.map((f3) => f3.toLowerCase().trim()));
@@ -157291,14 +157410,14 @@ function isSystemSelfObservation(obs) {
   const text2 = stringifyObservation(obs, false);
   return SYSTEM_SELF_PATTERNS.some((pattern) => pattern.test(text2));
 }
-function readerForAlias(reader, aliases, observation) {
-  if (!reader) return void 0;
-  return reader.projectId && aliases.has(observation.projectId) ? { ...reader, projectId: observation.projectId } : reader;
+function readerForAlias(reader2, aliases, observation) {
+  if (!reader2) return void 0;
+  return reader2.projectId && aliases.has(observation.projectId) ? { ...reader2, projectId: observation.projectId } : reader2;
 }
-function readableAliasObservations(observations2, aliases, reader) {
-  return reader ? observations2.filter((observation) => canReadObservation(
+function readableAliasObservations(observations2, aliases, reader2) {
+  return reader2 ? observations2.filter((observation) => canReadObservation(
     observation,
-    readerForAlias(reader, aliases, observation)
+    readerForAlias(reader2, aliases, observation)
   )) : observations2;
 }
 function isUsefulSessionSummary(summary) {
@@ -157317,13 +157436,13 @@ function continuationScore(observation, projectTokens, task) {
   score += Math.min(matches, 2) * 2;
   return score;
 }
-async function getSessionResumeBrief(projectId, task, reader) {
+async function getSessionResumeBrief(projectId, task, reader2) {
   const aliasSet = await resolveProjectIds(projectId);
   const [sessions, allObs] = await Promise.all([
     loadAliasSessions(aliasSet),
     loadAliasActiveObservations(aliasSet)
   ]);
-  const readableObs = readableAliasObservations(allObs, aliasSet, reader);
+  const readableObs = readableAliasObservations(allObs, aliasSet, reader2);
   const previous = sessions.filter((session) => session.status === "completed").sort((a, b) => new Date(b.endedAt || b.startedAt).getTime() - new Date(a.endedAt || a.startedAt).getTime()).find((session) => session.summary && session.summary !== "(session ended implicitly by new session start)" && isUsefulSessionSummary(session.summary));
   const projectTokens = tokenizeProjectId(projectId);
   const memories = readableObs.filter((observation) => RESUME_TYPES.has(observation.type)).filter((observation) => classifyLayer(observation) === "L2").filter((observation) => !isNoiseObservation(observation) && !isSystemSelfObservation(observation)).map((observation) => ({
@@ -157434,13 +157553,13 @@ async function endSession(projectDir2, sessionId, summary) {
   await sessionStore.update(session);
   return session;
 }
-async function getSessionContext(projectDir2, projectId, limit2 = 3, reader) {
+async function getSessionContext(projectDir2, projectId, limit2 = 3, reader2) {
   const aliasSet = await resolveProjectIds(projectId);
   const [sessions, allObs] = await Promise.all([
     loadAliasSessions(aliasSet),
     loadAliasActiveObservations(aliasSet, SESSION_CONTEXT_OBSERVATION_LIMIT)
   ]);
-  const readableObs = readableAliasObservations(allObs, aliasSet, reader);
+  const readableObs = readableAliasObservations(allObs, aliasSet, reader2);
   const isNoisySummary = (summary) => {
     if (!summary) return false;
     return NOISE_PATTERNS2.some((p) => p.test(summary)) || SYSTEM_SELF_PATTERNS.some((p) => p.test(summary));
@@ -157477,7 +157596,7 @@ async function getSessionContext(projectDir2, projectId, limit2 = 3, reader) {
   const hasL1Content = l1HookObs.length > 0 || l3GitCount > 0;
   if (hasL1Content) {
     let graphNeighbors = [];
-    if (!reader && activeEntities.length > 0) {
+    if (!reader2 && activeEntities.length > 0) {
       try {
         const graphMgr = new KnowledgeGraphManager(projectDir2);
         await graphMgr.init();
@@ -161985,13 +162104,13 @@ __export(export_import_exports, {
   exportAsMarkdown: () => exportAsMarkdown,
   importFromJson: () => importFromJson
 });
-async function exportAsJson(projectDir2, projectId, reader) {
+async function exportAsJson(projectDir2, projectId, reader2) {
   const store = getObservationStore();
   const allObs = await store.loadAll();
   const allSessions = await getSessionStore().loadAll();
   const projectObs = filterReadableObservations(
     allObs.filter((o) => o.projectId === projectId),
-    reader
+    reader2
   );
   const projectSessions = allSessions.filter((s2) => s2.projectId === projectId);
   const typeBreakdown = {};
@@ -162011,8 +162130,8 @@ async function exportAsJson(projectDir2, projectId, reader) {
     }
   };
 }
-async function exportAsMarkdown(projectDir2, projectId, reader) {
-  const data = await exportAsJson(projectDir2, projectId, reader);
+async function exportAsMarkdown(projectDir2, projectId, reader2) {
+  const data = await exportAsJson(projectDir2, projectId, reader2);
   const lines = [];
   lines.push(`# Memorix Export: ${projectId}`);
   lines.push(`Exported: ${data.exportedAt}`);
@@ -162131,6 +162250,350 @@ var init_export_import = __esm({
   }
 });
 
+// src/memory/cleanup.ts
+function isLowQualityObservation(title) {
+  return LOW_QUALITY_PATTERNS.some((pattern) => pattern.test(title.trim()));
+}
+function classifyNoiseObservation(observation) {
+  const title = observation.title?.trim() ?? "";
+  const entityName = observation.entityName?.trim().toLowerCase() ?? "";
+  const concepts = (observation.concepts ?? []).map((concept) => concept.trim().toLowerCase());
+  if (entityName === "memorix.demo" || entityName.startsWith("for_memmcp_test") || concepts.some((concept) => EXPLICIT_NOISE_MARKERS.has(concept))) {
+    return { isNoise: true, reason: "system-self" };
+  }
+  if (EXPLICIT_NOISE_TITLE_PATTERNS.some((pattern) => pattern.test(title))) {
+    return { isNoise: true, reason: "demo/test/noise" };
+  }
+  return { isNoise: false };
+}
+function analyzeCleanupObservations(observations2, options = {}) {
+  const active = observations2.filter((observation) => (observation.status ?? "active") === "active");
+  const lowQuality = active.filter((observation) => isLowQualityObservation(observation.title ?? ""));
+  const lowQualityIds = new Set(lowQuality.map((observation) => observation.id));
+  const highQuality = active.filter((observation) => !lowQualityIds.has(observation.id));
+  const groups = /* @__PURE__ */ new Map();
+  for (const observation of highQuality) {
+    const key = `${observation.type}|${observation.title}|${observation.entityName}`;
+    const existing = groups.get(key);
+    if (existing) existing.duplicates.push(observation);
+    else groups.set(key, { canonical: observation, duplicates: [] });
+  }
+  const duplicateGroups = [...groups.values()].filter((group) => group.duplicates.length > 0);
+  const duplicates = duplicateGroups.flatMap((group) => group.duplicates);
+  const excludedIds = new Set([...lowQuality, ...duplicates].map((observation) => observation.id));
+  const noise = [];
+  if (options.includeNoise) {
+    for (const observation of active) {
+      if (excludedIds.has(observation.id)) continue;
+      const classification = classifyNoiseObservation(observation);
+      if (classification.isNoise && classification.reason) {
+        noise.push({ observation, reason: classification.reason });
+      }
+    }
+  }
+  const toRemove = [...lowQuality, ...duplicates];
+  const toArchive = noise.map((hit) => hit.observation);
+  return {
+    totalActive: active.length,
+    highQuality: highQuality.length - duplicates.length - toArchive.length,
+    lowQuality,
+    duplicateGroups,
+    duplicates,
+    noise,
+    toRemove,
+    toArchive
+  };
+}
+function requireObservationIds(observations2, action) {
+  const ids = observations2.map((observation) => observation.id);
+  if (ids.some((id) => typeof id !== "number")) {
+    throw new Error(`Cannot ${action}: an observation has no persisted ID.`);
+  }
+  return ids;
+}
+async function applyCleanupMutations(store, toArchive, toRemove) {
+  const archiveIds = requireObservationIds(toArchive, "archive");
+  const removeIds = requireObservationIds(toRemove, "delete");
+  const removals = new Set(removeIds);
+  if (archiveIds.some((id) => removals.has(id))) {
+    throw new Error("Cleanup cannot archive and delete the same observation.");
+  }
+  await store.atomic(async (tx) => {
+    await Promise.all(archiveIds.map((id) => tx.setStatus(id, "archived", "active")));
+    await Promise.all(removeIds.map((id) => tx.remove(id)));
+  });
+  return { archived: archiveIds.length, removed: removeIds.length };
+}
+var LOW_QUALITY_PATTERNS, EXPLICIT_NOISE_TITLE_PATTERNS, EXPLICIT_NOISE_MARKERS;
+var init_cleanup = __esm({
+  "src/memory/cleanup.ts"() {
+    "use strict";
+    init_esm_shims();
+    LOW_QUALITY_PATTERNS = [
+      /^Session activity/i,
+      /^Updated \S+\.\w+$/i,
+      /^Created \S+\.\w+$/i,
+      /^Deleted \S+\.\w+$/i,
+      /^Modified \S+\.\w+$/i,
+      /^Ran command:/i,
+      /^Read file:/i
+    ];
+    EXPLICIT_NOISE_TITLE_PATTERNS = [
+      /^\s*\[(?:test|demo|benchmark|sandbox|playground|测试|演示)\]/i,
+      /^\s*(?:Used\s+(?:mcp__\S+|apply_patch)|Ran:)\s*/i
+    ];
+    EXPLICIT_NOISE_MARKERS = /* @__PURE__ */ new Set([
+      "test-fixture",
+      "demo-fixture",
+      "benchmark-fixture",
+      "sandbox-fixture",
+      "cleanup-noise"
+    ]);
+  }
+});
+
+// src/dashboard/maintenance.ts
+import { createHmac, randomBytes, timingSafeEqual } from "crypto";
+function reader(projectId) {
+  return { projectId };
+}
+function summarize(observation) {
+  return {
+    id: observation.id,
+    title: observation.title,
+    type: observation.type,
+    entityName: observation.entityName
+  };
+}
+function normalizeIds(ids) {
+  return [...new Set(ids)].sort((left, right) => left - right);
+}
+function normalizeClusters(clusters) {
+  return clusters.map((ids) => normalizeIds(ids)).sort((left, right) => left.join(",").localeCompare(right.join(",")));
+}
+function payloadRecord(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    throw new DashboardMaintenanceError("The maintenance preview payload is missing.", 400);
+  }
+  return payload;
+}
+function payloadIds(value, field) {
+  if (!Array.isArray(value) || value.some((id) => !Number.isSafeInteger(id) || Number(id) <= 0)) {
+    throw new DashboardMaintenanceError(`Invalid ${field} in maintenance preview.`, 400);
+  }
+  return normalizeIds(value);
+}
+function sign(action, projectId, payload) {
+  return createHmac("sha256", previewSecret).update(JSON.stringify({ action, projectId, payload })).digest("hex");
+}
+function verify(action, projectId, payload, token) {
+  if (typeof token !== "string" || !/^[a-f0-9]{64}$/.test(token)) {
+    throw new DashboardMaintenanceError("Preview this maintenance action before executing it.", 400);
+  }
+  const expected = Buffer.from(sign(action, projectId, payload), "hex");
+  const received = Buffer.from(token, "hex");
+  if (!timingSafeEqual(expected, received)) {
+    throw new DashboardMaintenanceError("The maintenance preview is invalid or belongs to another project.", 409);
+  }
+}
+function assertCurrent(expected, actual) {
+  if (JSON.stringify(normalizeIds(expected)) !== JSON.stringify(normalizeIds(actual))) {
+    throw new DashboardMaintenanceError("Memory changed after the preview. Refresh the preview before executing.", 409);
+  }
+}
+async function manageableActiveObservations(context) {
+  const scope = reader(context.projectId);
+  return filterReadableObservations(
+    await context.store.loadByProject(context.projectId, { status: "active" }),
+    scope
+  ).filter((observation) => canManageObservation(observation, scope));
+}
+function cleanupPayload(includeNoise, analysis) {
+  return {
+    includeNoise,
+    removeIds: normalizeIds(analysis.toRemove.map((observation) => observation.id)),
+    archiveIds: normalizeIds(analysis.toArchive.map((observation) => observation.id))
+  };
+}
+async function previewCleanup(context, includeNoise) {
+  const analysis = analyzeCleanupObservations(await manageableActiveObservations(context), { includeNoise });
+  const payload = cleanupPayload(includeNoise, analysis);
+  return {
+    action: "cleanup",
+    projectId: context.projectId,
+    includeNoise,
+    summary: {
+      totalActive: analysis.totalActive,
+      highQuality: analysis.highQuality,
+      lowQuality: analysis.lowQuality.length,
+      duplicates: analysis.duplicates.length,
+      noise: analysis.noise.length,
+      delete: analysis.toRemove.length,
+      archive: analysis.toArchive.length
+    },
+    lowQuality: analysis.lowQuality.map(summarize),
+    duplicateGroups: analysis.duplicateGroups.map((group) => ({
+      canonical: summarize(group.canonical),
+      duplicates: group.duplicates.map(summarize)
+    })),
+    noise: analysis.noise.map((hit) => ({ ...summarize(hit.observation), reason: hit.reason })),
+    payload,
+    token: sign("cleanup", context.projectId, payload)
+  };
+}
+async function executeCleanup(context, payload, token) {
+  const record80 = payloadRecord(payload);
+  const normalized = {
+    includeNoise: record80.includeNoise === true,
+    removeIds: payloadIds(record80.removeIds, "removeIds"),
+    archiveIds: payloadIds(record80.archiveIds, "archiveIds")
+  };
+  verify("cleanup", context.projectId, normalized, token);
+  const observations2 = await manageableActiveObservations(context);
+  const analysis = analyzeCleanupObservations(observations2, { includeNoise: normalized.includeNoise });
+  const current = cleanupPayload(normalized.includeNoise, analysis);
+  assertCurrent(normalized.removeIds, current.removeIds);
+  assertCurrent(normalized.archiveIds, current.archiveIds);
+  const result = await applyCleanupMutations(context.store, analysis.toArchive, analysis.toRemove);
+  return { action: "cleanup", projectId: context.projectId, ...result };
+}
+async function previewDeduplicate(context) {
+  if (!isLLMEnabled()) {
+    return {
+      action: "deduplicate",
+      projectId: context.projectId,
+      available: false,
+      reason: "Intelligent deduplication requires a configured memory LLM."
+    };
+  }
+  const plan = await planMemoryDeduplication(await manageableActiveObservations(context));
+  const payload = { resolveIds: normalizeIds(plan.resolveIds) };
+  return {
+    action: "deduplicate",
+    projectId: context.projectId,
+    available: true,
+    summary: {
+      scanned: plan.scanned,
+      entities: plan.entities,
+      comparisons: plan.comparisons,
+      failedComparisons: plan.failedComparisons,
+      resolve: payload.resolveIds.length
+    },
+    actions: plan.actions,
+    payload,
+    token: sign("deduplicate", context.projectId, payload)
+  };
+}
+async function executeDeduplicate(context, payload, token) {
+  const record80 = payloadRecord(payload);
+  const normalized = { resolveIds: payloadIds(record80.resolveIds, "resolveIds") };
+  verify("deduplicate", context.projectId, normalized, token);
+  const result = await applyDeduplicationPlan(
+    context.store,
+    context.projectId,
+    normalized.resolveIds,
+    reader(context.projectId)
+  );
+  if (result.skipped.length > 0) {
+    throw new DashboardMaintenanceError("Memory changed after the preview. Refresh before applying deduplication.", 409);
+  }
+  return { action: "deduplicate", projectId: context.projectId, ...result };
+}
+async function previewConsolidate(context) {
+  const clusters = await findConsolidationCandidates(
+    context.projectRoot ?? context.dataDir,
+    context.projectId
+  );
+  const payload = { clusterIds: normalizeClusters(clusters.map((cluster) => cluster.ids)) };
+  return {
+    action: "consolidate",
+    projectId: context.projectId,
+    summary: {
+      clusters: clusters.length,
+      observations: normalizeIds(clusters.flatMap((cluster) => cluster.ids)).length
+    },
+    clusters,
+    payload,
+    token: sign("consolidate", context.projectId, payload)
+  };
+}
+async function executeConsolidate(context, payload, token) {
+  const record80 = payloadRecord(payload);
+  if (!Array.isArray(record80.clusterIds)) {
+    throw new DashboardMaintenanceError("Invalid clusterIds in maintenance preview.", 400);
+  }
+  const clusterIds = record80.clusterIds.map((ids, index) => payloadIds(ids, `clusterIds[${index}]`));
+  const normalized = { clusterIds: normalizeClusters(clusterIds) };
+  verify("consolidate", context.projectId, normalized, token);
+  const current = await findConsolidationCandidates(context.projectRoot ?? context.dataDir, context.projectId);
+  if (JSON.stringify(normalized.clusterIds) !== JSON.stringify(normalizeClusters(current.map((cluster) => cluster.ids)))) {
+    throw new DashboardMaintenanceError("Memory changed after the preview. Refresh before consolidating.", 409);
+  }
+  const result = await executeConsolidation(context.projectRoot ?? context.dataDir, context.projectId);
+  return { action: "consolidate", projectId: context.projectId, ...result };
+}
+async function retentionCandidates(context) {
+  return (await manageableActiveObservations(context)).map((observation) => ({
+    observation,
+    retention: projectObservationRetention(observation)
+  })).filter((row) => row.retention.zone === "archive-candidate");
+}
+async function previewRetentionArchive(context) {
+  const candidates = await retentionCandidates(context);
+  const payload = {
+    archiveIds: normalizeIds(candidates.map((candidate) => candidate.observation.id))
+  };
+  return {
+    action: "retention-archive",
+    projectId: context.projectId,
+    summary: { archive: payload.archiveIds.length },
+    candidates: candidates.map(({ observation, retention }) => ({
+      ...summarize(observation),
+      score: retention.displayScore,
+      zone: retention.zone,
+      ageHours: retention.ageHours
+    })),
+    payload,
+    token: sign("retention-archive", context.projectId, payload)
+  };
+}
+async function executeRetentionArchive(context, payload, token) {
+  const record80 = payloadRecord(payload);
+  const normalized = { archiveIds: payloadIds(record80.archiveIds, "archiveIds") };
+  verify("retention-archive", context.projectId, normalized, token);
+  const current = await retentionCandidates(context);
+  assertCurrent(normalized.archiveIds, current.map((candidate) => candidate.observation.id));
+  const result = await archiveExpired(
+    context.dataDir,
+    void 0,
+    void 0,
+    context.projectId,
+    reader(context.projectId)
+  );
+  return { action: "retention-archive", projectId: context.projectId, ...result };
+}
+var previewSecret, DashboardMaintenanceError;
+var init_maintenance = __esm({
+  "src/dashboard/maintenance.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_provider2();
+    init_cleanup();
+    init_consolidation();
+    init_deduplication();
+    init_retention();
+    init_visibility();
+    previewSecret = randomBytes(32);
+    DashboardMaintenanceError = class extends Error {
+      constructor(message, status) {
+        super(message);
+        this.status = status;
+      }
+      status;
+    };
+  }
+});
+
 // src/dashboard/project-classification.ts
 var project_classification_exports = {};
 __export(project_classification_exports, {
@@ -162733,6 +163196,56 @@ function filterDashboardObservations(observations2, projectId) {
 function isActiveStatus(status) {
   return (status ?? "active") === "active";
 }
+async function handleMaintenanceMutation(apiPath, req, res, context) {
+  if (req.method !== "POST") {
+    throw new DashboardMaintenanceError("Maintenance actions require POST.", 405);
+  }
+  let body = {};
+  const raw = await readBody(req);
+  if (raw.trim()) {
+    try {
+      const parsed = JSON.parse(raw);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("object required");
+      body = parsed;
+    } catch {
+      throw new DashboardMaintenanceError("Invalid maintenance request body.", 400);
+    }
+  }
+  const maintenanceContext = {
+    ...context,
+    store: getObservationStore()
+  };
+  let result;
+  switch (apiPath) {
+    case "/maintenance/cleanup/preview":
+      result = await previewCleanup(maintenanceContext, body.includeNoise === true);
+      break;
+    case "/maintenance/cleanup/execute":
+      result = await executeCleanup(maintenanceContext, body.payload, body.token);
+      break;
+    case "/maintenance/deduplicate/preview":
+      result = await previewDeduplicate(maintenanceContext);
+      break;
+    case "/maintenance/deduplicate/execute":
+      result = await executeDeduplicate(maintenanceContext, body.payload, body.token);
+      break;
+    case "/maintenance/consolidate/preview":
+      result = await previewConsolidate(maintenanceContext);
+      break;
+    case "/maintenance/consolidate/execute":
+      result = await executeConsolidate(maintenanceContext, body.payload, body.token);
+      break;
+    case "/maintenance/retention/preview":
+      result = await previewRetentionArchive(maintenanceContext);
+      break;
+    case "/maintenance/retention/execute":
+      result = await executeRetentionArchive(maintenanceContext, body.payload, body.token);
+      break;
+    default:
+      throw new DashboardMaintenanceError("Unknown maintenance action.", 404);
+  }
+  sendJson(res, result);
+}
 function prepareDashboardConfig(projectRoot) {
   if (!projectRoot) {
     if (preparedDashboardProjectRoot !== null) {
@@ -162775,6 +163288,21 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
   prepareDashboardConfig(effectiveProjectRoot);
   try {
     switch (apiPath) {
+      case "/maintenance/cleanup/preview":
+      case "/maintenance/cleanup/execute":
+      case "/maintenance/deduplicate/preview":
+      case "/maintenance/deduplicate/execute":
+      case "/maintenance/consolidate/preview":
+      case "/maintenance/consolidate/execute":
+      case "/maintenance/retention/preview":
+      case "/maintenance/retention/execute": {
+        await handleMaintenanceMutation(apiPath, req, res, {
+          dataDir: effectiveDataDir,
+          projectId: effectiveProjectId,
+          projectRoot: effectiveProjectRoot
+        });
+        break;
+      }
       case "/projects": {
         try {
           const allObs = filterReadableObservations(
@@ -163298,7 +163826,8 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
     }
   } catch (err) {
     const message = err instanceof Error ? err.message : "Unknown error";
-    sendError(res, message);
+    const status = err instanceof DashboardMaintenanceError ? err.status : 500;
+    sendError(res, message, status);
   }
 }
 async function serveStatic(req, res, staticDir) {
@@ -163469,7 +163998,15 @@ async function buildTeamSnapshot(dataDir, projectId, scope, mode) {
 function readBody(req) {
   return new Promise((resolve2, reject) => {
     const chunks = [];
-    req.on("data", (c) => chunks.push(c));
+    let size = 0;
+    req.on("data", (c) => {
+      size += c.length;
+      if (size > 64 * 1024) {
+        reject(new DashboardMaintenanceError("Request body is too large.", 413));
+        return;
+      }
+      chunks.push(c);
+    });
     req.on("end", () => resolve2(Buffer.concat(chunks).toString("utf-8")));
     req.on("error", reject);
   });
@@ -163602,6 +164139,7 @@ var init_server = __esm({
     init_graph_scope();
     init_retention();
     init_visibility();
+    init_maintenance();
     MIME_TYPES = {
       ".html": "text/html; charset=utf-8",
       ".css": "text/css; charset=utf-8",
@@ -166747,7 +167285,7 @@ The path should point to a directory containing a .git folder.`
   };
   const server = existingServer ?? new McpServer({
     name: "memorix",
-    version: true ? "1.6.3" : "1.0.1"
+    version: true ? "1.7.1" : "1.0.1"
   });
   const originalRegisterTool = server.registerTool.bind(server);
   server.registerTool = ((name, ...args) => {
@@ -166877,20 +167415,20 @@ The path should point to a directory containing a .git folder.`
       if (readOnlyBoundary) return readOnlyBoundary;
       const requestedVisibility = longTerm?.scope === "user" ? "personal" : longTerm?.scope === "team" ? "team" : visibility;
       const effectiveVisibility = requestedVisibility ?? "project";
-      const reader = getObservationReader();
+      const reader2 = getObservationReader();
       if (effectiveVisibility !== "project" && !currentAgentId) {
         return {
           content: [{ type: "text", text: "Personal or team memory requires memorix_session_start with joinTeam=true so Memorix can bind an owner." }],
           isError: true
         };
       }
-      if (effectiveVisibility === "team" && !reader.isTeamMember) {
+      if (effectiveVisibility === "team" && !reader2.isTeamMember) {
         return {
           content: [{ type: "text", text: "Team memory requires an active coordination membership in the current project." }],
           isError: true
         };
       }
-      if (longTerm?.scope === "team" && !reader.isTeamMember) {
+      if (longTerm?.scope === "team" && !reader2.isTeamMember) {
         return {
           content: [{ type: "text", text: "Team long-term memory requires an active coordination membership in the current project." }],
           isError: true
@@ -166937,9 +167475,9 @@ The path should point to a directory containing a .git folder.`
                 useLLM: isLLMEnabled(),
                 minValueScore: 0.3,
                 searchMemories: async (q, limit2, pid, signal) => {
-                  const result = await compactSearch({ query: q, limit: limit2, projectId: pid, status: "active", reader, signal });
+                  const result = await compactSearch({ query: q, limit: limit2, projectId: pid, status: "active", reader: reader2, signal });
                   if (result.entries.length === 0) return [];
-                  const details = await compactDetail(result.entries.map((e2) => e2.id), { reader });
+                  const details = await compactDetail(result.entries.map((e2) => e2.id), { reader: reader2 });
                   return details.documents.map((d, i2) => ({
                     id: Number(d.id.replace("obs-", "")),
                     observationId: d.observationId,
@@ -166953,7 +167491,7 @@ The path should point to a directory containing a .git folder.`
                 },
                 getObservation: (id) => {
                   const o = getObservation(id);
-                  if (!o || o.projectId !== project.id || !canReadObservation(o, reader)) return null;
+                  if (!o || o.projectId !== project.id || !canReadObservation(o, reader2)) return null;
                   return {
                     id: o.id,
                     entityName: o.entityName,
@@ -167010,7 +167548,7 @@ ${modeIcon} Formation[active]: ${formationResult.evaluation.category} (${formati
             const { action: action2, targetId, reason } = formationResult.resolution;
             if (action2 === "merge" && targetId) {
               const targetObs = getObservation(targetId);
-              if (targetObs && targetObs.projectId === project.id && canReadObservation(targetObs, reader)) {
+              if (targetObs && targetObs.projectId === project.id && canReadObservation(targetObs, reader2)) {
                 await storeObservation({
                   entityName: targetObs.entityName,
                   type: targetObs.type,
@@ -167025,7 +167563,7 @@ ${modeIcon} Formation[active]: ${formationResult.evaluation.category} (${formati
                   sourceDetail: "explicit",
                   createdByAgentId: currentAgentId,
                   visibility,
-                  visibilityReader: reader
+                  visibilityReader: reader2
                 });
                 return {
                   content: [{
@@ -167036,7 +167574,7 @@ ${modeIcon} Formation[active]: ${formationResult.evaluation.category} (${formati
               }
             } else if (action2 === "evolve" && targetId) {
               const targetObs = getObservation(targetId);
-              if (targetObs && targetObs.projectId === project.id && canReadObservation(targetObs, reader)) {
+              if (targetObs && targetObs.projectId === project.id && canReadObservation(targetObs, reader2)) {
                 await storeObservation({
                   entityName: targetObs.entityName,
                   type: targetObs.type,
@@ -167051,7 +167589,7 @@ ${modeIcon} Formation[active]: ${formationResult.evaluation.category} (${formati
                   sourceDetail: "explicit",
                   createdByAgentId: currentAgentId,
                   visibility,
-                  visibilityReader: reader
+                  visibilityReader: reader2
                 });
                 return {
                   content: [{
@@ -167078,12 +167616,12 @@ ${modeIcon} Formation[active]: ${formationResult.evaluation.category} (${formati
                 limit: 5,
                 projectId: project.id,
                 status: "active",
-                reader
+                reader: reader2
               });
               const similarEntries = searchResult.entries.map((e2) => e2);
               if (similarEntries.length > 0) {
                 const similarIds = similarEntries.map((e2) => e2.id);
-                const details = await compactDetail(similarIds, { reader });
+                const details = await compactDetail(similarIds, { reader: reader2 });
                 const existingMemories = details.documents.map((d, i2) => ({
                   id: d.observationId,
                   title: d.title,
@@ -167101,7 +167639,7 @@ ${modeIcon} Formation[active]: ${formationResult.evaluation.category} (${formati
                 );
                 if (decision.action === "UPDATE" && decision.targetId) {
                   const targetObs = getObservation(decision.targetId);
-                  if (targetObs && targetObs.projectId === project.id && canReadObservation(targetObs, reader)) {
+                  if (targetObs && targetObs.projectId === project.id && canReadObservation(targetObs, reader2)) {
                     await storeObservation({
                       entityName: targetObs.entityName,
                       type: targetObs.type,
@@ -167116,7 +167654,7 @@ ${modeIcon} Formation[active]: ${formationResult.evaluation.category} (${formati
                       sourceDetail: "explicit",
                       createdByAgentId: currentAgentId,
                       visibility,
-                      visibilityReader: reader
+                      visibilityReader: reader2
                     });
                     compactAction = `[UPDATED] Compact UPDATE: merged into #${decision.targetId} (${decision.reason})`;
                     compactMerged = true;
@@ -167203,7 +167741,7 @@ Mode: ${decision.usedLLM ? "LLM" : "heuristic"}`
             const attrCheck = await checkProjectAttribution(
               entityName,
               project.id,
-              filterReadableObservations(getAllObservations(), reader)
+              filterReadableObservations(getAllObservations(), reader2)
             );
             if (attrCheck.suspicious) {
               attributionWarning = `
@@ -167230,7 +167768,7 @@ Mode: ${decision.usedLLM ? "LLM" : "heuristic"}`
             valueCategory: formationResult?.evaluation.category,
             createdByAgentId: currentAgentId,
             visibility: requestedVisibility,
-            visibilityReader: reader
+            visibilityReader: reader2
           });
           let longTermNote = "";
           if (longTerm) {
@@ -167245,8 +167783,8 @@ Mode: ${decision.usedLLM ? "LLM" : "heuristic"}`
                 applicability: longTerm.applicability,
                 reader: {
                   projectId: project.id,
-                  ...reader.agentId ? { agentId: reader.agentId } : {},
-                  ...reader.isTeamMember ? { isTeamMember: true } : {}
+                  ...reader2.agentId ? { agentId: reader2.agentId } : {},
+                  ...reader2.isTeamMember ? { isTeamMember: true } : {}
                 }
               });
               const autoQualified = await maybeAutoQualifyLongTermMemory2({
@@ -167299,12 +167837,12 @@ Auto-enriched: ${enrichmentParts.join(", ")}` : "";
                   limit: 5,
                   projectId: project.id,
                   status: "active",
-                  reader
+                  reader: reader2
                 });
                 const similarEntries = searchResult.entries.map((e2) => e2);
                 if (similarEntries.length > 0) {
                   const similarIds = similarEntries.map((e2) => e2.id);
-                  const details = await compactDetail(similarIds, { reader });
+                  const details = await compactDetail(similarIds, { reader: reader2 });
                   const existingMemories = details.documents.map((d, i2) => ({
                     id: d.observationId,
                     title: d.title,
@@ -167330,9 +167868,9 @@ Auto-enriched: ${enrichmentParts.join(", ")}` : "";
                 useLLM: isLLMEnabled(),
                 minValueScore: 0.3,
                 searchMemories: async (q, limit2, pid, signal) => {
-                  const result = await compactSearch({ query: q, limit: limit2, projectId: pid, status: "active", reader, signal });
+                  const result = await compactSearch({ query: q, limit: limit2, projectId: pid, status: "active", reader: reader2, signal });
                   if (result.entries.length === 0) return [];
-                  const details = await compactDetail(result.entries.map((e2) => e2.id), { reader });
+                  const details = await compactDetail(result.entries.map((e2) => e2.id), { reader: reader2 });
                   return details.documents.map((d, i2) => ({
                     id: Number(d.id.replace("obs-", "")),
                     observationId: d.observationId,
@@ -167346,7 +167884,7 @@ Auto-enriched: ${enrichmentParts.join(", ")}` : "";
                 },
                 getObservation: (id) => {
                   const o = getObservation(id);
-                  if (!o || o.projectId !== project.id || !canReadObservation(o, reader)) return null;
+                  if (!o || o.projectId !== project.id || !canReadObservation(o, reader2)) return null;
                   return { id: o.id, entityName: o.entityName, type: o.type, title: o.title, narrative: o.narrative, facts: o.facts, topicKey: o.topicKey };
                 },
                 getEntityNames: () => graphManager.getEntityNames()
@@ -168114,10 +168652,10 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
     async ({ ids, status }) => {
       const { resolveObservations: resolveObservations2, getObservation: getObservation2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
       const safeIds = (Array.isArray(ids) ? ids : [ids]).map((id) => coerceNumber(id, 0)).filter((id) => id > 0);
-      const reader = getObservationReader();
+      const reader2 = getObservationReader();
       const authorizedIds = safeIds.filter((id) => {
         const observation = getObservation2(id, project.id);
-        return observation ? canManageObservation(observation, reader) : false;
+        return observation ? canManageObservation(observation, reader2) : false;
       });
       const result = await resolveObservations2(authorizedIds, status ?? "resolved");
       const deniedCount = safeIds.length - authorizedIds.length;
@@ -168160,7 +168698,7 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
     async ({ entityName, decision, alternatives, rationale, constraints, expectedOutcome, risks, concepts, filesModified, relatedCommits, relatedEntities }) => {
       const unresolved = requireResolvedProject("store reasoning in the current project");
       if (unresolved) return unresolved;
-      const reader = getObservationReader();
+      const reader2 = getObservationReader();
       return withFreshIndex(async () => {
         const narrativeParts = [rationale];
         if (alternatives && alternatives.length > 0) {
@@ -168186,7 +168724,7 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
           const attrCheck = await checkProjectAttribution(
             entityName,
             project.id,
-            filterReadableObservations(getAllObservations(), reader)
+            filterReadableObservations(getAllObservations(), reader2)
           );
           if (attrCheck.suspicious) {
             reasoningAttributionWarning = `
@@ -168335,11 +168873,11 @@ ${result.formatted}` }]
     },
     async ({ query, dryRun }) => {
       const { getAllObservations: getAllObservations2, resolveObservations: resolveObservations2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
-      const reader = getObservationReader();
+      const reader2 = getObservationReader();
       const allObs = await withFreshIndex(() => filterReadableObservations(
         getAllObservations2().filter((o) => (o.status ?? "active") === "active" && o.projectId === project.id),
-        reader
-      ).filter((observation) => canManageObservation(observation, reader)));
+        reader2
+      ).filter((observation) => canManageObservation(observation, reader2)));
       if (allObs.length < 2) {
         return { content: [{ type: "text", text: "Not enough active memories to deduplicate." }] };
       }
@@ -168353,7 +168891,7 @@ ${result.formatted}` }]
       }
       let candidates;
       if (query) {
-        const searchResult = await compactSearch({ query, limit: 20, projectId: project.id, status: "active", reader });
+        const searchResult = await compactSearch({ query, limit: 20, projectId: project.id, status: "active", reader: reader2 });
         const idSet = new Set(searchResult.entries.map((e2) => e2.id));
         candidates = allObs.filter((o) => idSet.has(o.id));
       } else {
@@ -168362,64 +168900,33 @@ ${result.formatted}` }]
       if (candidates.length < 2) {
         return { content: [{ type: "text", text: "Not enough memories in scope to deduplicate." }] };
       }
-      const byEntity = /* @__PURE__ */ new Map();
-      for (const obs of candidates) {
-        const list = byEntity.get(obs.entityName) ?? [];
-        list.push(obs);
-        byEntity.set(obs.entityName, list);
-      }
-      const actions = [];
-      const toResolve = [];
-      for (const [entity, group] of byEntity) {
-        if (group.length < 2) continue;
-        for (let i2 = 0; i2 < group.length; i2++) {
-          for (let j = i2 + 1; j < group.length; j++) {
-            const newer = group[j];
-            const older = group[i2];
-            try {
-              const decision = await deduplicateMemory(
-                { title: newer.title, narrative: newer.narrative, facts: newer.facts },
-                [{ id: older.id, title: older.title, narrative: older.narrative, facts: older.facts.join("\n") }]
-              );
-              if (decision && decision.action === "UPDATE" && decision.targetId) {
-                actions.push(`[UPDATED] #${older.id} "${older.title}" \u2192 superseded by #${newer.id} (${decision.reason})${decision.usedLLM ? " [LLM]" : " [heuristic]"}`);
-                toResolve.push(older.id);
-              } else if (decision && decision.action === "NONE") {
-                actions.push(`[DELETE] #${newer.id} "${newer.title}" \u2192 redundant (${decision.reason})${decision.usedLLM ? " [LLM]" : " [heuristic]"}`);
-                toResolve.push(newer.id);
-              } else if (decision && decision.action === "DELETE") {
-                actions.push(`[ERROR] #${decision.targetId ?? older.id} \u2192 outdated (${decision.reason})${decision.usedLLM ? " [LLM]" : " [heuristic]"}`);
-                toResolve.push(decision.targetId ?? older.id);
-              }
-            } catch (dedupErr) {
-              actions.push(`[WARN] comparison failed: ${dedupErr?.message ?? dedupErr}`);
-            }
-          }
-        }
-      }
-      if (actions.length === 0) {
-        return { content: [{ type: "text", text: `[OK] Scanned ${candidates.length} memories across ${byEntity.size} entities \u2014 no duplicates found.` }] };
+      const manageableCandidates = candidates.filter((observation) => canManageObservation(observation, reader2));
+      const plan = await planMemoryDeduplication(manageableCandidates);
+      const actionLines = plan.actions.map(
+        (item) => `Resolve #${item.resolveId} "${item.resolveTitle}"; keep #${item.keepId} "${item.keepTitle}" (${item.reason})${item.usedLLM ? " [LLM]" : " [heuristic]"}`
+      );
+      if (actionLines.length === 0) {
+        return { content: [{ type: "text", text: `[OK] Scanned ${plan.scanned} memories across ${plan.entities} entities \u2014 no duplicates found.` }] };
       }
       if (dryRun) {
         return {
           content: [{
             type: "text",
-            text: `[SEARCH] DRY RUN \u2014 ${actions.length} action(s) found:
+            text: `[SEARCH] DRY RUN \u2014 ${actionLines.length} action(s) found:
 
-${actions.join("\n")}
+${actionLines.join("\n")}
 
 Run with dryRun=false to apply.`
           }]
         };
       }
-      const unique2 = [...new Set(toResolve)];
-      await resolveObservations2(unique2, "resolved");
+      const result = await applyDeduplicationPlan(getObservationStore(), project.id, plan.resolveIds, reader2);
       return {
         content: [{
           type: "text",
-          text: `[CLEANUP] Deduplicated: resolved ${unique2.length} memory(ies)
+          text: `[CLEANUP] Deduplicated: resolved ${result.resolved.length} memory(ies)
 
-${actions.join("\n")}`
+${actionLines.join("\n")}`
         }]
       };
     }
@@ -168527,8 +169034,8 @@ ${actions.join("\n")}`
           formatted.push(JSON.stringify({ durableMemory: details }, null, 2));
         }
         if (observationTypedRefs.length > 0 || safeRefs.length > 0 || safeIds.length > 0) {
-          const reader = getObservationReader(hasCrossProjectRef ? "global" : "project");
-          const result = observationTypedRefs.length > 0 ? await compactDetail(observationTypedRefs, { reader }) : safeRefs.length > 0 ? await compactDetail(safeRefs, { reader }) : await compactDetail(safeIds.map((id) => ({ id, projectId: project.id })), { reader });
+          const reader2 = getObservationReader(hasCrossProjectRef ? "global" : "project");
+          const result = observationTypedRefs.length > 0 ? await compactDetail(observationTypedRefs, { reader: reader2 }) : safeRefs.length > 0 ? await compactDetail(safeRefs, { reader: reader2 }) : await compactDetail(safeIds.map((id) => ({ id, projectId: project.id })), { reader: reader2 });
           formatted.push(
             result.documents.length > 0 ? result.formatted : observationTypedRefs.length > 0 ? `No memories found for refs: ${observationTypedRefs.join(", ")}` : safeRefs.length > 0 ? `No memories found for refs: ${safeRefs.map((ref) => `${ref.projectId ?? "current"}#${ref.id}`).join(", ")}` : `No memories found for IDs: ${safeIds.join(", ")}`
           );
@@ -168561,10 +169068,10 @@ ${actions.join("\n")}`
       const { getDb: getDb2 } = await Promise.resolve().then(() => (init_orama_store(), orama_store_exports));
       const { search: search2 } = await import("@orama/orama");
       const { getAllObservations: getAllObservations2, resolveObservations: resolveObservations2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
-      const reader = getObservationReader();
+      const reader2 = getObservationReader();
       const allObs = await withFreshIndex(() => filterReadableObservations(
         getAllObservations2().filter((observation) => observation.projectId === project.id),
-        reader
+        reader2
       ));
       const accessMap = /* @__PURE__ */ new Map();
       try {
@@ -168614,7 +169121,7 @@ ${actions.join("\n")}`
       }
       if (action === "archive") {
         const managedIds = new Set(
-          allObs.filter((observation) => canManageObservation(observation, reader)).map((observation) => observation.id)
+          allObs.filter((observation) => canManageObservation(observation, reader2)).map((observation) => observation.id)
         );
         const candidates2 = getArchiveCandidates2(docs).filter((document2) => managedIds.has(document2.observationId));
         if (candidates2.length === 0) {
@@ -169328,10 +169835,10 @@ ${skill2.content}` }]
       }
       const { getAllObservations: getAllObservations2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
       const allObs = await withFreshIndex(() => getAllObservations2());
-      const reader = getObservationReader();
+      const reader2 = getObservationReader();
       const matched = filterReadableObservations(
         allObs.filter((observation) => observation.projectId === project.id && observationIds.includes(observation.id)),
-        reader
+        reader2
       );
       if (matched.length === 0) {
         return { content: [{ type: "text", text: `No observations found for IDs: [${observationIds.join(", ")}]. Use \`memorix_search\` to find valid IDs.` }], isError: true };
@@ -171039,6 +171546,7 @@ var init_server2 = __esm({
     init_tool_profile();
     init_provider2();
     init_memory_manager();
+    init_deduplication();
     init_formation();
     init_formation_timeout();
     init_timeout();
@@ -171217,7 +171725,7 @@ var init_serve_shared = __esm({
 
 // src/cli/version.ts
 function getCliVersion() {
-  return true ? "1.6.3" : pkg.version;
+  return true ? "1.7.1" : pkg.version;
 }
 var init_version3 = __esm({
   "src/cli/version.ts"() {