@remnic/plugin-openclaw 9.54.4 → 9.54.5

package/dist/index.js

@@ -214,6 +214,49 @@ import {
 
 // ../../src/tools.ts
 import { runMemoryGovernance } from "@remnic/core/maintenance/memory-governance";
+
+// ../../src/memory-action-target.ts
+import { isSupportPassportPrivateMemory } from "@remnic/core";
+function clampUnitInterval(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  if (value < 0) return 0;
+  if (value > 1) return 1;
+  return value;
+}
+function normalizeEligibilitySource(value) {
+  switch (value) {
+    case "extraction":
+    case "consolidation":
+    case "replay":
+    case "manual":
+      return value;
+    default:
+      return "unknown";
+  }
+}
+function deriveMemoryActionPolicyEligibility(memory) {
+  if (!memory) return void 0;
+  const frontmatter = memory.frontmatter;
+  return {
+    confidence: clampUnitInterval(frontmatter.confidence, 0),
+    lifecycleState: frontmatter.status === "archived" ? "archived" : frontmatter.lifecycleState ?? "candidate",
+    importance: clampUnitInterval(frontmatter.importance?.score, 0),
+    source: normalizeEligibilitySource(frontmatter.source)
+  };
+}
+async function readReferencedMemoryForPolicyEligibility(storage, memoryId) {
+  if (!memoryId) return void 0;
+  const direct = await storage.getMemoryById?.(memoryId);
+  if (direct) return direct;
+  const active = (await storage.readAllMemories?.())?.find((memory) => memory.frontmatter.id === memoryId);
+  if (active) return active;
+  return (await storage.readArchivedMemories?.())?.find((memory) => memory.frontmatter.id === memoryId);
+}
+function blocksSupportPassportMutation(action, memory) {
+  return (action === "update_note" || action === "discard" || action === "link_graph") && Boolean(memory && isSupportPassportPrivateMemory(memory));
+}
+
+// ../../src/tools.ts
 function toolResult(text) {
   return { content: [{ type: "text", text }], details: void 0 };
 }
@@ -232,12 +275,6 @@ function asNonEmptyString(value) {
 function normalizeToolNamespace(value) {
   return asNonEmptyString(value);
 }
-function clampUnitInterval(value, fallback) {
-  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
-  if (value < 0) return 0;
-  if (value > 1) return 1;
-  return value;
-}
 function normalizeProfilingReportLimit(value) {
   if (value === void 0) return 5;
   if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value)) {
@@ -252,43 +289,7 @@ function normalizeMemorySearchResultLimit(value) {
   }
   return Math.min(Math.max(value, 1), 50);
 }
-function normalizeMemoryActionEligibilitySource(value) {
-  switch (value) {
-    case "extraction":
-    case "consolidation":
-    case "replay":
-    case "manual":
-      return value;
-    default:
-      return "unknown";
-  }
-}
-function deriveMemoryActionPolicyEligibility(memory) {
-  if (!memory) return void 0;
-  const frontmatter = memory.frontmatter;
-  return {
-    confidence: clampUnitInterval(frontmatter.confidence, 0),
-    lifecycleState: frontmatter.status === "archived" ? "archived" : frontmatter.lifecycleState ?? "candidate",
-    importance: clampUnitInterval(frontmatter.importance?.score, 0),
-    source: normalizeMemoryActionEligibilitySource(frontmatter.source)
-  };
-}
-async function readReferencedMemoryForPolicyEligibility(storage, memoryId) {
-  if (!memoryId) return void 0;
-  if (typeof storage.getMemoryById === "function") {
-    const direct = await storage.getMemoryById(memoryId);
-    if (direct) return direct;
-  }
-  if (typeof storage.readAllMemories === "function") {
-    const active = (await storage.readAllMemories()).find((memory) => memory.frontmatter.id === memoryId);
-    if (active) return active;
-  }
-  if (typeof storage.readArchivedMemories === "function") {
-    const archived = (await storage.readArchivedMemories()).find((memory) => memory.frontmatter.id === memoryId);
-    if (archived) return archived;
-  }
-  return void 0;
-}
+var MEMORY_SEARCH_CANDIDATE_CAP = 25e3;
 var WORK_TASK_STATUSES = /* @__PURE__ */ new Set(["todo", "in_progress", "blocked", "done", "cancelled"]);
 var WORK_TASK_PRIORITIES = /* @__PURE__ */ new Set(["low", "medium", "high"]);
 var WORK_PROJECT_STATUSES = /* @__PURE__ */ new Set(["active", "on_hold", "completed", "archived"]);
@@ -568,12 +569,39 @@ Best for:
           const { query, maxResults, collection, namespace } = params;
           const namespaceFilter = namespace && namespace.length > 0 ? namespace : void 0;
           const resultLimit = normalizeMemorySearchResultLimit(maxResults);
-          const filtered = collection === "global" && !namespaceFilter ? (await orchestrator.qmd.searchGlobal(query, resultLimit)).slice(0, resultLimit) : await orchestrator.searchAcrossNamespaces({
+          const searchCandidates = async (limit) => collection === "global" && !namespaceFilter ? await orchestrator.qmd.searchGlobal(query, limit) : await orchestrator.searchAcrossNamespaces({
             query,
             namespaces: namespaceFilter ? [namespaceFilter] : void 0,
-            maxResults: resultLimit,
+            maxResults: limit,
             mode: "search"
           });
+          let candidateLimit = resultLimit;
+          const privateVisibilityCache = /* @__PURE__ */ new Map();
+          let candidates = await searchCandidates(candidateLimit);
+          let filtered = await orchestrator.filterPrivateSearchResults(
+            candidates,
+            namespaceFilter ? [namespaceFilter] : [],
+            false,
+            privateVisibilityCache
+          );
+          while (filtered.length < resultLimit && candidates.length >= candidateLimit && candidateLimit < MEMORY_SEARCH_CANDIDATE_CAP) {
+            const nextCandidateLimit = Math.min(
+              MEMORY_SEARCH_CANDIDATE_CAP,
+              Math.max(candidateLimit + 16, candidateLimit * 2)
+            );
+            if (nextCandidateLimit === candidateLimit) break;
+            const nextCandidates = await searchCandidates(nextCandidateLimit);
+            if (nextCandidates.length <= candidates.length) break;
+            candidateLimit = nextCandidateLimit;
+            candidates = nextCandidates;
+            filtered = await orchestrator.filterPrivateSearchResults(
+              candidates,
+              namespaceFilter ? [namespaceFilter] : [],
+              false,
+              privateVisibilityCache
+            );
+          }
+          filtered = filtered.slice(0, resultLimit);
           if (filtered.length === 0) {
             return toolResult(`No memories found matching: "${query}"`);
           }
@@ -1600,6 +1628,19 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
         }
         const storage = typeof orchestrator.getStorage === "function" ? await orchestrator.getStorage(ns) : orchestrator.storage;
         const referencedMemory = await readReferencedMemoryForPolicyEligibility(storage, memoryIdValue);
+        if (blocksSupportPassportMutation(action, referencedMemory)) {
+          await orchestrator.appendMemoryActionEvent({
+            ...baseEvent,
+            outcome: "failed",
+            status: "rejected",
+            dryRun: dryRun === true,
+            outputMemoryIds: [],
+            reason: "validation: support passport records require the owner surface"
+          });
+          return toolResult(
+            "Validation failed: support passport records can only be changed through the support passport owner surface."
+          );
+        }
         const structuredEvent = {
           ...baseEvent,
           outcome: outcome ?? "applied",
@@ -8403,9 +8444,11 @@ function buildTurnFingerprint(input) {
 import { planRecallMode } from "@remnic/core/intent";
 import {
   expandTildePath as expandTildePath4,
+  isSupportPassportPrivateMemory as isSupportPassportPrivateMemory2,
   renderMemoryContextPrompt as renderSharedMemoryContextPrompt,
   resolveAgentAccessAuthToken,
-  resolvePrincipal
+  resolvePrincipal,
+  searchWithGenericExclusion
 } from "@remnic/core";
 import {
   normalizeHostEmbeddingVector,
@@ -10671,17 +10714,27 @@ Keep the reflection grounded in the evidence below.
                 async search(query, opts) {
                   const namespace = typeof orchestrator.resolveSelfNamespace === "function" ? orchestrator.resolveSelfNamespace(opts?.sessionKey) : void 0;
                   const resolvedMode = opts?.qmdSearchModeOverride === "vsearch" ? "vector" : opts?.qmdSearchModeOverride === "query" ? "search" : opts?.qmdSearchModeOverride ?? "search";
-                  const rawResults = await orchestrator.searchAcrossNamespaces({
-                    query,
-                    maxResults: opts?.maxResults,
-                    namespaces: namespace ? [namespace] : void 0,
-                    mode: resolvedMode
+                  const requestedMaxResults = typeof opts?.maxResults === "number" && Number.isFinite(opts.maxResults) ? Math.max(0, Math.floor(opts.maxResults)) : void 0;
+                  const minScore = typeof opts?.minScore === "number" && Number.isFinite(opts.minScore) ? opts.minScore : void 0;
+                  const visibleResults = await searchWithGenericExclusion({
+                    budget: requestedMaxResults ?? Number.MAX_SAFE_INTEGER,
+                    sendInitialLimit: requestedMaxResults !== void 0,
+                    search: (limit) => orchestrator.searchAcrossNamespaces({
+                      query,
+                      ...limit !== void 0 ? { maxResults: limit } : {},
+                      namespaces: namespace ? [namespace] : void 0,
+                      mode: resolvedMode
+                    }),
+                    filterPrivate: async (results) => {
+                      const visible = await orchestrator.filterPrivateSearchResults(
+                        results,
+                        namespace ? [namespace] : []
+                      );
+                      return minScore === void 0 ? visible : visible.filter((result) => result.score >= minScore);
+                    },
+                    isExcluded: (resultPath) => isMemoryArtifactPath(resultPath)
                   });
-                  return rawResults.filter((result) => {
-                    const candidate = result;
-                    const p = typeof candidate.path === "string" ? candidate.path : typeof candidate.id === "string" ? candidate.id : "";
-                    return !isMemoryArtifactPath(p);
-                  }).map((result, index) => {
+                  return visibleResults.map((result, index) => {
                     const candidate = result;
                     const rawPath = typeof candidate.path === "string" ? candidate.path : typeof candidate.id === "string" ? candidate.id : `memory-${index + 1}`;
                     const absolutePath = readScope.absolutize(rawPath);
@@ -10697,13 +10750,20 @@ Keep the reflection grounded in the evidence below.
                       source: isSessionsMemoryPath(normalizedPath) ? "sessions" : "memory",
                       citation: normalizedPath
                     };
-                  }).filter(
-                    (result) => typeof opts?.minScore === "number" && Number.isFinite(opts.minScore) ? result.score >= opts.minScore : true
-                  );
+                  });
                 },
                 async readFile(params) {
                   const requestedPath = readScope.normalizeWorkspacePath(params.relPath);
                   const absolutePath = await readScope.resolveReadablePath(params.relPath);
+                  const visible = await orchestrator.filterPrivateSearchResults([{
+                    docid: absolutePath,
+                    path: absolutePath,
+                    snippet: "",
+                    score: 0
+                  }], [], true);
+                  if (visible.length === 0) {
+                    throw new Error(`memory read excluded (private record): ${params.relPath}`);
+                  }
                   const text = await readTextFileLater(absolutePath);
                   const allLines = text.split(/\r?\n/);
                   const from = typeof params.from === "number" ? Math.max(1, Math.floor(params.from)) : 1;
@@ -11594,17 +11654,22 @@ Keep the reflection grounded in the evidence below.
           const agentSessionKey = typeof params === "object" ? params.agentSessionKey : void 0;
           const namespace = typeof orchestrator.resolveSelfNamespace === "function" ? orchestrator.resolveSelfNamespace(agentSessionKey) : void 0;
           try {
-            const rawResults = await orchestrator.searchAcrossNamespaces({
-              query,
-              maxResults,
-              namespaces: namespace ? [namespace] : void 0,
-              mode: "search"
+            const visibleResults = await searchWithGenericExclusion({
+              budget: maxResults,
+              sendInitialLimit: true,
+              search: (limit) => orchestrator.searchAcrossNamespaces({
+                query,
+                ...limit !== void 0 ? { maxResults: limit } : {},
+                namespaces: namespace ? [namespace] : void 0,
+                mode: "search"
+              }),
+              filterPrivate: (results) => orchestrator.filterPrivateSearchResults(
+                results,
+                namespace ? [namespace] : []
+              ),
+              isExcluded: (resultPath) => isMemoryArtifactPath(resultPath)
             });
-            return rawResults.filter((result) => {
-              const candidate = result;
-              const p = typeof candidate.path === "string" ? candidate.path : typeof candidate.id === "string" ? candidate.id : "";
-              return !isMemoryArtifactPath(p);
-            }).map((result, index) => {
+            return visibleResults.map((result, index) => {
               const candidate = result;
               const lookupPath = typeof candidate.path === "string" ? candidate.path : typeof candidate.id === "string" ? candidate.id : `remnic-memory-${index + 1}`;
               const startLine = typeof candidate.startLine === "number" && Number.isFinite(candidate.startLine) ? Math.max(1, Math.floor(candidate.startLine)) : 1;
@@ -11642,7 +11707,7 @@ Keep the reflection grounded in the evidence below.
             const resolved = await readMemoryByLookup(lookup, agentSessionKey);
             if (!resolved) return null;
             const { memory, displayPath } = resolved;
-            if (isMemoryArtifactPath(displayPath) || isMemoryArtifactPath(memory.path)) {
+            if (isMemoryArtifactPath(displayPath) || isMemoryArtifactPath(memory.path) || isSupportPassportPrivateMemory2(memory)) {
               return null;
             }
             const allLines = memory.content.split(/\r?\n/);