@digitalforgestudios/openclaw-sulcus 6.6.2 → 6.6.4

package/index.ts

@@ -5295,16 +5295,215 @@ const sulcusPlugin = {
       }
     }
 
-    // 3. registerMemoryFlushPlan — no custom compaction flush
+    // 3. registerMemoryFlushPlan — Sulcus-aware pre-compaction flush
     if (typeof (api.registerMemoryFlushPlan as unknown) === "function") {
       try {
-        (api.registerMemoryFlushPlan as (r: unknown) => void)(() => null);
-        logger.info("sulcus: registered memory flush plan (no-op)");
+        (api.registerMemoryFlushPlan as (r: unknown) => void)(() => {
+          if (!isAvailable || !sulcusMem) return null;
+          return {
+            softThresholdTokens: 15000,
+            forceFlushTranscriptBytes: "2mb",
+            reserveTokensFloor: 30000,
+            prompt: [
+              "Your session is approaching context limits. Before compaction, extract and save the most important information from this conversation using memory_store.",
+              "",
+              "Focus on:",
+              "- Decisions made and their reasoning",
+              "- Facts learned or confirmed",
+              "- User preferences stated or implied",
+              "- Procedures or workflows discussed",
+              "- Errors encountered and their resolutions",
+              "",
+              "Use the appropriate memory_type for each:",
+              "- preference: user preferences, opinions, style choices",
+              "- fact: data points, configurations, names, values",
+              "- semantic: knowledge, explanations, conclusions",
+              "- procedural: how-tos, workflows, step-by-step processes",
+              "- episodic: events, conversations, time-specific context",
+              "",
+              "Store 3-8 memories. Be selective — quality over quantity. Skip trivial exchanges.",
+            ].join("\n"),
+            systemPrompt: "You are a memory extraction agent. Your job is to identify and store the most valuable information from the current conversation before it gets compacted. Use memory_store with precise memory_type classification. Do not store system noise, tool outputs, or trivial exchanges.",
+          };
+        });
+        logger.info("sulcus: registered memory flush plan (Sulcus-aware)");
       } catch (e: unknown) {
         logger.warn(`sulcus: registerMemoryFlushPlan failed: ${e instanceof Error ? e.message : e}`);
       }
     }
 
