@digitalforgestudios/openclaw-sulcus 3.9.0 → 3.11.0

package/index.ts

@@ -104,8 +104,8 @@ const hookHandlers: Record<string, HookHandler> = {
     if (!prompt) return;
     try {
       const limit = config.limit ?? 5;
-      logger.debug(`sulcus: searching context for prompt: ${prompt.substring(0, 50)}...`);
-      const res = await sulcusMem.search_memory(prompt, limit);
+      logger.debug(`sulcus: searching context for prompt: ${prompt.substring(0, 50)}... (namespace: ${namespace})`);
+      const res = await sulcusMem.search_memory(prompt, limit, namespace);
       const results = res?.results ?? [];
       if (!results || results.length === 0) {
         return { prependSystemContext: FALLBACK_AWARENESS };
@@ -280,9 +280,10 @@ class SulcusCloudClient {
    * search_memory — maps to POST /agent/search
    * Server returns { results: [...] }; we normalise to the results array.
    */
-  async search_memory(query: string, limit?: number): Promise<{ results: any[] }> {
+  async search_memory(query: string, limit?: number, namespace?: string): Promise<{ results: any[] }> {
     const body: any = { query };
     if (limit !== undefined) body.limit = limit;
+    if (namespace !== undefined) body.namespace = namespace;
     const res = await this.request("POST", "/api/v1/agent/search", body);
     const results = res?.results ?? res?.items ?? res?.nodes ?? (Array.isArray(res) ? res : []);
     return { results };
@@ -300,12 +301,15 @@ class SulcusCloudClient {
   }
 
   /**
-   * list_hot_nodes — maps to GET /agent/memory/status
+   * list_hot_nodes — maps to GET /agent/hot_nodes
    * Returns hot_nodes list; normalised for memory_status tool.
+   * Note: was incorrectly calling /agent/memory/status which doesn't return hot_nodes.
    */
-  async list_hot_nodes(_limit?: number): Promise<{ nodes: any[] }> {
-    const res = await this.request("GET", "/api/v1/agent/memory/status");
-    const nodes = res?.hot_nodes ?? res?.nodes ?? [];
+  async list_hot_nodes(limit?: number): Promise<{ nodes: any[] }> {
+    const q = limit ? `?limit=${limit}` : "";
+    const res = await this.request("GET", `/api/v1/agent/hot_nodes${q}`);
+    // Server returns an array directly from this endpoint
+    const nodes = Array.isArray(res) ? res : (res?.hot_nodes ?? res?.nodes ?? []);
     return { nodes };
   }
 
@@ -318,6 +322,15 @@ class SulcusCloudClient {
     return this.request("POST", "/api/v1/agent/consolidate", body);
   }
 
+  /**
+   * delete_memory — maps to DELETE /agent/nodes/:id?train=true|false
+   * If train=true, snapshots content before deletion and records a 'reject' training signal for SIVU.
+   */
+  async delete_memory(id: string, train?: boolean): Promise<any> {
+    const trainParam = train ? "true" : "false";
+    return this.request("DELETE", `/api/v1/agent/nodes/${encodeURIComponent(id)}?train=${trainParam}`);
+  }
+
   /**
    * export_markdown — maps to GET /agent/export?format=markdown
    * Returns raw markdown string.
@@ -501,6 +514,20 @@ const JUNK_PATTERNS = [
   /^<<<EXTERNAL_UNTRUSTED_CONTENT/i,
   /^Runtime:/i,
   /tool_call|function_call|<function_calls>/i,
+  // Subagent completion events — internal runtime artifacts, not memories
+  /\[Inter-session message\]\s*sourceSession=/i,
+  /<<<BEGIN_UNTRUSTED_CHILD_RESULT>>>/,
+  /<<<END_UNTRUSTED_CHILD_RESULT>>>/,
+  /\[Internal task completion event\]/i,
+  /^source:\s*subagent/im,
+  /session_key:\s*agent:main:subagent:/i,
+  // Cron task payloads — system prompts, not meaningful content
+  /^Sulcus validation cycle\./i,
+  /^Heartbeat prompt:/i,
+  /OpenClaw runtime context \(internal\)/i,
+  // Credential patterns — should never be stored
+  /\b(sk-[a-f0-9]{40,}|Bearer\s+[A-Za-z0-9._~+/=-]{20,})\b/,
+  /\b(api[_-]?key|secret|password|token)\s*[:=]\s*["']?[A-Za-z0-9._~+/=-]{16,}/i,
 ];
 
 function isJunkMemory(text: string): boolean {
@@ -601,7 +628,8 @@ const toolDefinitions: Record<string, ToolDefinition> = {
       description: "Search Sulcus memory for relevant context",
       parameters: Type.Object({
         query: Type.String({ description: "Search query string." }),
-        limit: Type.Optional(Type.Number({ default: 5, description: "Maximum number of results to return (1-10)." }))
+        limit: Type.Optional(Type.Number({ default: 5, description: "Maximum number of results to return (1-10)." })),
+        namespace: Type.Optional(Type.String({ description: "Namespace to search. Defaults to your own namespace. Specify another to cross-search (ACL enforced)." }))
       }),
     },
     options: { name: "memory_recall" },
@@ -610,11 +638,14 @@ const toolDefinitions: Record<string, ToolDefinition> = {
         if (!isAvailable) {
           throw new Error(`Sulcus unavailable: ${nativeLoader.error || "WASM not loaded"}`);
         }
-        const res = await sulcusMem.search_memory(params.query, params.limit ?? 5);
+        // Default to agent's own namespace to prevent cross-namespace bleed.
+        // Agent can explicitly pass namespace to search another (ACL enforced server-side).
+        const searchNamespace = params.namespace ?? namespace;
+        const res = await sulcusMem.search_memory(params.query, params.limit ?? 5, searchNamespace);
         const results = res?.results ?? res?.items ?? res?.nodes ?? res ?? [];
         return {
           content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
-          details: { results, backend: backendMode, namespace }
+          details: { results, backend: backendMode, namespace: searchNamespace }
         };
       },
   },
@@ -633,6 +664,7 @@ const toolDefinitions: Record<string, ToolDefinition> = {
           Type.Literal("procedural"),
           Type.Literal("fact")
         ], { description: "Memory type. preference=user preferences, procedural=how-to/processes, fact=stable knowledge, semantic=concepts/relationships, episodic=events/experiences. Default: episodic" })),
+        train: Type.Optional(Type.Boolean({ description: "Signal the SIU to learn from this manual store. When true, this memory+type becomes a positive training example for both SIVU (store=yes) and SICU (type=<memory_type>). Default: false" })),
       }),
     },
     options: { name: "memory_store" },
@@ -652,9 +684,27 @@ const toolDefinitions: Record<string, ToolDefinition> = {
         const res = await sulcusMem.add_memory(params.content, params.memory_type ?? null);
         const nodeId = res?.id ?? "unknown";
         const mtype = params.memory_type || "episodic";
+        // If train=true, submit a training signal to the SIU
+        let trainResult: string | null = null;
+        if (params.train && (sulcusMem as any).request) {
+          try {
+            await (sulcusMem as any).request("POST", "/api/v2/siu/signal", {
+              memory_id: nodeId,
+              text: params.content,
+              sivu_label: "store",
+              sicu_label: mtype,
+              source: "agent_manual_store",
+            });
+            trainResult = "training signal submitted";
+            logger.info(`sulcus: SIU training signal sent for memory ${nodeId} (store, ${mtype})`);
+          } catch (e: any) {
+            trainResult = `training signal failed: ${e.message}`;
+            logger.warn(`sulcus: SIU training signal failed: ${e.message}`);
+          }
+        }
         return {
-          content: [{ type: "text", text: `Stored [${mtype}] memory (id: ${nodeId}) → backend: ${backendMode}, namespace: ${namespace}` }],
-          details: { id: nodeId, memory_type: mtype, backend: backendMode, namespace, ...res }
+          content: [{ type: "text", text: `Stored [${mtype}] memory (id: ${nodeId}) → backend: ${backendMode}, namespace: ${namespace}${trainResult ? ` | SIU: ${trainResult}` : ""}` }],
+          details: { id: nodeId, memory_type: mtype, backend: backendMode, namespace, train: trainResult, ...res }
         };
       },
   },
@@ -683,7 +733,11 @@ const toolDefinitions: Record<string, ToolDefinition> = {
           };
         }
         try {
-          const hotNodes = await sulcusMem.list_hot_nodes(20);
+          // Fetch both status info and hot nodes in parallel
+          const [statusInfo, hotNodes] = await Promise.all([
+            sulcusMem.request("GET", "/api/v1/agent/memory/status").catch(() => null),
+            sulcusMem.list_hot_nodes(20),
+          ]);
           const nodeList = hotNodes?.nodes ?? hotNodes ?? [];
           const count = Array.isArray(nodeList) ? nodeList.length : 0;
           return {
@@ -691,10 +745,12 @@ const toolDefinitions: Record<string, ToolDefinition> = {
               status: "ok",
               backend: backendMode,
               namespace,
+              ...(statusInfo?.capabilities ? { capabilities: statusInfo.capabilities } : {}),
+              ...(statusInfo?.stats ? { stats: statusInfo.stats } : {}),
               hot_node_count: count,
               hot_nodes: nodeList,
             }, null, 2) }],
-            details: { status: "ok", backend: backendMode, namespace, count }
+            details: { status: "ok", backend: backendMode, namespace, count, ...(statusInfo?.stats ?? {}) }
           };
         } catch (e: any) {
           return {
@@ -802,6 +858,31 @@ const toolDefinitions: Record<string, ToolDefinition> = {
       },
   },
 
+  memory_delete: {
+    schema: {
+      name: "memory_delete",
+      label: "Delete Memory",
+      description: "Delete a memory node by ID. With train=true (default), the deleted content trains SIVU to reject similar content in the future. Use this to clean up junk, duplicates, or noise memories.",
+      parameters: Type.Object({
+        id: Type.String({ description: "Memory node ID to delete." }),
+        train: Type.Optional(Type.Boolean({ default: true, description: "Train SIVU to reject similar content (default true). Set false to delete without training." })),
+      }),
+    },
+    options: { name: "memory_delete" },
+    makeExecute: ({ sulcusMem, backendMode, namespace, nativeLoader, isAvailable }) =>
+      async (_id: string, params: any) => {
+        if (!isAvailable) {
+          throw new Error(`Sulcus unavailable: ${nativeLoader.error || "WASM not loaded"}`);
+        }
+        const train = params.train !== false; // default true
+        const res = await (sulcusMem as SulcusCloudClient).delete_memory(params.id, train);
+        return {
+          content: [{ type: "text", text: `Deleted memory ${params.id}${train ? " (trained SIVU to reject similar)" : ""}. Backend: ${backendMode}, namespace: ${namespace}` }],
+          details: { id: params.id, trained: train, result: res, backend: backendMode, namespace }
+        };
+      },
+  },
+
   // ── SIU v2 Tools ───────────────────────────────────────────────────────────
   // These tools call the SIU v2 server endpoints for text classification.
   // Requires cloud backend (serverUrl + apiKey). Uses /api/v2/siu/* endpoints.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digitalforgestudios/openclaw-sulcus",
-  "version": "3.9.0",
+  "version": "3.11.0",
   "description": "Sulcus — reactive, thermodynamic memory plugin for OpenClaw. Opt-in persistent memory with heat-based decay, semantic search, and cross-agent sync. Auto-recall and auto-capture disabled by default.",
   "keywords": [
     "openclaw",