memorix 1.6.3 → 1.7.1

package/dist/cli/index.js

@@ -3232,7 +3232,7 @@ ${import_picocolors.default.gray(m3)}  ${s4}
 
 // src/cli/version.ts
 function getCliVersion() {
-  return true ? "1.6.3" : pkg.version;
+  return true ? "1.7.1" : pkg.version;
 }
 var init_version = __esm({
   "src/cli/version.ts"() {
@@ -13242,29 +13242,29 @@ function sharedAgentIds(record2) {
     return [];
   }
 }
-function canReadObservation(record2, reader) {
-  if (!reader) return true;
-  const sameProject = reader.projectId === record2.projectId;
+function canReadObservation(record2, reader2) {
+  if (!reader2) return true;
+  const sameProject = reader2.projectId === record2.projectId;
   const visibility = resolveObservationVisibility(record2);
-  if (visibility === "project") return !reader.projectId || sameProject;
-  if (!sameProject || !reader.agentId) return false;
-  if (visibility === "team") return reader.isTeamMember === true;
-  return record2.createdByAgentId === reader.agentId || sharedAgentIds(record2).includes(reader.agentId);
-}
-function canManageObservation(record2, reader) {
-  if (!reader) return true;
-  if (!reader.projectId || reader.projectId !== record2.projectId) return false;
+  if (visibility === "project") return !reader2.projectId || sameProject;
+  if (!sameProject || !reader2.agentId) return false;
+  if (visibility === "team") return reader2.isTeamMember === true;
+  return record2.createdByAgentId === reader2.agentId || sharedAgentIds(record2).includes(reader2.agentId);
+}
+function canManageObservation(record2, reader2) {
+  if (!reader2) return true;
+  if (!reader2.projectId || reader2.projectId !== record2.projectId) return false;
   switch (resolveObservationVisibility(record2)) {
     case "project":
       return true;
     case "team":
-      return reader.isTeamMember === true;
+      return reader2.isTeamMember === true;
     case "personal":
-      return Boolean(reader.agentId && record2.createdByAgentId === reader.agentId);
+      return Boolean(reader2.agentId && record2.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"() {
@@ -16171,8 +16171,8 @@ var require_int2 = __commonJS({
     var stringifyNumber = require_stringifyNumber();
     var intIdentify = (value) => typeof value === "bigint" || Number.isInteger(value);
     function intResolve(str2, offset, radix, { intAsBigInt }) {
-      const sign = str2[0];
-      if (sign === "-" || sign === "+")
+      const sign2 = str2[0];
+      if (sign2 === "-" || sign2 === "+")
         offset += 1;
       str2 = str2.substring(offset).replace(/_/g, "");
       if (intAsBigInt) {
@@ -16188,10 +16188,10 @@ var require_int2 = __commonJS({
             break;
         }
         const n4 = BigInt(str2);
-        return sign === "-" ? BigInt(-1) * n4 : n4;
+        return sign2 === "-" ? BigInt(-1) * n4 : n4;
       }
       const n3 = parseInt(str2, radix);
-      return sign === "-" ? -1 * n3 : n3;
+      return sign2 === "-" ? -1 * n3 : n3;
     }
     function intStringify(node, radix, prefix) {
       const { value } = node;
@@ -16340,11 +16340,11 @@ var require_timestamp = __commonJS({
     init_esm_shims();
     var stringifyNumber = require_stringifyNumber();
     function parseSexagesimal(str2, asBigInt) {
-      const sign = str2[0];
-      const parts = sign === "-" || sign === "+" ? str2.substring(1) : str2;
+      const sign2 = str2[0];
+      const parts = sign2 === "-" || sign2 === "+" ? str2.substring(1) : str2;
       const num = (n3) => asBigInt ? BigInt(n3) : Number(n3);
       const res = parts.replace(/_/g, "").split(":").reduce((res2, p3) => res2 * num(60) + num(p3), num(0));
-      return sign === "-" ? num(-1) * res : res;
+      return sign2 === "-" ? num(-1) * res : res;
     }
     function stringifySexagesimal(node) {
       let { value } = node;
@@ -16353,9 +16353,9 @@ var require_timestamp = __commonJS({
         num = (n3) => BigInt(n3);
       else if (isNaN(value) || !isFinite(value))
         return stringifyNumber.stringifyNumber(node);
-      let sign = "";
+      let sign2 = "";
       if (value < 0) {
-        sign = "-";
+        sign2 = "-";
         value *= num(-1);
       }
       const _60 = num(60);
@@ -16370,7 +16370,7 @@ var require_timestamp = __commonJS({
           parts.unshift(value);
         }
       }
-      return sign + parts.map((n3) => String(n3).padStart(2, "0")).join(":").replace(/000000\d*$/, "");
+      return sign2 + parts.map((n3) => String(n3).padStart(2, "0")).join(":").replace(/000000\d*$/, "");
     }
     var intTime = {
       identify: (value) => typeof value === "bigint" || Number.isInteger(value),
@@ -24056,8 +24056,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();
   }
@@ -24065,19 +24065,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(decoder2.decode(value, { stream: true }));
@@ -24087,7 +24087,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) {
@@ -24417,8 +24417,8 @@ async function* callOpenAIWithToolsStream(messages, tools) {
     const error40 = await response.text().catch(() => "unknown error");
     throw new Error(`LLM streaming API error (${response.status}): ${error40}`);
   }
-  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 decoder2 = new TextDecoder();
   let fullContent = "";
   const toolCallMap = /* @__PURE__ */ new Map();
@@ -24426,7 +24426,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 += decoder2.decode(value, { stream: true });
       const lines = buffer.split("\n");
@@ -24468,7 +24468,7 @@ async function* callOpenAIWithToolsStream(messages, tools) {
       }
     }
   } finally {
-    reader.releaseLock();
+    reader2.releaseLock();
   }
   const toolCalls = [...toolCallMap.values()].map((tc2) => ({
     id: tc2.id,
@@ -24549,8 +24549,8 @@ async function* callAnthropicWithToolsStream(messages, tools) {
     const error40 = await response.text().catch(() => "unknown error");
     throw new Error(`Anthropic streaming API error (${response.status}): ${error40}`);
   }
-  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 decoder2 = new TextDecoder();
   let fullContent = "";
   const toolCalls = [];
@@ -24561,7 +24561,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 += decoder2.decode(value, { stream: true });
       const lines = buffer.split("\n");
@@ -24609,7 +24609,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 {
@@ -36248,12 +36248,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)
@@ -36265,7 +36265,7 @@ async function readBoundedImageResponse(response) {
       chunks.push(value);
     }
   } finally {
-    reader.releaseLock();
+    reader2.releaseLock();
   }
   return Buffer.concat(chunks);
 }
@@ -36789,22 +36789,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 (e5) {
-        reader.releaseLock();
+        reader2.releaseLock();
         throw e5;
       }
     },
     async return() {
-      const cancelPromise = reader.cancel();
-      reader.releaseLock();
+      const cancelPromise = reader2.cancel();
+      reader2.releaseLock();
       await cancelPromise;
       return { done: true, value: void 0 };
     },
@@ -36820,9 +36820,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({
@@ -39561,31 +39561,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;
         });
@@ -40544,31 +40544,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;
         });
@@ -42833,31 +42833,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;
         });
@@ -63573,22 +63573,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 (e5) {
-        reader.releaseLock();
+        reader2.releaseLock();
         throw e5;
       }
     },
     async return() {
-      const cancelPromise = reader.cancel();
-      reader.releaseLock();
+      const cancelPromise = reader2.cancel();
+      reader2.releaseLock();
       await cancelPromise;
       return { done: true, value: void 0 };
     },
@@ -63604,9 +63604,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({
@@ -66633,31 +66633,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;
         });
@@ -69069,31 +69069,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;
         });
@@ -70763,7 +70763,7 @@ function consumeLine(text2) {
   };
 }
 async function* iterateSseMessages(body, signal) {
-  const reader = body.getReader();
+  const reader2 = body.getReader();
   const decoder2 = new TextDecoder();
   const state = { event: null, data: [], raw: [] };
   let buffer = "";
@@ -70772,7 +70772,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;
       }
@@ -70808,7 +70808,7 @@ async function* iterateSseMessages(body, signal) {
       yield trailingEvent;
     }
   } finally {
-    reader.releaseLock();
+    reader2.releaseLock();
   }
 }
 async function* iterateAnthropicEvents(response, signal) {
@@ -73651,7 +73651,7 @@ var require_supports_color = __commonJS({
         return 1;
       }
       if ("CI" in env3) {
-        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE", "DRONE"].some((sign) => sign in env3) || env3.CI_NAME === "codeship") {
+        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE", "DRONE"].some((sign2) => sign2 in env3) || env3.CI_NAME === "codeship") {
           return 1;
         }
         return min;
@@ -74580,68 +74580,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((resolve6, reject) => {
-          reader._closedPromise_resolve = resolve6;
-          reader._closedPromise_reject = reject;
+      function defaultReaderClosedPromiseInitialize(reader2) {
+        reader2._closedPromise = newPromise((resolve6, reject) => {
+          reader2._closedPromise_resolve = resolve6;
+          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(x5) {
         return typeof x5 === "number" && isFinite(x5);
@@ -74718,8 +74718,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 {
@@ -74730,11 +74730,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;
@@ -74840,8 +74840,8 @@ var require_ponyfill_es2018 = __commonJS({
         }
         return x5 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();
@@ -74851,14 +74851,14 @@ var require_ponyfill_es2018 = __commonJS({
           stream2._readableStreamController[PullSteps](readRequest);
         }
       }
-      function ReadableStreamDefaultReaderRelease(reader) {
-        ReadableStreamReaderGenericRelease(reader);
+      function ReadableStreamDefaultReaderRelease(reader2) {
+        ReadableStreamReaderGenericRelease(reader2);
         const e5 = new TypeError("Reader was released");
-        ReadableStreamDefaultReaderErrorReadRequests(reader, e5);
+        ReadableStreamDefaultReaderErrorReadRequests(reader2, e5);
       }
-      function ReadableStreamDefaultReaderErrorReadRequests(reader, e5) {
-        const readRequests = reader._readRequests;
-        reader._readRequests = new SimpleQueue();
+      function ReadableStreamDefaultReaderErrorReadRequests(reader2, e5) {
+        const readRequests = reader2._readRequests;
+        reader2._readRequests = new SimpleQueue();
         readRequests.forEach((readRequest) => {
           readRequest._errorSteps(e5);
         });
@@ -74869,10 +74869,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() {
@@ -74888,7 +74888,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 promise2 = newPromise((resolve6, reject) => {
@@ -74903,17 +74903,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 promise2;
         }
         _returnSteps(value) {
@@ -74921,13 +74921,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 });
         }
       }
@@ -74947,8 +74947,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;
@@ -75452,12 +75452,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);
         }
       }
@@ -75817,8 +75817,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 {
@@ -75829,11 +75829,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;
@@ -75966,8 +75966,8 @@ var require_ponyfill_es2018 = __commonJS({
         }
         return x5 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);
@@ -75975,14 +75975,14 @@ var require_ponyfill_es2018 = __commonJS({
           ReadableByteStreamControllerPullInto(stream2._readableStreamController, view, min, readIntoRequest);
         }
       }
-      function ReadableStreamBYOBReaderRelease(reader) {
-        ReadableStreamReaderGenericRelease(reader);
+      function ReadableStreamBYOBReaderRelease(reader2) {
+        ReadableStreamReaderGenericRelease(reader2);
         const e5 = new TypeError("Reader was released");
-        ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e5);
+        ReadableStreamBYOBReaderErrorReadIntoRequests(reader2, e5);
       }
-      function ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e5) {
-        const readIntoRequests = reader._readIntoRequests;
-        reader._readIntoRequests = new SimpleQueue();
+      function ReadableStreamBYOBReaderErrorReadIntoRequests(reader2, e5) {
+        const readIntoRequests = reader2._readIntoRequests;
+        reader2._readIntoRequests = new SimpleQueue();
         readIntoRequests.forEach((readIntoRequest) => {
           readIntoRequest._errorSteps(e5);
         });
@@ -76997,7 +76997,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;
@@ -77050,7 +77050,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);
@@ -77061,7 +77061,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 {
@@ -77077,7 +77077,7 @@ var require_ponyfill_es2018 = __commonJS({
             }
             return null;
           });
-          isOrBecomesClosed(source, reader._closedPromise, () => {
+          isOrBecomesClosed(source, reader2._closedPromise, () => {
             if (!preventClose) {
               shutdownWithAction(() => WritableStreamDefaultWriterCloseWithErrorPropagation(writer));
             } else {
@@ -77140,7 +77140,7 @@ var require_ponyfill_es2018 = __commonJS({
           }
           function finalize(isError, error40) {
             WritableStreamDefaultWriterRelease(writer);
-            ReadableStreamReaderGenericRelease(reader);
+            ReadableStreamReaderGenericRelease(reader2);
             if (signal !== void 0) {
               signal.removeEventListener("abort", abortAlgorithm);
             }
@@ -77418,7 +77418,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;
@@ -77471,7 +77471,7 @@ var require_ponyfill_es2018 = __commonJS({
               reading = false;
             }
           };
-          ReadableStreamDefaultReaderRead(reader, readRequest);
+          ReadableStreamDefaultReaderRead(reader2, readRequest);
           return promiseResolvedWith(void 0);
         }
         function cancel1Algorithm(reason) {
@@ -77498,7 +77498,7 @@ var require_ponyfill_es2018 = __commonJS({
         }
         branch1 = CreateReadableStream(startAlgorithm, pullAlgorithm, cancel1Algorithm);
         branch2 = CreateReadableStream(startAlgorithm, pullAlgorithm, cancel2Algorithm);
-        uponRejection(reader._closedPromise, (r6) => {
+        uponRejection(reader2._closedPromise, (r6) => {
           ReadableStreamDefaultControllerError(branch1._readableStreamController, r6);
           ReadableStreamDefaultControllerError(branch2._readableStreamController, r6);
           if (!canceled1 || !canceled2) {
@@ -77509,7 +77509,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;
@@ -77525,7 +77525,7 @@ var require_ponyfill_es2018 = __commonJS({
         });
         function forwardReaderError(thisReader) {
           uponRejection(thisReader._closedPromise, (r6) => {
-            if (thisReader !== reader) {
+            if (thisReader !== reader2) {
               return null;
             }
             ReadableByteStreamControllerError(branch1._readableStreamController, r6);
@@ -77537,10 +77537,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) => {
@@ -77595,13 +77595,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;
@@ -77663,7 +77663,7 @@ var require_ponyfill_es2018 = __commonJS({
               reading = false;
             }
           };
-          ReadableStreamBYOBReaderRead(reader, view, 1, readIntoRequest);
+          ReadableStreamBYOBReaderRead(reader2, view, 1, readIntoRequest);
         }
         function pull1Algorithm() {
           if (reading) {
@@ -77718,7 +77718,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) {
@@ -77783,13 +77783,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 (e5) {
             return promiseRejectedWith(e5);
           }
@@ -77807,7 +77807,7 @@ var require_ponyfill_es2018 = __commonJS({
         }
         function cancelAlgorithm(reason) {
           try {
-            return promiseResolvedWith(reader.cancel(reason));
+            return promiseResolvedWith(reader2.cancel(reason));
           } catch (e5) {
             return promiseRejectedWith(e5);
           }
@@ -78095,10 +78095,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);
           });
@@ -78108,14 +78108,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();
           });
@@ -78124,15 +78124,15 @@ var require_ponyfill_es2018 = __commonJS({
       function ReadableStreamError(stream2, e5) {
         stream2._state = "errored";
         stream2._storedError = e5;
-        const reader = stream2._reader;
-        if (reader === void 0) {
+        const reader2 = stream2._reader;
+        if (reader2 === void 0) {
           return;
         }
-        defaultReaderClosedPromiseReject(reader, e5);
-        if (IsReadableStreamDefaultReader(reader)) {
-          ReadableStreamDefaultReaderErrorReadRequests(reader, e5);
+        defaultReaderClosedPromiseReject(reader2, e5);
+        if (IsReadableStreamDefaultReader(reader2)) {
+          ReadableStreamDefaultReaderErrorReadRequests(reader2, e5);
         } else {
-          ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e5);
+          ReadableStreamBYOBReaderErrorReadIntoRequests(reader2, e5);
         }
       }
       function streamBrandCheckException$1(name) {
@@ -81772,7 +81772,7 @@ var require_bignumber = __commonJS({
             }
             return arr.reverse();
           }
-          return function(str2, baseIn, baseOut, sign, callerIsToString) {
+          return function(str2, baseIn, baseOut, sign2, callerIsToString) {
             var alphabet, d4, e5, k6, r6, x5, xc, y6, i4 = str2.indexOf("."), dp = DECIMAL_PLACES, rm3 = ROUNDING_MODE;
             if (i4 >= 0) {
               k6 = POW_PRECISION;
@@ -81798,7 +81798,7 @@ var require_bignumber = __commonJS({
             } else {
               x5.c = xc;
               x5.e = e5;
-              x5.s = sign;
+              x5.s = sign2;
               x5 = div(x5, y6, dp, rm3, baseOut);
               xc = x5.c;
               r6 = x5.r;
@@ -86017,7 +86017,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);
@@ -86026,25 +86026,25 @@ var require_jwa = __commonJS({
       };
     }
     var bufferEqual;
-    var timingSafeEqual = "timingSafeEqual" in crypto2 ? function timingSafeEqual2(a4, b4) {
+    var timingSafeEqual2 = "timingSafeEqual" in crypto2 ? function timingSafeEqual3(a4, b4) {
       if (a4.byteLength !== b4.byteLength) {
         return false;
       }
       return crypto2.timingSafeEqual(a4, b4);
-    } : function timingSafeEqual2(a4, b4) {
+    } : function timingSafeEqual3(a4, b4) {
       if (!bufferEqual) {
         bufferEqual = require_buffer_equal_constant_time();
       }
       return bufferEqual(a4, b4);
     };
     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);
@@ -86053,7 +86053,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);
@@ -86063,7 +86063,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);
@@ -86076,7 +86076,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);
@@ -86091,7 +86091,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;
@@ -86099,19 +86099,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 === "";
       };
     }
@@ -86212,7 +86212,7 @@ var require_sign_stream = __commonJS({
       }.bind(this));
     }
     util2.inherits(SignStream, Stream7);
-    SignStream.prototype.sign = function sign() {
+    SignStream.prototype.sign = function sign2() {
       try {
         var signature = jwsSign({
           header: this.header,
@@ -86331,7 +86331,7 @@ var require_verify_stream = __commonJS({
       }.bind(this));
     }
     util2.inherits(VerifyStream, Stream7);
-    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);
@@ -88688,14 +88688,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) {
@@ -88739,7 +88739,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.
@@ -90724,8 +90724,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) {
@@ -93408,7 +93408,7 @@ var require_websocket = __commonJS({
     var http3 = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes: randomBytes2, createHash: createHash20 } = __require("crypto");
+    var { randomBytes: randomBytes3, createHash: createHash20 } = __require("crypto");
     var { Duplex, Readable: Readable3 } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -93946,7 +93946,7 @@ var require_websocket = __commonJS({
         }
       }
       const defaultPort = isSecure ? 443 : 80;
-      const key = randomBytes2(16).toString("base64");
+      const key = randomBytes3(16).toString("base64");
       const request = isSecure ? https2.request : http3.request;
       const protocolSet = /* @__PURE__ */ new Set();
       let perMessageDeflate;
@@ -104257,22 +104257,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 (e5) {
-        reader.releaseLock();
+        reader2.releaseLock();
         throw e5;
       }
     },
     async return() {
-      const cancelPromise = reader.cancel();
-      reader.releaseLock();
+      const cancelPromise = reader2.cancel();
+      reader2.releaseLock();
       await cancelPromise;
       return { done: true, value: void 0 };
     },
@@ -104289,9 +104289,9 @@ async function CancelReadableStream3(stream2) {
     await ((_b = (_a6 = stream2[Symbol.asyncIterator]()).return) === null || _b === void 0 ? void 0 : _b.call(_a6));
     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) {
@@ -108165,9 +108165,9 @@ var init_node = __esm({
       processStreamResponse(response) {
         return __asyncGenerator(this, arguments, function* processStreamResponse_1() {
           var _a6;
-          const reader = (_a6 = response === null || response === void 0 ? void 0 : response.body) === null || _a6 === void 0 ? void 0 : _a6.getReader();
+          const reader2 = (_a6 = response === null || response === void 0 ? void 0 : response.body) === null || _a6 === void 0 ? void 0 : _a6.getReader();
           const decoder2 = new TextDecoder("utf-8");
-          if (!reader) {
+          if (!reader2) {
             throw new Error("Response body is empty");
           }
           try {
@@ -108175,7 +108175,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");
@@ -108239,7 +108239,7 @@ var init_node = __esm({
               }
             }
           } finally {
-            reader.releaseLock();
+            reader2.releaseLock();
           }
         });
       }
@@ -113947,12 +113947,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 {
@@ -140774,24 +140774,24 @@ var init_event_streams = __esm({
         const fn2 = ReadableStream.prototype[Symbol.asyncIterator];
         if (typeof fn2 === "function")
           return fn2.call(this);
-        const reader = this.getReader();
+        const reader2 = this.getReader();
         return {
           next: async () => {
-            const r6 = await reader.read();
+            const r6 = await reader2.read();
             if (r6.done) {
-              reader.releaseLock();
+              reader2.releaseLock();
               return { done: true, value: void 0 };
             }
             return { done: false, value: r6.value };
           },
           throw: async (e5) => {
-            await reader.cancel(e5);
-            reader.releaseLock();
+            await reader2.cancel(e5);
+            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]() {
@@ -168438,11 +168438,11 @@ function normalizeCodexStatus(status) {
 async function* parseSSE(response, signal) {
   if (!response.body)
     return;
-  const reader = response.body.getReader();
+  const reader2 = response.body.getReader();
   const decoder2 = new TextDecoder();
   let buffer = "";
   const onAbort = () => {
-    void reader.cancel().catch(() => {
+    void reader2.cancel().catch(() => {
     });
   };
   signal?.addEventListener("abort", onAbort, { once: true });
@@ -168451,7 +168451,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");
       }
@@ -168482,11 +168482,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 {
     }
   }
@@ -177249,12 +177249,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;
@@ -177262,7 +177262,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);
@@ -178111,7 +178111,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 store2 = getObservationStore();
   if (projectId) {
     let afterId;
@@ -178122,13 +178122,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 store2.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 store2.atomic(async (tx) => {
@@ -178588,21 +178588,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";
@@ -178988,14 +178988,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 store2 = await createStore(input.dataDir);
-  const eligible = store2.list({ limit: 1e3 }).filter((memory) => isEligibleLongTermMemory(memory) && canReadLongTermMemory(memory, reader));
+  const eligible = store2.list({ limit: 1e3 }).filter((memory) => isEligibleLongTermMemory(memory) && canReadLongTermMemory(memory, reader2));
   let selected = eligible.map((memory) => {
     const ranked = scoreForTask(memory, task);
     return ranked ? {
@@ -185899,11 +185899,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((o4) => o4.projectId === projectId) : rawObs).filter((observation) => canReadObservation(observation, reader));
+  const allObs = (projectId ? rawObs.filter((o4) => o4.projectId === projectId) : rawObs).filter((observation) => canReadObservation(observation, reader2));
   const sorted = allObs.sort((a4, b4) => a4.createdAt.localeCompare(b4.createdAt));
   const anchorIndex = sorted.findIndex((o4) => o4.id === anchorId);
   if (anchorIndex === -1) {
@@ -186410,8 +186410,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,
@@ -188058,7 +188058,7 @@ async function askMemoryQuestion(question, history = []) {
       warning: "No project detected \u2014 memory tools unavailable."
     };
   }
-  const { project, dataDir, reader, identity } = operatorContext;
+  const { project, dataDir, reader: reader2, identity } = operatorContext;
   loadDotenv(project.rootPath);
   initLLM({ scope: "agent" });
   await prepareProjectSearch(project.id, dataDir);
@@ -188069,11 +188069,11 @@ async function askMemoryQuestion(question, history = []) {
       limit: SEARCH_LIMIT,
       projectId: project.id,
       status: "active",
-      reader
+      reader: reader2
     });
     const topEntries = searchResult.entries.slice(0, DETAIL_LIMIT);
     const detailRefs = topEntries.map((entry) => ({ id: entry.id, projectId: project.id }));
-    const detailResult = detailRefs.length > 0 ? await compactDetail(detailRefs, { reader }) : { documents: [], formatted: "", totalTokens: 0 };
+    const detailResult = detailRefs.length > 0 ? await compactDetail(detailRefs, { reader: reader2 }) : { documents: [], formatted: "", totalTokens: 0 };
     const sources2 = detailResult.documents.map((doc, index) => toSource(doc, topEntries[index]?.score ?? 0));
     return {
       question: trimmedQuestion,
@@ -188094,7 +188094,7 @@ async function askMemoryQuestion(question, history = []) {
   messages.push({ role: "user", content: trimmedQuestion });
   const ctx = {
     projectId: project.id,
-    reader,
+    reader: reader2,
     ...identity ? { writerAgentId: identity.agentId } : {},
     collectedSources: []
   };
@@ -188190,7 +188190,7 @@ async function askMemoryQuestionStream(question, history = [], callbacks, signal
       warning: "No project detected \u2014 memory tools unavailable."
     };
   }
-  const { project, dataDir, reader, identity } = operatorContext;
+  const { project, dataDir, reader: reader2, identity } = operatorContext;
   loadDotenv(project.rootPath);
   initLLM({ scope: "agent" });
   await prepareProjectSearch(project.id, dataDir);
@@ -188201,11 +188201,11 @@ async function askMemoryQuestionStream(question, history = [], callbacks, signal
       limit: SEARCH_LIMIT,
       projectId: project.id,
       status: "active",
-      reader
+      reader: reader2
     });
     const topEntries = searchResult.entries.slice(0, DETAIL_LIMIT);
     const detailRefs = topEntries.map((entry) => ({ id: entry.id, projectId: project.id }));
-    const detailResult = detailRefs.length > 0 ? await compactDetail(detailRefs, { reader }) : { documents: [], formatted: "", totalTokens: 0 };
+    const detailResult = detailRefs.length > 0 ? await compactDetail(detailRefs, { reader: reader2 }) : { documents: [], formatted: "", totalTokens: 0 };
     const sources2 = detailResult.documents.map((doc, index) => toSource(doc, topEntries[index]?.score ?? 0));
     return {
       question: trimmedQuestion,
@@ -188226,7 +188226,7 @@ async function askMemoryQuestionStream(question, history = [], callbacks, signal
   messages.push({ role: "user", content: trimmedQuestion });
   const ctx = {
     projectId: project.id,
-    reader,
+    reader: reader2,
     ...identity ? { writerAgentId: identity.agentId } : {},
     collectedSources: []
   };
@@ -188445,7 +188445,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,
@@ -188485,7 +188485,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) {
@@ -188499,7 +188499,7 @@ function auditMemoryQuality(observations2, options) {
       lowEvidence,
       hookNoise,
       orphans,
-      retentionCandidates
+      retentionCandidates: retentionCandidates2
     },
     recommendations
   };
@@ -189011,6 +189011,125 @@ var init_graph_context = __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(store2, projectId, resolveIds, reader2 = { projectId }) {
+  const uniqueIds = [...new Set(resolveIds)];
+  const manageable = [];
+  const skipped = [];
+  for (const id of uniqueIds) {
+    const observation = await store2.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 store2.atomic(async (tx) => {
+    const updates = await Promise.all(manageable.map((id) => tx.setStatus(id, "resolved", "active")));
+    return manageable.filter((_5, 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/store/session-store.ts
 var session_store_exports = {};
 __export(session_store_exports, {
@@ -189538,7 +189657,9 @@ var init_memory3 = __esm({
     init_freshness();
     init_observations();
     init_graph_context();
+    init_deduplication();
     init_visibility();
+    init_obs_store();
     init_operator_shared();
     memory_default = defineCommand({
       meta: {
@@ -189595,7 +189716,7 @@ var init_memory3 = __esm({
           const needsSearchIndex = action === "search" || action === "detail" || action === "timeline";
           const longTermReadOnly = longTermAction === "list" || longTermAction === "show";
           const context = readOnlyActions.has(action) || longTermReadOnly ? await getCliReadContext({ searchIndex: needsSearchIndex }) : await getCliProjectContext({ searchIndex: true });
-          const { project, dataDir, reader, identity } = context;
+          const { project, dataDir, reader: reader2, identity } = context;
           switch (action) {
             case "search": {
               const query = getStringArg(args.query, positional);
@@ -189605,7 +189726,7 @@ var init_memory3 = __esm({
               }
               const limit2 = parsePositiveInt(args.limit, 10);
               const quality = coerceRetrievalQuality(args.quality);
-              const result = await compactSearch({ query, limit: limit2, quality, projectId: project.id, reader }, "cli");
+              const result = await compactSearch({ query, limit: limit2, quality, projectId: project.id, reader: reader2 }, "cli");
               emitResult({ project, entries: result.entries }, result.formatted, asJson);
               return;
             }
@@ -189615,7 +189736,7 @@ var init_memory3 = __esm({
                 emitError('query is required for "memorix memory graph-context"', asJson);
                 return;
               }
-              const observations2 = filterReadableObservations(getAllObservations(), reader);
+              const observations2 = filterReadableObservations(getAllObservations(), reader2);
               const packet = buildGraphContextPacket(observations2, {
                 projectId: project.id,
                 query,
@@ -189637,7 +189758,7 @@ var init_memory3 = __esm({
             }
             case "recent": {
               const limit2 = parsePositiveInt(args.limit, 10);
-              const observations2 = filterReadableObservations(getProjectObservations(project.id), reader).filter((obs) => (obs.status ?? "active") === "active").slice(-limit2).reverse();
+              const observations2 = filterReadableObservations(getProjectObservations(project.id), reader2).filter((obs) => (obs.status ?? "active") === "active").slice(-limit2).reverse();
               emitResult(
                 { project, observations: observations2 },
                 observations2.length === 0 ? "No active observations." : observations2.map((obs) => `- #${obs.id} ${obs.title}`).join("\n"),
@@ -189655,7 +189776,7 @@ var init_memory3 = __esm({
               const type = coerceObservationType(args.type);
               const topicKey = asStringArg(args.topicKey) || suggestTopicKey(type, title) || void 0;
               const writeScope = resolveCliWriteScope(
-                { reader, identity },
+                { reader: reader2, identity },
                 args.visibility
               );
               const result = await storeObservation({
@@ -189703,7 +189824,7 @@ var init_memory3 = __esm({
                 const numericId = Number.parseInt(ref, 10);
                 return Number.isFinite(numericId) && String(numericId) === ref.trim() ? `obs:${numericId}@${project.id}` : ref;
               });
-              const result = await compactDetail(scopedRefs, { reader });
+              const result = await compactDetail(scopedRefs, { reader: reader2 });
               if (scopedRefs.length === 1 && result.documents.length === 0) {
                 emitError(`No readable memory found for ${scopedRefs[0]}.`, asJson);
                 return;
@@ -189725,7 +189846,7 @@ var init_memory3 = __esm({
                 project.id,
                 parsePositiveInt(args.before, 3),
                 parsePositiveInt(args.after, 3),
-                reader,
+                reader2,
                 "cli"
               );
               if (!result.timeline.anchorEntry) {
@@ -189744,7 +189865,7 @@ var init_memory3 = __esm({
               const status = coerceObservationStatus(args.status);
               const authorizedIds = ids.filter((id) => {
                 const observation = getObservation(id, project.id);
-                return observation ? canManageObservation(observation, reader) : false;
+                return observation ? canManageObservation(observation, reader2) : false;
               });
               if (authorizedIds.length === 0) {
                 emitError("No requested observations are manageable with the active CLI scope.", asJson);
@@ -189780,12 +189901,11 @@ var init_memory3 = __esm({
                 );
                 return;
               }
-              const { deduplicateMemory: deduplicateMemory2 } = await Promise.resolve().then(() => (init_memory_manager(), memory_manager_exports));
               const allObs = await withFreshIndex(
                 () => filterReadableObservations(
                   getAllObservations().filter((obs) => (obs.status ?? "active") === "active" && obs.projectId === project.id),
-                  reader
-                )
+                  reader2
+                ).filter((observation) => canManageObservation(observation, reader2))
               );
               if (allObs.length < 2) {
                 emitResult({ project, actions: [], resolved: [] }, "Not enough active memories to deduplicate.", asJson);
@@ -189793,57 +189913,27 @@ var init_memory3 = __esm({
               }
               let candidates = allObs;
               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 ids = new Set(searchResult.entries.map((entry) => entry.id));
                 candidates = allObs.filter((obs) => ids.has(obs.id));
               } else {
                 candidates = allObs.slice(-20);
               }
-              const byEntity = /* @__PURE__ */ new Map();
-              for (const obs of candidates) {
-                const bucket = byEntity.get(obs.entityName) ?? [];
-                bucket.push(obs);
-                byEntity.set(obs.entityName, bucket);
-              }
-              const actions = [];
-              const toResolve = [];
-              for (const [, group] of byEntity) {
-                if (group.length < 2) continue;
-                for (let index = 0; index < group.length; index += 1) {
-                  for (let compareIndex = index + 1; compareIndex < group.length; compareIndex += 1) {
-                    const newer = group[compareIndex];
-                    const older = group[index];
-                    try {
-                      const decision = await deduplicateMemory2(
-                        { 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 === "DELETE" || decision.action === "UPDATE" || decision.action === "NONE")) {
-                        actions.push(`Resolve #${older.id} because it duplicates newer #${newer.id}`);
-                        toResolve.push(older.id);
-                      }
-                    } catch {
-                    }
-                  }
-                }
-              }
-              if (dryRun || toResolve.length === 0) {
+              const plan = await planMemoryDeduplication(candidates);
+              const actionLines = plan.actions.map(
+                (item) => `Resolve #${item.resolveId} "${item.resolveTitle}"; keep #${item.keepId} "${item.keepTitle}" (${item.reason})`
+              );
+              if (dryRun || plan.resolveIds.length === 0) {
                 emitResult(
-                  { project, actions, resolved: [], dryRun: true },
-                  actions.length === 0 ? "No duplicate candidates found." : actions.join("\n"),
+                  { project, plan, resolved: [], dryRun: true },
+                  actionLines.length === 0 ? "No duplicate candidates found." : actionLines.join("\n"),
                   asJson
                 );
                 return;
               }
-              const result = await resolveObservations(
-                [...new Set(toResolve)].filter((id) => {
-                  const observation = getObservation(id, project.id);
-                  return observation ? canManageObservation(observation, reader) : false;
-                }),
-                "resolved"
-              );
+              const result = await applyDeduplicationPlan(getObservationStore(), project.id, plan.resolveIds, reader2);
               emitResult(
-                { project, actions, resolved: result.resolved, notFound: result.notFound, dryRun: false },
+                { project, plan, resolved: result.resolved, skipped: result.skipped, dryRun: false },
                 `Resolved ${result.resolved.length} duplicate observation(s).`,
                 asJson
               );
@@ -189910,7 +190000,7 @@ var init_memory3 = __esm({
               const observations2 = await withFreshIndex(() => getAllObservations());
               const matched = filterReadableObservations(
                 observations2.filter((obs) => obs.projectId === project.id && ids.includes(obs.id)),
-                reader
+                reader2
               ).filter((observation) => resolveObservationVisibility(observation) === "project");
               if (matched.length === 0) {
                 emitError(`No project-visible observations found for IDs: ${ids.join(", ")}. Private and team records cannot be promoted into shared skills.`, asJson);
@@ -189947,8 +190037,8 @@ var init_memory3 = __esm({
               const longTermReader = {
                 projectId: project.id,
                 ...owner ? { ownerId: owner.id } : {},
-                ...reader.agentId ? { agentId: reader.agentId } : {},
-                ...reader.isTeamMember ? { isTeamMember: true } : {}
+                ...reader2.agentId ? { agentId: reader2.agentId } : {},
+                ...reader2.isTeamMember ? { isTeamMember: true } : {}
               };
               const memoryId = () => {
                 const id = asStringArg(args.id) || asStringArg(args.fromObservation) || longTermPositional[0]?.trim();
@@ -190028,7 +190118,7 @@ var init_memory3 = __esm({
                     return;
                   }
                   const observation = getObservation(observationId2, project.id);
-                  if (!observation || !canManageObservation(observation, reader)) {
+                  if (!observation || !canManageObservation(observation, reader2)) {
                     emitError("Observation was not found or is outside the active write scope.", asJson);
                     return;
                   }
@@ -197160,14 +197250,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) {
@@ -197186,13 +197276,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((a4, b4) => new Date(b4.endedAt || b4.startedAt).getTime() - new Date(a4.endedAt || a4.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) => ({
@@ -197303,13 +197393,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_PATTERNS.some((p3) => p3.test(summary)) || SYSTEM_SELF_PATTERNS.some((p3) => p3.test(summary));
@@ -197346,7 +197436,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();
@@ -198534,15 +198624,15 @@ var init_context2 = __esm({
         const asJson = !!args.json || !!args.briefJson;
         const task = args.task?.trim() || args.input?.trim() || void 0;
         try {
-          const { project, dataDir, reader } = await getCliProjectContext();
+          const { project, dataDir, reader: reader2 } = await getCliProjectContext();
           const context = await buildAutoProjectContext({
             project,
             dataDir,
-            observations: filterReadableObservations(getAllObservations(), reader),
+            observations: filterReadableObservations(getAllObservations(), reader2),
             task,
             agent: coerceAgentTarget(args.agent),
             refresh: coerceRefreshMode(args.refresh),
-            reader,
+            reader: reader2,
             ...args.resume ? { continuation: "always" } : {}
           });
           const detailed = {
@@ -198704,11 +198794,11 @@ var init_explain = __esm({
       run: async ({ args }) => {
         const asJson = !!args.json;
         try {
-          const { project, dataDir, reader } = await getCliProjectContext();
+          const { project, dataDir, reader: reader2 } = await getCliProjectContext();
           const context = await buildAutoProjectContext({
             project,
             dataDir,
-            observations: filterReadableObservations(getAllObservations(), reader),
+            observations: filterReadableObservations(getAllObservations(), reader2),
             refresh: coerceRefreshMode2(args.refresh)
           });
           emitResult(
@@ -199103,7 +199193,7 @@ var init_codegraph = __esm({
         const action = (positional[0] || args.action || "status").toLowerCase();
         const asJson = !!args.json || !!args.briefJson;
         try {
-          const { project, dataDir, reader } = await getCliProjectContext();
+          const { project, dataDir, reader: reader2 } = await getCliProjectContext();
           const store2 = new CodeGraphStore();
           await store2.init(dataDir);
           const explicitAction = Boolean(positional[0] || args.action);
@@ -199232,7 +199322,7 @@ ${formatUsageHint()}`;
               const limit2 = parsePositiveInt(args.limit, 20);
               const observations2 = filterReadableObservations(
                 getAllObservations().filter((obs) => obs.projectId === project.id && (obs.status ?? "active") === "active"),
-                reader
+                reader2
               ).reverse();
               const basePack = assembleContextPackForTask({
                 store: store2,
@@ -199272,7 +199362,7 @@ ${formatUsageHint()}`;
                 ...external.outline ? { semanticCode: external.outline } : {},
                 providerQuality: external.quality,
                 ...external.caution ? { runtimeCautions: [{ kind: "external-codegraph-fallback", message: external.caution }] } : {},
-                reader,
+                reader: reader2,
                 agent: coerceAgentTarget2(args.agent)
               });
               emitResult(
@@ -199899,7 +199989,7 @@ var init_reasoning = __esm({
         const action = args._?.[0] || "";
         const asJson = !!args.json;
         try {
-          const { project, reader, identity } = await getCliProjectContext({ searchIndex: action === "search" });
+          const { project, reader: reader2, identity } = await getCliProjectContext({ searchIndex: action === "search" });
           switch (action) {
             case "store": {
               const entityName = args.entity?.trim();
@@ -199930,7 +200020,7 @@ var init_reasoning = __esm({
                 narrativeParts.push(`Risks: ${risks.join("; ")}`);
               }
               const writeScope = resolveCliWriteScope(
-                { reader, identity },
+                { reader: reader2, identity },
                 args.visibility
               );
               const result = await storeObservation({
@@ -199976,7 +200066,7 @@ var init_reasoning = __esm({
                 type: "reasoning",
                 projectId: scope === "global" ? void 0 : project.id,
                 status: "active",
-                reader: scope === "global" ? {} : reader
+                reader: scope === "global" ? {} : reader2
               });
               emitResult(
                 { project, scope, entries: result.entries },
@@ -200052,10 +200142,10 @@ var init_retention2 = __esm({
         const action = args._?.[0] || "";
         const asJson = !!args.json;
         try {
-          const { project, dataDir, reader } = await getCliProjectContext();
+          const { project, dataDir, reader: reader2 } = await getCliProjectContext();
           const activeDocs = filterReadableObservations(
             getAllObservations().filter((obs) => obs.projectId === project.id && (obs.status ?? "active") === "active"),
-            reader
+            reader2
           ).map(toDocument);
           switch (action) {
             case "status": {
@@ -200076,7 +200166,7 @@ var init_retention2 = __esm({
               return;
             }
             case "archive": {
-              const result = await archiveExpired(dataDir, void 0, void 0, project.id, reader);
+              const result = await archiveExpired(dataDir, void 0, void 0, project.id, reader2);
               emitResult(
                 { project, result },
                 result.archived === 0 ? "No expired observations to archive." : `Archived ${result.archived} expired observation(s); ${result.remaining} active observation(s) remain.`,
@@ -201241,8 +201331,8 @@ var init_audit2 = __esm({
         try {
           switch (action) {
             case "memory": {
-              const { project, reader } = await getCliProjectContext();
-              const report = auditMemoryQuality(filterReadableObservations(getAllObservations(), reader), {
+              const { project, reader: reader2 } = await getCliProjectContext();
+              const report = auditMemoryQuality(filterReadableObservations(getAllObservations(), reader2), {
                 projectId: project.id
               });
               emitResult(
@@ -201279,11 +201369,11 @@ var init_audit2 = __esm({
               return;
             }
             case "project": {
-              const { project, reader } = await getCliProjectContext();
+              const { project, reader: reader2 } = await getCliProjectContext();
               const threshold = Number.parseInt(String(args.threshold ?? "2"), 10) || 2;
               const entries = await auditProjectObservations(
                 project.id,
-                filterReadableObservations(getAllObservations(), reader),
+                filterReadableObservations(getAllObservations(), reader2),
                 threshold
               );
               emitResult(
@@ -201316,13 +201406,13 @@ __export(export_import_exports, {
   exportAsMarkdown: () => exportAsMarkdown,
   importFromJson: () => importFromJson
 });
-async function exportAsJson(projectDir2, projectId, reader) {
+async function exportAsJson(projectDir2, projectId, reader2) {
   const store2 = getObservationStore();
   const allObs = await store2.loadAll();
   const allSessions = await getSessionStore().loadAll();
   const projectObs = filterReadableObservations(
     allObs.filter((o4) => o4.projectId === projectId),
-    reader
+    reader2
   );
   const projectSessions = allSessions.filter((s4) => s4.projectId === projectId);
   const typeBreakdown = {};
@@ -201342,8 +201432,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}`);
@@ -201523,12 +201613,12 @@ var init_transfer = __esm({
         const action = args._?.[0] || "";
         const asJson = !!args.json;
         try {
-          const { project, dataDir, reader } = await getCliProjectContext();
+          const { project, dataDir, reader: reader2 } = await getCliProjectContext();
           switch (action) {
             case "export": {
               const format = args.format === "markdown" ? "markdown" : "json";
               if (format === "markdown") {
-                const markdown = await exportAsMarkdown(dataDir, project.id, reader);
+                const markdown = await exportAsMarkdown(dataDir, project.id, reader2);
                 const output2 = args.out?.trim();
                 if (output2) {
                   const outputPath = await writeExportPayload(project.rootPath, output2, markdown);
@@ -201538,7 +201628,7 @@ var init_transfer = __esm({
                 emitResult({ project, format, markdown }, markdown, asJson);
                 return;
               }
-              const exported = await exportAsJson(dataDir, project.id, reader);
+              const exported = await exportAsJson(dataDir, project.id, reader2);
               const serialized = JSON.stringify(exported, null, 2);
               const output = args.out?.trim();
               if (output) {
@@ -201987,7 +202077,7 @@ var init_skills3 = __esm({
         const action = args._?.[0] || "";
         const asJson = !!args.json;
         try {
-          const { project, reader } = await getCliProjectContext();
+          const { project, reader: reader2 } = await getCliProjectContext();
           const { SkillsEngine: SkillsEngine2 } = await Promise.resolve().then(() => (init_engine4(), engine_exports2));
           const engine = new SkillsEngine2(project.rootPath);
           switch (action) {
@@ -202003,7 +202093,7 @@ var init_skills3 = __esm({
             case "generate": {
               const observations2 = filterReadableObservations(
                 await getObservationStore().loadAll(),
-                reader
+                reader2
               ).filter((observation) => resolveObservationVisibility(observation) === "project").map((obs) => ({
                 id: obs.id,
                 entityName: obs.entityName,
@@ -202045,7 +202135,7 @@ var init_skills3 = __esm({
               }
               const observations2 = filterReadableObservations(
                 await getObservationStore().loadAll(),
-                reader
+                reader2
               ).filter((observation) => resolveObservationVisibility(observation) === "project").map((obs) => ({
                 id: obs.id,
                 entityName: obs.entityName,
@@ -202121,7 +202211,7 @@ var init_identity2 = __esm({
         const action = (args._?.[0] || "status").toLowerCase();
         const asJson = !!args.json;
         try {
-          const { project, dataDir, teamStore, identity, reader, identityWarning } = await getCliProjectContext();
+          const { project, dataDir, teamStore, identity, reader: reader2, identityWarning } = await getCliProjectContext();
           switch (action) {
             case "status": {
               const saved = await loadCliIdentity(dataDir, project.id);
@@ -202132,7 +202222,7 @@ var init_identity2 = __esm({
                   identity,
                   savedIdentity: saved,
                   agent: agent ?? null,
-                  reader,
+                  reader: reader2,
                   ...identityWarning ? { warning: identityWarning } : {}
                 },
                 identity ? `CLI identity: ${agent?.name ?? identity.agentId} (${identity.agentId})` : identityWarning ?? 'CLI identity: project-scoped only. Use "memorix identity join" or "memorix identity use --agent-id <id>" for private/team operations.',
@@ -202298,7 +202388,7 @@ var init_session2 = __esm({
         const action = args._?.[0] || "";
         const asJson = !!args.json;
         try {
-          const { project, dataDir, teamStore, reader } = await getCliProjectContext({
+          const { project, dataDir, teamStore, reader: reader2 } = await getCliProjectContext({
             projectRoot: args.projectRoot
           });
           switch (action) {
@@ -202332,7 +202422,7 @@ var init_session2 = __esm({
                 projectId: project.id,
                 agentId: agentRecord.agent_id,
                 isTeamMember: agentRecord.status === "active"
-              } : reader;
+              } : reader2;
               const result = await startSession(dataDir, project.id, {
                 sessionId: args.sessionId,
                 agent: args.agent,
@@ -202427,7 +202517,7 @@ var init_session2 = __esm({
             case "context": {
               const limit2 = parsePositiveInt(args.limit, 3);
               const [context, sessions] = await Promise.all([
-                getSessionContext(dataDir, project.id, limit2, reader),
+                getSessionContext(dataDir, project.id, limit2, reader2),
                 listSessions(dataDir, project.id)
               ]);
               const active = sessions.filter((session) => session.status === "active").length;
@@ -203981,7 +204071,7 @@ var init_poll2 = __esm({
         try {
           const { project, teamStore, identity, reader: activeReader } = await getCliProjectContext();
           const agentId = resolveCliActorId(args.agentId, identity);
-          let reader = activeReader;
+          let reader2 = activeReader;
           let watermark = computeWatermark(0, 0, 0);
           if (agentId) {
             const agent = teamStore.getAgent(agentId);
@@ -203989,7 +204079,7 @@ var init_poll2 = __esm({
               emitError(`Unknown agent "${agentId}"`, asJson);
               return;
             }
-            reader = {
+            reader2 = {
               projectId: project.id,
               agentId,
               isTeamMember: agent.status === "active"
@@ -204001,7 +204091,7 @@ var init_poll2 = __esm({
                 getAllObservations().filter(
                   (obs) => obs.projectId === project.id && (obs.writeGeneration ?? 0) > lastSeen
                 ),
-                reader
+                reader2
               )
             );
             watermark = computeWatermark(lastSeen, currentGen, projectObs.length);
@@ -217817,6 +217907,350 @@ var init_behavior = __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(store2, 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 store2.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 record2 = payloadRecord(payload);
+  const normalized = {
+    includeNoise: record2.includeNoise === true,
+    removeIds: payloadIds(record2.removeIds, "removeIds"),
+    archiveIds: payloadIds(record2.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 record2 = payloadRecord(payload);
+  const normalized = { resolveIds: payloadIds(record2.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 record2 = payloadRecord(payload);
+  if (!Array.isArray(record2.clusterIds)) {
+    throw new DashboardMaintenanceError("Invalid clusterIds in maintenance preview.", 400);
+  }
+  const clusterIds = record2.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((candidate2) => candidate2.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 record2 = payloadRecord(payload);
+  const normalized = { archiveIds: payloadIds(record2.archiveIds, "archiveIds") };
+  verify("retention-archive", context.projectId, normalized, token);
+  const current = await retentionCandidates(context);
+  assertCurrent(normalized.archiveIds, current.map((candidate2) => candidate2.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, {
@@ -218419,6 +218853,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) {
@@ -218461,6 +218945,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(
@@ -218984,7 +219483,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) {
@@ -219155,7 +219655,15 @@ async function buildTeamSnapshot(dataDir, projectId, scope, mode) {
 function readBody(req) {
   return new Promise((resolve6, reject) => {
     const chunks = [];
-    req.on("data", (c6) => chunks.push(c6));
+    let size = 0;
+    req.on("data", (c6) => {
+      size += c6.length;
+      if (size > 64 * 1024) {
+        reject(new DashboardMaintenanceError("Request body is too large.", 413));
+        return;
+      }
+      chunks.push(c6);
+    });
     req.on("end", () => resolve6(Buffer.concat(chunks).toString("utf-8")));
     req.on("error", reject);
   });
@@ -219288,6 +219796,7 @@ var init_server3 = __esm({
     init_graph_scope();
     init_retention();
     init_visibility();
+    init_maintenance();
     MIME_TYPES = {
       ".html": "text/html; charset=utf-8",
       ".css": "text/css; charset=utf-8",
@@ -259694,7 +260203,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) => {
@@ -259824,20 +260333,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
@@ -259884,9 +260393,9 @@ The path should point to a directory containing a .git folder.`
                 useLLM: isLLMEnabled(),
                 minValueScore: 0.3,
                 searchMemories: async (q4, limit2, pid, signal) => {
-                  const result = await compactSearch({ query: q4, limit: limit2, projectId: pid, status: "active", reader, signal });
+                  const result = await compactSearch({ query: q4, limit: limit2, projectId: pid, status: "active", reader: reader2, signal });
                   if (result.entries.length === 0) return [];
-                  const details = await compactDetail(result.entries.map((e5) => e5.id), { reader });
+                  const details = await compactDetail(result.entries.map((e5) => e5.id), { reader: reader2 });
                   return details.documents.map((d4, i4) => ({
                     id: Number(d4.id.replace("obs-", "")),
                     observationId: d4.observationId,
@@ -259900,7 +260409,7 @@ The path should point to a directory containing a .git folder.`
                 },
                 getObservation: (id) => {
                   const o4 = getObservation(id);
-                  if (!o4 || o4.projectId !== project.id || !canReadObservation(o4, reader)) return null;
+                  if (!o4 || o4.projectId !== project.id || !canReadObservation(o4, reader2)) return null;
                   return {
                     id: o4.id,
                     entityName: o4.entityName,
@@ -259957,7 +260466,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,
@@ -259972,7 +260481,7 @@ ${modeIcon} Formation[active]: ${formationResult.evaluation.category} (${formati
                   sourceDetail: "explicit",
                   createdByAgentId: currentAgentId,
                   visibility,
-                  visibilityReader: reader
+                  visibilityReader: reader2
                 });
                 return {
                   content: [{
@@ -259983,7 +260492,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,
@@ -259998,7 +260507,7 @@ ${modeIcon} Formation[active]: ${formationResult.evaluation.category} (${formati
                   sourceDetail: "explicit",
                   createdByAgentId: currentAgentId,
                   visibility,
-                  visibilityReader: reader
+                  visibilityReader: reader2
                 });
                 return {
                   content: [{
@@ -260025,12 +260534,12 @@ ${modeIcon} Formation[active]: ${formationResult.evaluation.category} (${formati
                 limit: 5,
                 projectId: project.id,
                 status: "active",
-                reader
+                reader: reader2
               });
               const similarEntries = searchResult.entries.map((e5) => e5);
               if (similarEntries.length > 0) {
                 const similarIds = similarEntries.map((e5) => e5.id);
-                const details = await compactDetail(similarIds, { reader });
+                const details = await compactDetail(similarIds, { reader: reader2 });
                 const existingMemories = details.documents.map((d4, i4) => ({
                   id: d4.observationId,
                   title: d4.title,
@@ -260048,7 +260557,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,
@@ -260063,7 +260572,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;
@@ -260150,7 +260659,7 @@ Mode: ${decision.usedLLM ? "LLM" : "heuristic"}`
             const attrCheck = await checkProjectAttribution(
               entityName,
               project.id,
-              filterReadableObservations(getAllObservations(), reader)
+              filterReadableObservations(getAllObservations(), reader2)
             );
             if (attrCheck.suspicious) {
               attributionWarning = `
@@ -260177,7 +260686,7 @@ Mode: ${decision.usedLLM ? "LLM" : "heuristic"}`
             valueCategory: formationResult?.evaluation.category,
             createdByAgentId: currentAgentId,
             visibility: requestedVisibility,
-            visibilityReader: reader
+            visibilityReader: reader2
           });
           let longTermNote = "";
           if (longTerm) {
@@ -260192,8 +260701,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({
@@ -260246,12 +260755,12 @@ Auto-enriched: ${enrichmentParts.join(", ")}` : "";
                   limit: 5,
                   projectId: project.id,
                   status: "active",
-                  reader
+                  reader: reader2
                 });
                 const similarEntries = searchResult.entries.map((e5) => e5);
                 if (similarEntries.length > 0) {
                   const similarIds = similarEntries.map((e5) => e5.id);
-                  const details = await compactDetail(similarIds, { reader });
+                  const details = await compactDetail(similarIds, { reader: reader2 });
                   const existingMemories = details.documents.map((d4, i4) => ({
                     id: d4.observationId,
                     title: d4.title,
@@ -260277,9 +260786,9 @@ Auto-enriched: ${enrichmentParts.join(", ")}` : "";
                 useLLM: isLLMEnabled(),
                 minValueScore: 0.3,
                 searchMemories: async (q4, limit2, pid, signal) => {
-                  const result = await compactSearch({ query: q4, limit: limit2, projectId: pid, status: "active", reader, signal });
+                  const result = await compactSearch({ query: q4, limit: limit2, projectId: pid, status: "active", reader: reader2, signal });
                   if (result.entries.length === 0) return [];
-                  const details = await compactDetail(result.entries.map((e5) => e5.id), { reader });
+                  const details = await compactDetail(result.entries.map((e5) => e5.id), { reader: reader2 });
                   return details.documents.map((d4, i4) => ({
                     id: Number(d4.id.replace("obs-", "")),
                     observationId: d4.observationId,
@@ -260293,7 +260802,7 @@ Auto-enriched: ${enrichmentParts.join(", ")}` : "";
                 },
                 getObservation: (id) => {
                   const o4 = getObservation(id);
-                  if (!o4 || o4.projectId !== project.id || !canReadObservation(o4, reader)) return null;
+                  if (!o4 || o4.projectId !== project.id || !canReadObservation(o4, reader2)) return null;
                   return { id: o4.id, entityName: o4.entityName, type: o4.type, title: o4.title, narrative: o4.narrative, facts: o4.facts, topicKey: o4.topicKey };
                 },
                 getEntityNames: () => graphManager.getEntityNames()
@@ -261061,10 +261570,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;
@@ -261107,7 +261616,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) {
@@ -261133,7 +261642,7 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
           const attrCheck = await checkProjectAttribution(
             entityName,
             project.id,
-            filterReadableObservations(getAllObservations(), reader)
+            filterReadableObservations(getAllObservations(), reader2)
           );
           if (attrCheck.suspicious) {
             reasoningAttributionWarning = `
@@ -261282,11 +261791,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((o4) => (o4.status ?? "active") === "active" && o4.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." }] };
       }
@@ -261300,7 +261809,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((e5) => e5.id));
         candidates = allObs.filter((o4) => idSet.has(o4.id));
       } else {
@@ -261309,64 +261818,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 i4 = 0; i4 < group.length; i4++) {
-          for (let j4 = i4 + 1; j4 < group.length; j4++) {
-            const newer = group[j4];
-            const older = group[i4];
-            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 unique3 = [...new Set(toResolve)];
-      await resolveObservations2(unique3, "resolved");
+      const result = await applyDeduplicationPlan(getObservationStore(), project.id, plan.resolveIds, reader2);
       return {
         content: [{
           type: "text",
-          text: `[CLEANUP] Deduplicated: resolved ${unique3.length} memory(ies)
+          text: `[CLEANUP] Deduplicated: resolved ${result.resolved.length} memory(ies)
 
-${actions.join("\n")}`
+${actionLines.join("\n")}`
         }]
       };
     }
@@ -261474,8 +261952,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(", ")}`
           );
@@ -261508,10 +261986,10 @@ ${actions.join("\n")}`
       const { getDb: getDb2 } = await Promise.resolve().then(() => (init_orama_store(), orama_store_exports));
       const { search: search3 } = await Promise.resolve().then(() => (init_esm(), esm_exports));
       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 {
@@ -261561,7 +262039,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) {
@@ -262275,10 +262753,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 };
@@ -263988,6 +264466,7 @@ var init_server4 = __esm({
     init_tool_profile();
     init_provider2();
     init_memory_manager();
+    init_deduplication();
     init_formation();
     init_formation_timeout();
     init_timeout();
@@ -264545,15 +265024,15 @@ import { Readable as Readable2 } from "stream";
 async function readWithoutBlocking(readPromise) {
   return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(void 0))]);
 }
-function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromise) {
+function writeFromReadableStreamDefaultReader(reader2, writable, currentReadPromise) {
   const cancel = (error40) => {
-    reader.cancel(error40).catch(() => {
+    reader2.cancel(error40).catch(() => {
     });
   };
   writable.on("close", cancel);
   writable.on("error", cancel);
-  (currentReadPromise ?? reader.read()).then(flow, handleStreamError);
-  return reader.closed.finally(() => {
+  (currentReadPromise ?? reader2.read()).then(flow, handleStreamError);
+  return reader2.closed.finally(() => {
     writable.off("close", cancel);
     writable.off("error", cancel);
   });
@@ -264561,13 +265040,13 @@ function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromi
     if (error40) writable.destroy(error40);
   }
   function onDrain() {
-    reader.read().then(flow, handleStreamError);
+    reader2.read().then(flow, handleStreamError);
   }
   function flow({ done, value }) {
     try {
       if (done) writable.end();
       else if (!writable.write(value)) writable.once("drain", onDrain);
-      else return reader.read().then(flow, handleStreamError);
+      else return reader2.read().then(flow, handleStreamError);
     } catch (e5) {
       handleStreamError(e5);
     }
@@ -264700,18 +265179,18 @@ var init_dist8 = __esm({
         controller.close();
       } });
       else if (incoming[wrapBodyStream]) {
-        let reader;
+        let reader2;
         init2.body = new ReadableStream({ async pull(controller) {
           try {
-            if (!reader) {
+            if (!reader2) {
               const buffered = readBodyBufferedBeforeDisconnect(incoming);
               if (buffered !== void 0) {
                 enqueueBufferedBody(controller, buffered);
                 return;
               }
             }
-            reader ||= Readable2.toWeb(incoming).getReader();
-            const { done, value } = await reader.read();
+            reader2 ||= Readable2.toWeb(incoming).getReader();
+            const { done, value } = await reader2.read();
             if (done) controller.close();
             else controller.enqueue(value);
           } catch (error40) {
@@ -265336,14 +265815,14 @@ var init_dist8 = __esm({
       if (cacheKey in res) return responseViaCache(res, outgoing);
       const resHeaderRecord = buildOutgoingHttpHeaders(res.headers, res.body === null ? void 0 : defaultContentType);
       if (res.body) {
-        const reader = res.body.getReader();
+        const reader2 = res.body.getReader();
         const values = [];
         let done = false;
         let currentReadPromise = void 0;
         if (resHeaderRecord["transfer-encoding"] !== "chunked") {
           let maxReadCount = 2;
           for (let i4 = 0; i4 < maxReadCount; i4++) {
-            currentReadPromise ||= reader.read();
+            currentReadPromise ||= reader2.read();
             const chunk = await readWithoutBlocking(currentReadPromise).catch((e5) => {
               console.error(e5);
               done = true;
@@ -265372,7 +265851,7 @@ var init_dist8 = __esm({
         if (done) outgoing.end();
         else {
           if (values.length === 0) flushHeaders(outgoing);
-          await writeFromReadableStreamDefaultReader(reader, outgoing, currentReadPromise);
+          await writeFromReadableStreamDefaultReader(reader2, outgoing, currentReadPromise);
         }
       } else if (resHeaderRecord[X_ALREADY_SENT]) {
       } else {
@@ -271500,7 +271979,7 @@ var init_ingest_image = __esm({
             emitError('path is required for "memorix ingest image"', asJson);
             return;
           }
-          const { project, dataDir, reader, identity } = await getCliProjectContext();
+          const { project, dataDir, reader: reader2, identity } = await getCliProjectContext();
           const resolvedPath = path43.resolve(project.rootPath, imagePath);
           const filename = path43.basename(resolvedPath);
           const imported = await importMediaFile({
@@ -271549,7 +272028,7 @@ var init_ingest_image = __esm({
             narrative: analysis.description,
             concepts: analysis.tags,
             facts: analysis.entities,
-            ...resolveCliWriteScope({ reader, identity }, args.visibility)
+            ...resolveCliWriteScope({ reader: reader2, identity }, args.visibility)
           });
           emitResult(
             { project, asset: imported.asset, deduplicated: imported.deduplicated, analysis, analysisWarning, observation },
@@ -271926,7 +272405,7 @@ var init_media = __esm({
               }
               const prompt2 = getValue(args.prompt, positional);
               if (!prompt2) throw new Error(`prompt is required for "memorix media generate ${target}"`);
-              const { project, dataDir, reader, identity } = await getCliProjectContext();
+              const { project, dataDir, reader: reader2, identity } = await getCliProjectContext();
               loadDotenv(project.rootPath);
               if (target === "video") {
                 const queued = queueMiniMaxVideoGeneration({
@@ -271979,7 +272458,7 @@ var init_media = __esm({
                 title: `MiniMax image: ${asset.sourceLabel ?? asset.id}`,
                 narrative: `Generated with ${generated.provider}/${generated.model}. Prompt: ${prompt2}`,
                 concepts: ["generated-image", "minimax", generated.model],
-                ...resolveCliWriteScope({ reader, identity }, args.visibility)
+                ...resolveCliWriteScope({ reader: reader2, identity }, args.visibility)
               }))) : [];
               emitResult(
                 { project, ...generated, observations: observations2 },
@@ -272040,7 +272519,7 @@ var init_media = __esm({
             case "derive-pdf": {
               const assetId = getValue(args.asset, positional);
               if (!assetId) throw new Error('asset is required for "memorix media derive-pdf"');
-              const { project, dataDir, reader, identity } = await getCliProjectContext();
+              const { project, dataDir, reader: reader2, identity } = await getCliProjectContext();
               const maxChars = parseOptionalInteger(args.maxChars ?? args["max-chars"], "maxChars", 1, 1e6);
               const requestedChunkChars = parseOptionalInteger(args.chunkChars ?? args["chunk-chars"], "chunkChars", 1, 12e4);
               const derived = await derivePdfText({
@@ -272063,7 +272542,7 @@ var init_media = __esm({
                     narrative: chunk.text,
                     facts: [`PDF pages: ${chunk.pageStart}-${chunk.pageEnd}`, "Derived with explicit PDF text extraction."],
                     concepts: ["pdf", "pdf-text", "media-derivation"],
-                    ...resolveCliWriteScope({ reader, identity }, args.visibility)
+                    ...resolveCliWriteScope({ reader: reader2, identity }, args.visibility)
                   }));
                 }
               }
@@ -272142,7 +272621,7 @@ ${asset.mimeType}, ${asset.byteSize} bytes, ${links.length} link(s)`,
             case "attach": {
               const assetId = getValue(args.asset, positional);
               if (!assetId) throw new Error('asset is required for "memorix media attach"');
-              const { project, dataDir, reader, identity } = await getCliProjectContext();
+              const { project, dataDir, reader: reader2, identity } = await getCliProjectContext();
               const store2 = new MediaStore(dataDir);
               const asset = store2.getAsset(project.id, assetId);
               if (!asset) throw new Error(`Media asset not found: ${assetId}`);
@@ -272156,7 +272635,7 @@ ${asset.mimeType}, ${asset.byteSize} bytes, ${links.length} link(s)`,
                 narrative: args.text?.trim() || description,
                 entityName: args.entity?.trim(),
                 concepts,
-                ...resolveCliWriteScope({ reader, identity }, args.visibility)
+                ...resolveCliWriteScope({ reader: reader2, identity }, args.visibility)
               });
               emitResult(
                 { project, asset, observation },
@@ -272426,7 +272905,7 @@ import * as fs26 from "fs";
 import path44 from "path";
 import { fileURLToPath as fileURLToPath8 } from "url";
 import { spawn as spawn6, execFileSync as execFileSync4 } from "child_process";
-import { randomBytes } from "crypto";
+import { randomBytes as randomBytes2 } from "crypto";
 import os7 from "os";
 function resolveBackgroundCwd(cwd, homeDir = os7.homedir()) {
   if (!isHomeDirectory(cwd, homeDir)) return cwd;
@@ -272731,7 +273210,7 @@ async function doStart(port) {
     process.exitCode = 1;
     return;
   }
-  const instanceToken = randomBytes(8).toString("hex");
+  const instanceToken = randomBytes2(8).toString("hex");
   saveState({
     pid,
     port,
@@ -274661,41 +275140,8 @@ __export(cleanup_exports, {
   applyCleanupMutations: () => applyCleanupMutations,
   default: () => cleanup_default
 });
-function isLowQuality(title) {
-  return LOW_QUALITY_PATTERNS.some((p3) => p3.test(title.trim()));
-}
-function isNoisePollution(obs) {
-  const text2 = [obs.title, obs.narrative, obs.entityName, ...obs.facts ?? [], ...obs.concepts ?? []].filter(Boolean).join("\n");
-  for (const p3 of SYSTEM_SELF_PATTERNS2) {
-    if (p3.test(text2)) return { isNoise: true, reason: "system-self" };
-  }
-  for (const p3 of NOISE_PATTERNS3) {
-    if (p3.test(text2)) return { isNoise: true, reason: "demo/test/noise" };
-  }
-  return { isNoise: false, reason: "" };
-}
-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(store2, 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 store2.atomic(async (tx) => {
-    await Promise.all(archiveIds.map((id) => tx.setStatus(id, "archived")));
-    await Promise.all(removeIds.map((id) => tx.remove(id)));
-  });
-  return { archived: archiveIds.length, removed: removeIds.length };
-}
-var LOW_QUALITY_PATTERNS, NOISE_PATTERNS3, SYSTEM_SELF_PATTERNS2, cleanup_default;
-var init_cleanup = __esm({
+var cleanup_default;
+var init_cleanup2 = __esm({
   "src/cli/commands/cleanup.ts"() {
     "use strict";
     init_esm_shims();
@@ -274704,46 +275150,8 @@ var init_cleanup = __esm({
     init_persistence();
     init_obs_store();
     init_visibility();
-    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
-    ];
-    NOISE_PATTERNS3 = [
-      /\[测试\]/i,
-      /\[test\]/i,
-      /验证/i,
-      /兼容/i,
-      /\bcompat(?:ibility)?\b/i,
-      /\bdemo\b/i,
-      /展示/i,
-      /全能力/i,
-      /handoff/i,
-      /交接/i,
-      /for_memmcp_test/i,
-      /\bbenchmark\b/i,
-      /\bsandbox\b/i,
-      /\bplayground\b/i
-    ];
-    SYSTEM_SELF_PATTERNS2 = [
-      /memorix.demo/i,
-      /memorix.*全能力/i,
-      /memorix.*工具.*能力/i,
-      /memorix.*runtime.*mode/i,
-      /memorix.*运行模式/i,
-      /memorix.*control.plane/i,
-      /session.*inject(?:ion)?/i,
-      /注入.*逻辑/i,
-      /\b22\s*(?:个|tools?).*(?:工具|能力|capabilit)/i,
-      /memorix.*(?:v\d|版本|version)/i,
-      /memorix.*(?:兼容|compat)/i,
-      /memorix.*(?:测试|test)/i,
-      /memmcp/i
-    ];
+    init_cleanup();
+    init_cleanup();
     cleanup_default = defineCommand({
       meta: {
         name: "cleanup",
@@ -274800,33 +275208,11 @@ Project: ${projectName} (${projectId})
           console.log("[OK] No observations found - nothing to clean up.");
           return;
         }
-        const lowQuality = projectObs.filter((o4) => isLowQuality(o4.title ?? ""));
-        const highQuality = projectObs.filter((o4) => !isLowQuality(o4.title ?? ""));
-        const seen = /* @__PURE__ */ new Set();
-        const duplicates = [];
-        const unique3 = [];
-        for (const obs of highQuality) {
-          const key = `${obs.type}|${obs.title}|${obs.entityName}`;
-          if (seen.has(key)) {
-            duplicates.push(obs);
-          } else {
-            seen.add(key);
-            unique3.push(obs);
-          }
-        }
-        const noiseHits = [];
-        if (args.noise) {
-          for (const obs of projectObs) {
-            if (lowQuality.includes(obs) || duplicates.includes(obs)) continue;
-            const { isNoise, reason } = isNoisePollution(obs);
-            if (isNoise) noiseHits.push({ obs, reason });
-          }
-        }
-        const toRemove = [...lowQuality, ...duplicates];
-        const toArchive = noiseHits.map((h5) => h5.obs);
+        const analysis = analyzeCleanupObservations(projectObs, { includeNoise: args.noise });
+        const { lowQuality, duplicates, noise: noiseHits, toRemove, toArchive } = analysis;
         console.log(`Analysis (active observations for ${projectId}):`);
-        console.log(`   Total active:       ${projectObs.length}`);
-        console.log(`   High quality:       ${unique3.length - toArchive.length}`);
+        console.log(`   Total active:       ${analysis.totalActive}`);
+        console.log(`   High quality:       ${analysis.highQuality}`);
         console.log(`   Low quality:        ${lowQuality.length}`);
         console.log(`   Duplicates:         ${duplicates.length}`);
         if (args.noise) {
@@ -274844,7 +275230,7 @@ Project: ${projectName} (${projectId})
         if (toRemove.length > 0) {
           console.log("Items to DELETE:");
           toRemove.slice(0, 10).forEach((o4) => {
-            const tag = isLowQuality(o4.title ?? "") ? "(low-quality)" : "(duplicate)";
+            const tag = isLowQualityObservation(o4.title ?? "") ? "(low-quality)" : "(duplicate)";
             console.log(`   ${tag} #${o4.id ?? "?"} "${o4.title}" [${o4.type}]`);
           });
           if (toRemove.length > 10) {
@@ -274854,8 +275240,8 @@ Project: ${projectName} (${projectId})
         }
         if (toArchive.length > 0) {
           console.log("Items to ARCHIVE (noise pollution):");
-          noiseHits.slice(0, 15).forEach(({ obs, reason }) => {
-            console.log(`   (${reason}) #${obs.id ?? "?"} "${obs.title}" [${obs.type}] entity=${obs.entityName}`);
+          noiseHits.slice(0, 15).forEach(({ observation, reason }) => {
+            console.log(`   (${reason}) #${observation.id ?? "?"} "${observation.title}" [${observation.type}] entity=${observation.entityName}`);
           });
           if (toArchive.length > 15) {
             console.log(`   ... and ${toArchive.length - 15} more`);
@@ -280585,11 +280971,11 @@ async function getSessionState(projectId) {
 async function bindSession() {
   try {
     const { getTuiOperatorContext: getTuiOperatorContext2 } = await Promise.resolve().then(() => (init_operator_context(), operator_context_exports));
-    const { project: proj, reader } = await getTuiOperatorContext2();
+    const { project: proj, reader: reader2 } = await getTuiOperatorContext2();
     const { startSession: startSession2 } = await Promise.resolve().then(() => (init_session(), session_exports));
     const { session, previousContext } = await startSession2(proj.rootPath, proj.id, {
       agent: "memorix-tui",
-      reader
+      reader: reader2
     });
     return {
       status: "bound",
@@ -280681,7 +281067,7 @@ async function getHealthInfo(projectId) {
   };
   try {
     const { initObservationStore: initStore, getObservationStore: getStore } = await Promise.resolve().then(() => (init_obs_store(), obs_store_exports));
-    const { project: proj, dataDir, reader } = await getTuiOperatorContext();
+    const { project: proj, dataDir, reader: reader2 } = await getTuiOperatorContext();
     try {
       const { loadDotenv: loadDotenv2 } = await Promise.resolve().then(() => (init_dotenv_loader(), dotenv_loader_exports));
       loadDotenv2(proj.rootPath);
@@ -280692,7 +281078,7 @@ async function getHealthInfo(projectId) {
     await initStore(dataDir);
     const allObs = await getStore().loadAll();
     const { filterReadableObservations: filterReadableObservations2 } = await Promise.resolve().then(() => (init_visibility(), visibility_exports));
-    const obs = filterReadableObservations2(allObs, reader);
+    const obs = filterReadableObservations2(allObs, reader2);
     const active = obs.filter((o4) => (o4.status ?? "active") === "active");
     defaults2.totalMemories = obs.length;
     defaults2.activeMemories = active.length;
@@ -280758,13 +281144,13 @@ async function getHealthInfo(projectId) {
 async function getRecentMemories(limit2 = 8, projectId) {
   try {
     const { initObservationStore: initStore, getObservationStore: getStore } = await Promise.resolve().then(() => (init_obs_store(), obs_store_exports));
-    const { project: proj, dataDir, reader } = await getTuiOperatorContext();
+    const { project: proj, dataDir, reader: reader2 } = await getTuiOperatorContext();
     const effectiveProjectId = projectId || proj.id;
     if (effectiveProjectId !== proj.id) return [];
     await initStore(dataDir);
     const allObs = await getStore().loadAll();
     const { filterReadableObservations: filterReadableObservations2 } = await Promise.resolve().then(() => (init_visibility(), visibility_exports));
-    const projectObs = filterReadableObservations2(allObs, reader);
+    const projectObs = filterReadableObservations2(allObs, reader2);
     const active = projectObs.filter((o4) => (o4.status ?? "active") === "active");
     const filtered = active.filter((o4) => !/^(Ran:|Command:|Executed:)\s/i.test(o4.title || ""));
     return filtered.slice(-limit2).reverse().map((o4) => ({
@@ -280783,10 +281169,10 @@ async function searchMemories(query, limit2 = 10) {
   try {
     const { searchObservations: searchObservations2 } = await Promise.resolve().then(() => (init_orama_store(), orama_store_exports));
     const { initObservations: initObservations2, prepareSearchIndex: prepareSearchIndex2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
-    const { project: proj, dataDir, reader } = await getTuiOperatorContext();
+    const { project: proj, dataDir, reader: reader2 } = await getTuiOperatorContext();
     await initObservations2(dataDir);
     await prepareSearchIndex2();
-    const results = await searchObservations2({ query, limit: limit2, projectId: proj.id, reader });
+    const results = await searchObservations2({ query, limit: limit2, projectId: proj.id, reader: reader2 });
     const typeIcons = {
       gotcha: "!",
       decision: "D",
@@ -280813,7 +281199,7 @@ async function storeQuickMemory(text2) {
   try {
     const { initObservations: initObservations2, storeObservation: storeObservation2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
     const { initObservationStore: initObservationStore2 } = await Promise.resolve().then(() => (init_obs_store(), obs_store_exports));
-    const { project: proj, dataDir, reader, identity } = await getTuiOperatorContext();
+    const { project: proj, dataDir, reader: reader2, identity } = await getTuiOperatorContext();
     await initObservationStore2(dataDir);
     await initObservations2(dataDir);
     const result = await storeObservation2({
@@ -280824,7 +281210,7 @@ async function storeQuickMemory(text2) {
       facts: [],
       projectId: proj.id,
       sourceDetail: "explicit",
-      visibilityReader: reader,
+      visibilityReader: reader2,
       ...identity ? { createdByAgentId: identity.agentId } : {}
     });
     return { id: result.observation.id, title: text2.slice(0, 100) };
@@ -280968,13 +281354,13 @@ async function getKnowledgeGraph(projectId) {
     const { filterReadableObservations: filterReadableObservations2 } = await Promise.resolve().then(() => (init_visibility(), visibility_exports));
     const { initMiniSkillStore: initMiniSkillStore2, getMiniSkillStore: getMiniSkillStore2 } = await Promise.resolve().then(() => (init_mini_skill_store(), mini_skill_store_exports));
     const { generateKnowledgeGraph: generateKnowledgeGraph2 } = await Promise.resolve().then(() => (init_knowledge_graph(), knowledge_graph_exports));
-    const { project: proj, dataDir, reader } = await getTuiOperatorContext();
+    const { project: proj, dataDir, reader: reader2 } = await getTuiOperatorContext();
     const effectiveProjectId = projectId || proj.id;
     if (effectiveProjectId !== proj.id) return null;
     await initObservationStore2(dataDir);
     await initObservations2(dataDir);
     await initMiniSkillStore2(dataDir);
-    const observations2 = filterReadableObservations2(getAllObservations2(), reader);
+    const observations2 = filterReadableObservations2(getAllObservations2(), reader2);
     const skills = await getMiniSkillStore2().loadByProject(effectiveProjectId);
     return generateKnowledgeGraph2({
       projectId: effectiveProjectId,
@@ -280992,13 +281378,13 @@ async function getKnowledgeBase(projectId) {
     const { filterReadableObservations: filterReadableObservations2 } = await Promise.resolve().then(() => (init_visibility(), visibility_exports));
     const { initMiniSkillStore: initMiniSkillStore2, getMiniSkillStore: getMiniSkillStore2 } = await Promise.resolve().then(() => (init_mini_skill_store(), mini_skill_store_exports));
     const { generateKnowledgeBase: generateKnowledgeBase2 } = await Promise.resolve().then(() => (init_generator(), generator_exports));
-    const { project: proj, dataDir, reader } = await getTuiOperatorContext();
+    const { project: proj, dataDir, reader: reader2 } = await getTuiOperatorContext();
     const effectiveProjectId = projectId || proj.id;
     if (effectiveProjectId !== proj.id) return null;
     await initObservationStore2(dataDir);
     await initObservations2(dataDir);
     await initMiniSkillStore2(dataDir);
-    const observations2 = filterReadableObservations2(getAllObservations2(), reader);
+    const observations2 = filterReadableObservations2(getAllObservations2(), reader2);
     const skills = await getMiniSkillStore2().loadByProject(effectiveProjectId);
     return generateKnowledgeBase2({
       projectId: effectiveProjectId,
@@ -281058,7 +281444,7 @@ function MemoryView({ projectId, focusRefId, selectedIdx, onNavigateKnowledge, i
         const { filterReadableObservations: filterReadableObservations2 } = await Promise.resolve().then(() => (init_visibility(), visibility_exports));
         const { initObservationStore: initObservationStore2 } = await Promise.resolve().then(() => (init_obs_store(), obs_store_exports));
         const { getTuiOperatorContext: getTuiOperatorContext2 } = await Promise.resolve().then(() => (init_operator_context(), operator_context_exports));
-        const { project: proj, dataDir, reader } = await getTuiOperatorContext2();
+        const { project: proj, dataDir, reader: reader2 } = await getTuiOperatorContext2();
         const effectiveProjectId = projectId || proj.id;
         if (effectiveProjectId !== proj.id) return;
         await initObservationStore2(dataDir);
@@ -281066,7 +281452,7 @@ function MemoryView({ projectId, focusRefId, selectedIdx, onNavigateKnowledge, i
         const obsId = parseInt(idMatch[1], 10);
         const obs = filterReadableObservations2(
           getAllObservations2().filter((observation) => observation.projectId === effectiveProjectId),
-          reader
+          reader2
         ).find((observation) => observation.id === obsId);
         if (obs) {
           setDetailItem({
@@ -283906,7 +284292,7 @@ var main2 = defineCommand({
     doctor: () => Promise.resolve().then(() => (init_doctor(), doctor_exports)).then((m6) => m6.default),
     repair: () => Promise.resolve().then(() => (init_repair3(), repair_exports)).then((m6) => m6.default),
     dashboard: () => Promise.resolve().then(() => (init_dashboard(), dashboard_exports)).then((m6) => m6.default),
-    cleanup: () => Promise.resolve().then(() => (init_cleanup(), cleanup_exports)).then((m6) => m6.default),
+    cleanup: () => Promise.resolve().then(() => (init_cleanup2(), cleanup_exports)).then((m6) => m6.default),
     purge: () => Promise.resolve().then(() => (init_purge(), purge_exports)).then((m6) => m6.default),
     uninstall: () => Promise.resolve().then(() => (init_uninstall(), uninstall_exports)).then((m6) => m6.default),
     orchestrate: () => Promise.resolve().then(() => (init_orchestrate(), orchestrate_exports)).then((m6) => m6.default),