@joshuaswarren/openclaw-engram 9.1.23 → 9.1.25

package/README.md

@@ -409,7 +409,7 @@ openclaw engram access http-serve --token "$OPENCLAW_ENGRAM_ACCESS_TOKEN"
 
 Key endpoints: `GET /engram/v1/health`, `POST /engram/v1/recall`, `POST /engram/v1/memories`, `GET /engram/v1/entities/:name`, and more. Full reference in [API docs](docs/api.md).
 
-The HTTP server also hosts a lightweight operator UI at `http://127.0.0.1:4318/engram/ui/` for memory browsing, recall inspection, governance review, and entity exploration.
+The HTTP server also hosts a lightweight operator UI at `http://127.0.0.1:4318/engram/ui/` for memory browsing, recall inspection, governance review, trust-zone promotion, and entity exploration.
 
 ### MCP Tools
 
@@ -473,8 +473,29 @@ openclaw engram semantic-consolidate --dry-run  # Preview without changes
 # Access layer
 openclaw engram access http-serve --token "$TOKEN"  # Start HTTP API
 openclaw engram access mcp-serve   # Start stdio MCP server
+
+# Trust-zone demos
+openclaw engram trust-zone-demo-seed --dry-run       # Preview the opt-in buyer demo dataset
+openclaw engram trust-zone-demo-seed                 # Explicitly seed the demo dataset
+openclaw engram trust-zone-promote --record-id <id> --target-zone working --reason "Operator review"
 ```
 
+### Trust-zone demo workflow
+
+Trust zones now ship with a dedicated admin-console view plus an explicit demo seeding path for buyer-facing walkthroughs.
+
+- **Never automatic** — Engram does not seed sample trust-zone records on install, startup, or feature enablement.
+- **Explicit only** — demo records appear only after you run `openclaw engram trust-zone-demo-seed` or trigger the matching admin-console action.
+- **Buyer-friendly story** — the trust-zone view surfaces provenance strength, promotion readiness, corroboration requirements, and operator promotion actions in one place.
+
+The seeded scenario is `enterprise-buyer-v1`, which creates a small, opinionated dataset covering:
+
+- quarantine records that are ready for review
+- working records that are blocked on missing provenance
+- working records that still need corroboration
+- working records with independent corroboration support
+- a trusted operator policy record
+
 See the [full CLI reference](docs/api.md#cli-commands) for all commands.
 
 ## Configuration

package/dist/access-cli.js

@@ -3,10 +3,10 @@ import {
   EngramAccessService,
   Orchestrator,
   parseConfig
-} from "./chunk-S6X3YWYF.js";
-import "./chunk-PIQWOQEX.js";
+} from "./chunk-JUQ752QV.js";
+import "./chunk-MNBCF5B2.js";
 import "./chunk-IMMYYNXG.js";
-import "./chunk-Y6DMH5LN.js";
+import "./chunk-IADQJS2J.js";
 import "./chunk-6KX4XLQJ.js";
 import "./chunk-4722S3A6.js";
 import "./chunk-MKM2BCQH.js";

package/dist/admin-console/public/app.js

@@ -5,6 +5,11 @@ const browserState = {
   offset: 0,
   total: 0,
 };
+const trustZoneState = {
+  limit: 12,
+  offset: 0,
+  total: 0,
+};
 
 function $(id) {
   return document.getElementById(id);
@@ -109,12 +114,43 @@ function readMemoryPageSize() {
   return Number.parseInt($("memoryPageSize")?.value || String(browserState.limit || 25), 10) || 25;
 }
 
+function readTrustZonePageSize() {
+  return Number.parseInt($("trustZonePageSize")?.value || String(trustZoneState.limit || 12), 10) || 12;
+}
+
 function stepMemoryPage(direction) {
   const pageSize = readMemoryPageSize();
   browserState.limit = pageSize;
   browserState.offset = Math.max(0, browserState.offset + direction * pageSize);
 }
 
+function syncTrustZoneControls() {
+  const prevButton = $("trustZonePrevButton");
+  const nextButton = $("trustZoneNextButton");
+  if (prevButton) prevButton.disabled = trustZoneState.offset <= 0;
+  if (nextButton) nextButton.disabled = trustZoneState.offset + trustZoneState.limit >= trustZoneState.total;
+
+  const pageStatus = $("trustZonePageStatus");
+  if (!pageStatus) return;
+  if (trustZoneState.total === 0) {
+    pageStatus.textContent = "No results";
+    return;
+  }
+  const pageOffset = Math.min(
+    trustZoneState.offset,
+    Math.max(0, trustZoneState.total - 1),
+  );
+  const start = pageOffset + 1;
+  const end = Math.min(pageOffset + trustZoneState.limit, trustZoneState.total);
+  pageStatus.textContent = `${start}-${end} of ${trustZoneState.total}`;
+}
+
+function stepTrustZonePage(direction) {
+  const pageSize = readTrustZonePageSize();
+  trustZoneState.limit = pageSize;
+  trustZoneState.offset = Math.max(0, trustZoneState.offset + direction * pageSize);
+}
+
 function renderMemoryList(memories) {
   const list = $("memoryList");
   if (!list) return;
@@ -254,6 +290,86 @@ function renderEntityList(entities) {
   });
 }
 
+function renderTrustZoneList(records) {
+  const list = $("trustZoneList");
+  if (!list) return;
+  if (!Array.isArray(records) || records.length === 0) {
+    renderEmptyState(list, "No trust-zone records matched.");
+    return;
+  }
+  clearChildren(list);
+  records.forEach((record) => {
+    const article = createItem();
+    const meta = document.createElement("div");
+    meta.className = "meta";
+    appendPill(meta, record.zone);
+    appendPill(meta, record.kind);
+    appendPill(meta, record.sourceClass);
+    appendPill(meta, record.anchored ? "anchored" : "unanchored");
+    if (record.trustScore) {
+      appendPill(meta, `trust ${record.trustScore.total} (${record.trustScore.band})`);
+    }
+    article.appendChild(meta);
+
+    const heading = document.createElement("h3");
+    heading.style.marginTop = "10px";
+    heading.textContent = record.recordId;
+    article.appendChild(heading);
+
+    const pathText = document.createElement("div");
+    pathText.className = "status";
+    pathText.textContent = `${record.recordedAt} · ${record.filePath}`;
+    article.appendChild(pathText);
+
+    const preview = document.createElement("p");
+    preview.textContent = record.summary;
+    article.appendChild(preview);
+
+    const readiness = document.createElement("div");
+    readiness.className = "status";
+    if (record.nextPromotionTarget) {
+      readiness.textContent = record.nextPromotionAllowed
+        ? `Ready for promotion to ${record.nextPromotionTarget}.`
+        : `Blocked on ${record.nextPromotionTarget}: ${(record.nextPromotionReasons || []).join("; ") || "operator review required"}`;
+    } else {
+      readiness.textContent = "No further promotion path.";
+    }
+    article.appendChild(readiness);
+
+    const toolbar = document.createElement("div");
+    toolbar.className = "toolbar";
+    toolbar.style.marginTop = "12px";
+
+    const inspectButton = document.createElement("button");
+    inspectButton.className = "secondary";
+    inspectButton.textContent = "Inspect";
+    inspectButton.addEventListener("click", () => {
+      $("trustZoneDetail").textContent = JSON.stringify(record, null, 2);
+      setStatus("trustZoneDetailStatus", `Loaded ${record.recordId}.`, "ok");
+    });
+    toolbar.appendChild(inspectButton);
+
+    if (record.nextPromotionTarget) {
+      const previewButton = document.createElement("button");
+      previewButton.className = "secondary";
+      previewButton.textContent = `Preview → ${record.nextPromotionTarget}`;
+      previewButton.addEventListener("click", () => void promoteTrustZone(record.recordId, record.nextPromotionTarget, true));
+      toolbar.appendChild(previewButton);
+    }
+
+    if (record.nextPromotionTarget && record.nextPromotionAllowed) {
+      const promoteButton = document.createElement("button");
+      promoteButton.className = "accent";
+      promoteButton.textContent = `Promote → ${record.nextPromotionTarget}`;
+      promoteButton.addEventListener("click", () => void promoteTrustZone(record.recordId, record.nextPromotionTarget, false));
+      toolbar.appendChild(promoteButton);
+    }
+
+    article.appendChild(toolbar);
+    list.appendChild(article);
+  });
+}
+
 function renderQuality(response) {
   const summary = $("qualitySummary");
   if (!summary) return;
@@ -418,6 +534,99 @@ async function loadMaintenance() {
   setStatus("maintenanceStatus", "Maintenance summary loaded.", "ok");
 }
 
+async function loadTrustZones(resetOffset = false) {
+  if (resetOffset) trustZoneState.offset = 0;
+  trustZoneState.limit = readTrustZonePageSize();
+  setStatus("trustZoneStatus", "Loading trust-zone state...");
+  const params = new URLSearchParams();
+  const query = $("trustZoneQuery")?.value?.trim();
+  const zone = $("trustZoneZone")?.value?.trim();
+  const sourceClass = $("trustZoneSourceClass")?.value?.trim();
+  if (query) params.set("q", query);
+  if (zone) params.set("zone", zone);
+  if (sourceClass) params.set("sourceClass", sourceClass);
+  params.set("limit", String(trustZoneState.limit));
+  params.set("offset", String(trustZoneState.offset));
+
+  const [statusResponse, browseResponse] = await Promise.all([
+    fetchJson("/engram/v1/trust-zones/status"),
+    fetchJson(`/engram/v1/trust-zones/records?${params.toString()}`),
+  ]);
+  trustZoneState.total = browseResponse.total || 0;
+  const maxOffset = trustZoneState.total > 0
+    ? Math.floor((trustZoneState.total - 1) / trustZoneState.limit) * trustZoneState.limit
+    : 0;
+  if (!resetOffset && trustZoneState.offset > maxOffset) {
+    trustZoneState.offset = maxOffset;
+    return loadTrustZones(false);
+  }
+
+  renderTrustZoneList(browseResponse.records);
+  syncTrustZoneControls();
+  const byZone = statusResponse?.status?.records?.byZone || {};
+  const zoneSummary = ["quarantine", "working", "trusted"]
+    .filter((name) => typeof byZone[name] === "number")
+    .map((name) => `${name} ${byZone[name]}`)
+    .join(" · ");
+  setStatus(
+    "trustZoneStatus",
+    `Loaded ${browseResponse.count} of ${browseResponse.total} trust-zone records.${zoneSummary ? ` ${zoneSummary}.` : ""}`,
+    "ok",
+  );
+}
+
+async function promoteTrustZone(recordId, targetZone, dryRun) {
+  if (!recordId || !targetZone) return;
+  setStatus("trustZoneDetailStatus", `${dryRun ? "Previewing" : "Applying"} ${targetZone} promotion for ${recordId}...`);
+  const response = await fetchJson("/engram/v1/trust-zones/promote", {
+    method: "POST",
+    body: JSON.stringify({
+      recordId,
+      targetZone,
+      promotionReason: dryRun
+        ? `Previewed in Engram admin console for ${recordId}.`
+        : `Promoted in Engram admin console for ${recordId}.`,
+      dryRun,
+    }),
+  });
+  $("trustZoneSeedResult").textContent = JSON.stringify(response, null, 2);
+  $("trustZoneDetail").textContent = JSON.stringify(response.record, null, 2);
+  await loadTrustZones(false);
+  setStatus(
+    "trustZoneDetailStatus",
+    dryRun ? `Previewed ${targetZone} promotion for ${recordId}.` : `Applied ${targetZone} promotion for ${recordId}.`,
+    "ok",
+  );
+}
+
+async function seedTrustZoneDemo(dryRun) {
+  if (!dryRun && typeof window.confirm === "function") {
+    const confirmed = window.confirm(
+      "Seed the explicit trust-zone demo dataset into the current namespace? This is opt-in demo data for buyer-facing walkthroughs.",
+    );
+    if (!confirmed) return;
+  }
+  setStatus("trustZoneStatus", dryRun ? "Previewing trust-zone demo seed..." : "Seeding trust-zone demo dataset...");
+  const response = await fetchJson("/engram/v1/trust-zones/demo-seed", {
+    method: "POST",
+    body: JSON.stringify({
+      scenario: "enterprise-buyer-v1",
+      dryRun,
+    }),
+  });
+  $("trustZoneSeedResult").textContent = JSON.stringify(response, null, 2);
+  if (!dryRun) {
+    await loadTrustZones(true);
+  }
+  setStatus(
+    "trustZoneStatus",
+    dryRun
+      ? `Previewed ${response.records.length} trust-zone demo records.`
+      : `Seeded ${response.recordsWritten} trust-zone demo records into ${response.namespace}.`,
+    "ok",
+  );
+}
+
 async function connectAndBootstrap() {
   const input = $("tokenInput");
   const token = input?.value?.trim() || readToken();
@@ -433,6 +642,7 @@ async function connectAndBootstrap() {
     setStatus("authStatus", "Connected to Engram access API.", "ok");
     await Promise.allSettled([
       loadMemoryBrowser(true),
+      loadTrustZones(true),
       loadReviewQueue(),
       loadEntities(),
       loadQuality(),
@@ -485,6 +695,17 @@ function bootstrap() {
     void loadMemoryBrowser(false);
   });
   $("runRecallButton")?.addEventListener("click", () => void runRecallDebugger());
+  $("refreshTrustZonesButton")?.addEventListener("click", () => void loadTrustZones(true));
+  $("trustZonePrevButton")?.addEventListener("click", () => {
+    stepTrustZonePage(-1);
+    void loadTrustZones(false);
+  });
+  $("trustZoneNextButton")?.addEventListener("click", () => {
+    stepTrustZonePage(1);
+    void loadTrustZones(false);
+  });
+  $("previewTrustZoneSeedButton")?.addEventListener("click", () => void seedTrustZoneDemo(true));
+  $("seedTrustZoneDemoButton")?.addEventListener("click", () => void seedTrustZoneDemo(false));
   $("refreshQueueButton")?.addEventListener("click", () => void loadReviewQueue());
   $("searchEntitiesButton")?.addEventListener("click", () => void loadEntities());
   $("copyMemoryPathButton")?.addEventListener("click", copyMemoryPath);
@@ -493,6 +714,7 @@ function bootstrap() {
     void connectAndBootstrap();
   } else {
     syncBrowserControls();
+    syncTrustZoneControls();
   }
 }
 

package/dist/admin-console/public/index.html

@@ -194,6 +194,15 @@
         font-size: 0.84rem;
         color: var(--muted);
       }
+      .callout {
+        border: 1px dashed var(--line);
+        border-radius: 14px;
+        padding: 12px 14px;
+        background: rgba(255, 255, 255, 0.62);
+        color: var(--muted);
+        font-size: 0.88rem;
+        line-height: 1.45;
+      }
       .status.ok {
         color: var(--ok);
       }
@@ -360,6 +369,69 @@
         </section>
       </div>
 
+      <div class="grid" style="margin-top: 16px;">
+        <section class="card">
+          <h2>Trust Zones</h2>
+          <div class="callout">
+            Demo data is never seeded automatically. Use the explicit seed action below only when you want a buyer-facing trust-zone walkthrough dataset.
+          </div>
+          <div class="toolbar" style="margin-top: 12px;">
+            <label style="flex: 1;">
+              Query
+              <input id="trustZoneQuery" type="text" placeholder="Search summaries, tags, metadata, or entity refs" />
+            </label>
+            <label>
+              Zone
+              <select id="trustZoneZone">
+                <option value="">All</option>
+                <option value="quarantine">quarantine</option>
+                <option value="working">working</option>
+                <option value="trusted">trusted</option>
+              </select>
+            </label>
+            <label>
+              Source
+              <select id="trustZoneSourceClass">
+                <option value="">All</option>
+                <option value="tool_output">tool_output</option>
+                <option value="web_content">web_content</option>
+                <option value="subagent_trace">subagent_trace</option>
+                <option value="system_memory">system_memory</option>
+                <option value="user_input">user_input</option>
+                <option value="manual">manual</option>
+              </select>
+            </label>
+            <label>
+              Page Size
+              <select id="trustZonePageSize">
+                <option value="8">8</option>
+                <option value="12" selected>12</option>
+                <option value="20">20</option>
+              </select>
+            </label>
+            <button id="refreshTrustZonesButton">Refresh</button>
+            <button class="secondary" id="previewTrustZoneSeedButton">Preview Demo Seed</button>
+            <button class="accent" id="seedTrustZoneDemoButton">Seed Demo Dataset</button>
+          </div>
+          <div class="toolbar pager" style="margin-top: 12px;">
+            <div class="status" id="trustZoneStatus">No trust-zone data loaded yet.</div>
+            <div class="toolbar">
+              <button class="secondary" id="trustZonePrevButton">Previous</button>
+              <div class="status" id="trustZonePageStatus">Page 1</div>
+              <button class="secondary" id="trustZoneNextButton">Next</button>
+            </div>
+          </div>
+          <div class="list" id="trustZoneList"></div>
+        </section>
+
+        <section class="card">
+          <h2>Trust Zone Detail</h2>
+          <div class="status" id="trustZoneDetailStatus">Select a trust-zone record to inspect raw lineage and promotion state.</div>
+          <div class="mono-box" style="margin-top: 12px;"><pre id="trustZoneDetail">Trust-zone detail will appear here.</pre></div>
+          <div class="mono-box" style="margin-top: 12px;"><pre id="trustZoneSeedResult">Demo seed previews and promotion results will appear here.</pre></div>
+        </section>
+      </div>
+
       <div class="grid" style="margin-top: 16px;">
         <section class="card">
           <h2>Review Queue</h2>

package/dist/{chunk-Y6DMH5LN.js → chunk-IADQJS2J.js}

@@ -2227,7 +2227,13 @@ ${sanitized.text}
   invalidateAllMemoriesCache() {
     _StorageManager.allMemoriesInFlight.delete(this.baseDir);
   }
-  async _readAllMemoriesFromDisk() {
+  normalizeMemoryReadBatchSize(batchSize) {
+    if (typeof batchSize !== "number" || !Number.isFinite(batchSize)) {
+      return 50;
+    }
+    return Math.max(1, Math.floor(batchSize));
+  }
+  async collectActiveMemoryPaths() {
     const filePaths = [];
     const collectPaths = async (dir) => {
       try {
@@ -2249,11 +2255,14 @@ ${sanitized.text}
     };
     await collectPaths(this.factsDir);
     await collectPaths(this.correctionsDir);
+    return filePaths;
+  }
+  async readParsedMemoriesFromPaths(filePaths, batchSize) {
     if (filePaths.length === 0) return [];
-    const BATCH_SIZE = 50;
+    const normalizedBatchSize = this.normalizeMemoryReadBatchSize(batchSize);
     const memories = [];
-    for (let i = 0; i < filePaths.length; i += BATCH_SIZE) {
-      const batch = filePaths.slice(i, i + BATCH_SIZE);
+    for (let i = 0; i < filePaths.length; i += normalizedBatchSize) {
+      const batch = filePaths.slice(i, i + normalizedBatchSize);
       const results = await Promise.all(
         batch.map(async (fullPath) => {
           try {
@@ -2273,12 +2282,126 @@ ${sanitized.text}
           }
         })
       );
-      for (const m of results) {
-        if (m !== null) memories.push(m);
+      for (const memory of results) {
+        if (memory !== null) memories.push(memory);
       }
     }
     return memories;
   }
+  async readWindowUpdatedMs(filePath) {
+    try {
+      const raw = await readFile2(filePath, "utf-8");
+      const match = raw.match(/^---\n([\s\S]*?)\n---\n?/);
+      if (!match) return null;
+      const frontmatterBlock = match[1];
+      const rawUpdated = frontmatterBlock.match(/^updated:\s*"?([^"\n]*)"?/m)?.[1] ?? frontmatterBlock.match(/^created:\s*"?([^"\n]*)"?/m)?.[1] ?? null;
+      const updatedMs = rawUpdated ? Date.parse(rawUpdated) : Number.NaN;
+      return Number.isFinite(updatedMs) ? updatedMs : null;
+    } catch {
+      return null;
+    }
+  }
+  async filterWindowPathsByUpdatedAfter(filePaths, updatedAfterMs) {
+    const results = await Promise.all(filePaths.map(async (filePath) => {
+      const updatedMs = await this.readWindowUpdatedMs(filePath);
+      if (updatedMs !== null) {
+        return updatedMs >= updatedAfterMs ? filePath : null;
+      }
+      try {
+        const fileStat = await stat2(filePath);
+        return fileStat.mtimeMs >= updatedAfterMs ? filePath : null;
+      } catch {
+        return filePath;
+      }
+    }));
+    return results.filter((filePath) => filePath !== null);
+  }
+  orderWindowPaths(filePaths) {
+    const correctionPaths = [];
+    const factPaths = [];
+    for (const filePath of filePaths) {
+      if (filePath === this.correctionsDir || filePath.startsWith(`${this.correctionsDir}${path4.sep}`)) {
+        correctionPaths.push(filePath);
+      } else {
+        factPaths.push(filePath);
+      }
+    }
+    correctionPaths.sort((left, right) => right.localeCompare(left));
+    factPaths.sort((left, right) => right.localeCompare(left));
+    if (correctionPaths.length === 0) return factPaths;
+    if (factPaths.length === 0) return correctionPaths;
+    const ordered = [];
+    const maxLength = Math.max(correctionPaths.length, factPaths.length);
+    for (let i = 0; i < maxLength; i += 1) {
+      const correctionPath = correctionPaths[i];
+      if (correctionPath) ordered.push(correctionPath);
+      const factPath = factPaths[i];
+      if (factPath) ordered.push(factPath);
+    }
+    return ordered;
+  }
+  async readWindowBoundedBatch(candidateBatchPaths, remainingSlots, remainingInspectionBudget, readBatchSize) {
+    const memories = [];
+    const filePaths = [];
+    const normalizedReadBatchSize = this.normalizeMemoryReadBatchSize(readBatchSize);
+    for (let index = 0; index < candidateBatchPaths.length; ) {
+      if (memories.length >= remainingSlots || filePaths.length >= remainingInspectionBudget) break;
+      const availableSlots = remainingSlots - memories.length;
+      const availableInspectionBudget = remainingInspectionBudget - filePaths.length;
+      const parallelWindow = availableSlots >= 4 && availableInspectionBudget >= 4 ? Math.min(normalizedReadBatchSize, 4) : 1;
+      const candidatePaths = candidateBatchPaths.slice(
+        index,
+        index + Math.min(parallelWindow, availableInspectionBudget)
+      );
+      index += candidatePaths.length;
+      if (candidatePaths.length === 0) break;
+      filePaths.push(...candidatePaths);
+      const parsedMemories = await this.readParsedMemoriesFromPaths(candidatePaths, candidatePaths.length);
+      if (parsedMemories.length === 0) continue;
+      memories.push(...parsedMemories.slice(0, availableSlots));
+    }
+    return { memories, filePaths };
+  }
+  async readMemoriesWindow(options = {}) {
+    const allPaths = await this.collectActiveMemoryPaths();
+    const sortedPaths = this.orderWindowPaths(allPaths);
+    const maxMemories = typeof options.maxMemories === "number" && Number.isFinite(options.maxMemories) ? Math.max(1, Math.floor(options.maxMemories)) : void 0;
+    const maxCandidatePaths = maxMemories === void 0 ? void 0 : maxMemories * 2;
+    const updatedAfterMs = options.updatedAfter?.getTime();
+    const normalizedBatchSize = this.normalizeMemoryReadBatchSize(options.batchSize);
+    const memories = [];
+    const selectedPaths = [];
+    for (let i = 0; i < sortedPaths.length; i += normalizedBatchSize) {
+      if (maxMemories !== void 0 && (memories.length >= maxMemories || maxCandidatePaths !== void 0 && selectedPaths.length >= maxCandidatePaths)) {
+        return { memories, filePaths: selectedPaths };
+      }
+      const batchPaths = sortedPaths.slice(i, i + normalizedBatchSize);
+      const candidateBatchPaths = updatedAfterMs === void 0 ? batchPaths : await this.filterWindowPathsByUpdatedAfter(batchPaths, updatedAfterMs);
+      const remainingSlots = maxMemories === void 0 ? void 0 : Math.max(0, maxMemories - memories.length);
+      const remainingInspectionBudget = maxCandidatePaths === void 0 ? void 0 : Math.max(0, maxCandidatePaths - selectedPaths.length);
+      const { memories: batchMemories, filePaths: parsedCandidatePaths } = remainingSlots === void 0 ? {
+        memories: await this.readParsedMemoriesFromPaths(candidateBatchPaths, normalizedBatchSize),
+        filePaths: candidateBatchPaths
+      } : await this.readWindowBoundedBatch(
+        candidateBatchPaths,
+        remainingSlots,
+        remainingInspectionBudget ?? remainingSlots,
+        normalizedBatchSize
+      );
+      selectedPaths.push(...parsedCandidatePaths);
+      for (const memory of batchMemories) {
+        memories.push(memory);
+        if (maxMemories !== void 0 && memories.length >= maxMemories) {
+          return { memories, filePaths: selectedPaths };
+        }
+      }
+    }
+    return { memories, filePaths: selectedPaths };
+  }
+  async _readAllMemoriesFromDisk() {
+    const filePaths = await this.collectActiveMemoryPaths();
+    return this.readParsedMemoriesFromPaths(filePaths, 50);
+  }
   /**
    * Read archived memory markdown files under archive/.
    * Used by long-term recall fallback when hot recall has no hits.
@@ -4088,4 +4211,4 @@ export {
   serializeEntityFile,
   StorageManager
 };
-//# sourceMappingURL=chunk-Y6DMH5LN.js.map
+//# sourceMappingURL=chunk-IADQJS2J.js.map