+    // 3b. registerCompactionProvider — Sulcus-native compaction summarization
+    if (isCloudBackend && sulcusMem && typeof (api.registerCompactionProvider as unknown) === "function") {
+      try {
+        const compactionSulcusMem = sulcusMem as SulcusCloudClient;
+        (api.registerCompactionProvider as (p: unknown) => void)({
+          id: "sulcus",
+          async summarize(params: {
+            messages: Record<string, unknown>[];
+            signal?: AbortSignal;
+            customInstructions?: string;
+            summarizationInstructions?: string;
+            previousSummary?: string;
+          }): Promise<string> {
+            const msgs = params.messages ?? [];
+            logger.info(`sulcus: compaction provider summarize() called with ${msgs.length} messages`);
+            try {
+              // 1. Extract substantive content from messages being compacted
+              const decisions: string[] = [];
+              const filesModified: string[] = [];
+              const toolsUsed: string[] = [];
+              const errorsHit: string[] = [];
+              const userIntents: string[] = [];
+              const assistantWork: string[] = [];
+
+              const DECISION_MARKERS = ["decided", "will use", "going to", "plan is", "the fix", "conclusion", "recommend", "approach"];
+
+              for (const msg of msgs) {
+                const role = (msg.role ?? msg.type) as string | undefined;
+                const text = typeof msg.content === "string" ? msg.content
+                  : typeof msg.text === "string" ? msg.text as string
+                  : Array.isArray(msg.content)
+                    ? (msg.content as Record<string, unknown>[]).filter((c) => c.type === "text").map((c) => c.text as string).join("\n")
+                    : "";
+                if (!text) continue;
+
+                if ((role === "user" || role === "human") && text.length > 10) {
+                  userIntents.push(text.substring(0, 200));
+                }
+                if ((role === "assistant" || role === "ai") && text.length > 50) {
+                  const lc = text.toLowerCase();
+                  if (DECISION_MARKERS.some((m) => lc.includes(m))) {
+                    const sentences = text.split(/[.!?\n]/).filter((s) => s.trim().length > 15);
+                    for (const s of sentences) {
+                      if (DECISION_MARKERS.some((m) => s.toLowerCase().includes(m))) {
+                        decisions.push(s.trim().substring(0, 300));
+                        if (decisions.length >= 8) break;
+                      }
+                    }
+                  }
+                  if (text.length > 100) {
+                    assistantWork.push(text.substring(0, 500));
+                  }
+                }
+
+                // Extract tool usage
+                const toolCalls = Array.isArray(msg.tool_calls) ? msg.tool_calls as Record<string, unknown>[] : [];
+                for (const tc of toolCalls) {
+                  const name = ((tc.name ?? tc.function) as string) ?? "";
+                  if (name && !toolsUsed.includes(name)) toolsUsed.push(name);
+                  if (/^(write|edit)$/i.test(name)) {
+                    const input = (tc.input ?? tc.arguments ?? {}) as Record<string, unknown>;
+                    const fp = (input?.file_path ?? input?.path) as string | undefined;
+                    if (fp && !filesModified.includes(fp)) filesModified.push(fp);
+                  }
+                }
+
+                // Track errors
+                if (role === "tool" && (msg.is_error === true || (typeof text === "string" && /error|failed|exception/i.test(text.substring(0, 100))))) {
+                  errorsHit.push(text.substring(0, 200));
+                }
+              }
+
+              // 2. Store key items as Sulcus memories via SIU classification
+              let stored = 0;
+              const itemsToStore: { text: string; suggestedType: string }[] = [];
+
+              for (const d of decisions.slice(0, 5)) {
+                itemsToStore.push({ text: d, suggestedType: "semantic" });
+              }
+              for (const u of userIntents.slice(0, 5)) {
+                if (u.length > 50 && /\b(prefer|always|never|don't|stop|use|switch|remember)\b/i.test(u)) {
+                  itemsToStore.push({ text: u, suggestedType: "preference" });
+                }
+              }
+              for (const a of assistantWork.slice(0, 3)) {
+                if (/\b(step \d|procedure|workflow|how to|instructions)\b/i.test(a)) {
+                  itemsToStore.push({ text: a, suggestedType: "procedural" });
+                } else {
+                  itemsToStore.push({ text: a, suggestedType: "semantic" });
+                }
+              }
+
+              for (const item of itemsToStore) {
+                if (isJunkMemory(item.text)) continue;
+                if (!shouldCapture(item.text)) continue;
+                try {
+                  let memType = item.suggestedType;
+                  try {
+                    const siuResult = await compactionSulcusMem.request(
+                      "POST", "/api/v2/siu/label", { text: item.text }
+                    ) as Record<string, unknown>;
+                    if (siuResult?.store === false && ((siuResult?.store_confidence as number) ?? 0) < 0.3) continue;
+                    if (siuResult?.memory_type) memType = siuResult.memory_type as string;
+                  } catch { /* SIU unavailable — use heuristic */ }
+                  const hints = buildExtractionHints(memType, namespace, "compaction_provider", item.text.substring(0, 200));
+                  await compactionSulcusMem.add_memory(item.text, memType, hints);
+                  stored++;
+                } catch { /* best-effort */ }
+              }
+              logger.info(`sulcus: compaction provider — stored ${stored} memories`);
+
+              // 3. Query Sulcus for relevant context (including freshly stored)
+              const topicQuery = userIntents.slice(0, 3).join(" ").substring(0, 500) || "session summary";
+              let relevantMemories: Record<string, unknown>[] = [];
+              try {
+                const searchRes = await compactionSulcusMem.search_memory(topicQuery, 15, namespace);
+                relevantMemories = searchRes?.results ?? [];
+              } catch (e) {
+                logger.warn(`sulcus: compaction provider — memory search failed: ${e}`);
+              }
+
+              // 4. Build structured summary
+              const sections: string[] = [];
+
+              if (params.previousSummary?.trim()) {
+                sections.push(`## Prior Context\n${params.previousSummary.trim()}`);
+              }
+
+              // Memory-backed context
+              const memLines: string[] = [];
+              const seenIds = new Set<string>();
+              for (const mem of relevantMemories) {
+                const id = mem.id as string;
+                if (seenIds.has(id)) continue;
+                seenIds.add(id);
+                const mtype = (mem.memory_type as string) ?? "unknown";
+                const label = ((mem.label ?? mem.pointer_summary ?? "") as string).trim();
+                if (!label || label.length < 20) continue;
+                memLines.push(`- [${mtype}] ${label.length > 400 ? label.substring(0, 400) + "..." : label}`);
+              }
+              if (memLines.length > 0) {
+                sections.push(`## Key Context (from Sulcus memory)\n${memLines.join("\n")}`);
+              }
+
+              // Decisions
+              if (decisions.length > 0) {
+                sections.push(`## Decisions Made\n${decisions.map((d) => "- " + d).join("\n")}`);
+              }
+
+              // Session activity
+              const activity: string[] = [`${msgs.length} messages in this session segment`];
+              if (filesModified.length > 0) activity.push(`Files modified: ${filesModified.join(", ")}`);
+              if (toolsUsed.length > 0) activity.push(`Tools used: ${toolsUsed.join(", ")}`);
+              if (errorsHit.length > 0) activity.push(`Errors: ${errorsHit.length}`);
+              sections.push(`## Session Activity\n${activity.join("\n")}`);
+
+              const summary = sections.join("\n\n");
+              if (!summary.trim()) throw new Error("Sulcus compaction produced empty summary");
+              logger.info(`sulcus: compaction provider produced summary (${summary.length} chars)`);
+              return summary;
+            } catch (err) {
+              logger.warn(`sulcus: compaction provider failed: ${err instanceof Error ? err.message : String(err)}`);
+              throw err; // Fall back to built-in LLM summarization
+            }
+          },
+        });
+        logger.info("sulcus: registered compaction provider \"sulcus\"");
+      } catch (e: unknown) {
+        logger.warn(`sulcus: registerCompactionProvider failed: ${e instanceof Error ? e.message : e}`);
+      }
+    }
+
     // 4. registerService — lifecycle management
     if (typeof (api.registerService as unknown) === "function") {
       try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digitalforgestudios/openclaw-sulcus",
-  "version": "6.6.2",
+  "version": "6.6.4",
   "description": "Sulcus \u2014 thermodynamic memory + Apache AGE knowledge graph for OpenClaw agents. v6.0: Multi-signal recall (semantic + hot-context + entity-graph + profile), configurable guardrails (outputGuard + toolGuard), token budget enforcement, context rebuild post-compaction, sulcus.toml config layer, SIRU training data logging, session-scoped memory, batch heat-boost. SIU v2 pipeline (SIVU/SICU/SILU/SITU/SIRU). Interaction-based decay. Curator sleep-cycle. Cross-agent sync.",
   "keywords": [
     "openclaw",
@@ -58,7 +58,7 @@
   },
   "main": "index.js",
   "scripts": {
-    "build": "npx esbuild index.ts --bundle --platform=node --target=node18 --outfile=index.js --external:openclaw --external:koffi --external:@sinclair/typebox --format=cjs",
+    "build": "npx esbuild index.ts --bundle --platform=node --target=node18 --outfile=index.js --external:openclaw --external:koffi --format=cjs",
     "prepublishOnly": "npm run build"
   }
 }