@byte5ai/palaia 2.0.2 → 2.0.4

package/openclaw.plugin.json

@@ -33,7 +33,7 @@
       },
       "maxInjectedChars": {
         "type": "number",
-        "default": 8000,
+        "default": 4000,
         "description": "Max characters for injected memory context"
       },
       "autoCapture": {
@@ -86,6 +86,11 @@
         "default": "query",
         "description": "Recall mode: list (context-independent) or query (context-relevant)"
       },
+      "recallMinScore": {
+        "type": "number",
+        "default": 0.7,
+        "description": "Minimum score for a recall result to be considered relevant (default: 0.7)"
+      },
       "recallTypeWeight": {
         "type": "object",
         "default": { "process": 1.5, "task": 1.2, "memory": 1.0 },
@@ -113,7 +118,7 @@
     },
     "maxInjectedChars": {
       "label": "Max Injected Characters",
-      "description": "Maximum characters of memory context injected per prompt (recommended: 8000)"
+      "description": "Maximum characters of memory context injected per prompt (recommended: 4000)"
     },
     "autoCapture": {
       "label": "Auto-Capture",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byte5ai/palaia",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "description": "Palaia memory backend for OpenClaw",
   "main": "index.ts",
   "openclaw": {

package/src/config.ts

@@ -54,6 +54,10 @@ export interface PalaiaPluginConfig {
   recallMode: "list" | "query";
   /** Type-aware weighting for recall results */
   recallTypeWeight: RecallTypeWeights;
+
+  // ── Recall Quality (Issue #65) ───────────────────────────────
+  /** Minimum score for a recall result to be considered relevant (default: 0.7) */
+  recallMinScore: number;
 }
 
 export const DEFAULT_RECALL_TYPE_WEIGHTS: RecallTypeWeights = {
@@ -67,15 +71,16 @@ export const DEFAULT_CONFIG: PalaiaPluginConfig = {
   maxResults: 10,
   timeoutMs: 3000,
   memoryInject: true,
-  maxInjectedChars: 8000,
+  maxInjectedChars: 4000,
   autoCapture: true,
   captureFrequency: "significant",
   captureMinTurns: 2,
-  captureMinSignificance: 0.3,
+  captureMinSignificance: 0.5,
   showMemorySources: true,
   showCaptureConfirm: true,
   recallMode: "query",
   recallTypeWeight: { ...DEFAULT_RECALL_TYPE_WEIGHTS },
+  recallMinScore: 0.7,
 };
 
 /**

package/src/hooks.ts

@@ -153,10 +153,13 @@ export function isValidScope(s: string): boolean {
 
 /**
  * Sanitize a scope value — returns the value if valid, otherwise fallback.
+ * Enforces: LLM may suggest private or team, but NEVER public (unless explicitly configured).
  */
-export function sanitizeScope(rawScope: string | null | undefined, fallback = "team"): string {
-  if (rawScope && isValidScope(rawScope)) return rawScope;
-  return fallback;
+export function sanitizeScope(rawScope: string | null | undefined, fallback = "team", allowPublic = false): string {
+  if (!rawScope || !isValidScope(rawScope)) return fallback;
+  // Block public scope unless explicitly allowed (config-level override)
+  if (rawScope === "public" && !allowPublic) return fallback;
+  return rawScope;
 }
 
 // ============================================================================
@@ -721,6 +724,7 @@ For each piece of knowledge, return a JSON array of objects:
 - "scope": "private" (personal preference, agent-specific), "team" (shared knowledge), or "public" (documentation)
 
 Only extract genuinely significant knowledge. Skip small talk, acknowledgments, routine exchanges.
+Do NOT extract if similar knowledge was likely captured in a recent exchange. Prefer quality over quantity. Skip routine status updates and acknowledgments.
 Return empty array [] if nothing is worth remembering.
 Return ONLY valid JSON, no markdown fences.`;
 
@@ -1052,6 +1056,10 @@ export function extractSignificance(
 
   if (matched.length === 0) return null;
 
+  // Require at least 2 different significance tags for rule-based capture
+  const uniqueTags = new Set(matched.map((m) => m.tag));
+  if (uniqueTags.size < 2) return null;
+
   const typePriority: Record<string, number> = { task: 3, process: 2, memory: 1 };
   const primaryType = matched.reduce(
     (best, m) => (typePriority[m.type] > typePriority[best] ? m.type : best),
@@ -1119,6 +1127,83 @@ export function getLastUserMessage(messages: unknown[]): string | null {
   return null;
 }
 
+// ============================================================================
+// Recall Query Builder (Issue #65 upgrade: robust user message extraction)
+// ============================================================================
+
+/** Day-of-week prefixes used as system markers in messages. */
+const DAY_PREFIXES = ["[Mon ", "[Tue ", "[Wed ", "[Thu ", "[Fri ", "[Sat ", "[Sun "];
+
+/**
+ * Clean a raw message string by removing system markers, JSON blocks,
+ * and other noise that degrades semantic search quality.
+ */
+export function cleanMessageForQuery(text: string): string {
+  let cleaned = text;
+
+  // Remove JSON code blocks (```json ... ```)
+  cleaned = cleaned.replace(/```json[\s\S]*?```/gi, "");
+
+  // Remove lines starting with system markers
+  cleaned = cleaned
+    .split("\n")
+    .filter((line) => {
+      const trimmed = line.trimStart();
+      if (trimmed.startsWith("System:")) return false;
+      if (trimmed.startsWith("[Queued")) return false;
+      if (trimmed.startsWith("[Inter-session")) return false;
+      for (const prefix of DAY_PREFIXES) {
+        if (trimmed.startsWith(prefix)) return false;
+      }
+      return true;
+    })
+    .join("\n")
+    .trim();
+
+  return cleaned;
+}
+
+/**
+ * Build a recall query from message history.
+ *
+ * - Always uses actual user messages (ignores event.prompt which may be stale/synthetic).
+ * - If the last user message is short (< 30 chars), prepends the previous user message
+ *   for better semantic context ("Ja", "OK", "Status" alone are poor queries).
+ * - Strips system markers, JSON blocks, and other noise.
+ * - Hard-caps at 500 characters.
+ *
+ * Returns empty string if nothing usable remains.
+ */
+export function buildRecallQuery(messages: unknown[]): string {
+  const texts = extractMessageTexts(messages);
+  const userMessages: string[] = [];
+  for (let i = texts.length - 1; i >= 0 && userMessages.length < 2; i--) {
+    if (texts[i].role === "user") {
+      const cleaned = cleanMessageForQuery(texts[i].text);
+      if (cleaned) userMessages.unshift(cleaned);
+    }
+  }
+
+  if (userMessages.length === 0) return "";
+
+  const lastMsg = userMessages[userMessages.length - 1];
+
+  // If the last user message is very short, include previous for context
+  let query: string;
+  if (lastMsg.length < 30 && userMessages.length > 1) {
+    query = `${userMessages[userMessages.length - 2]} ${lastMsg}`;
+  } else {
+    query = lastMsg;
+  }
+
+  // Hard cap at 500 characters
+  if (query.length > 500) {
+    query = query.slice(0, 500);
+  }
+
+  return query.trim();
+}
+
 // ============================================================================
 // Query-based Recall: Type-weighted reranking (Issue #65)
 // ============================================================================
@@ -1345,8 +1430,9 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
         let entries: QueryResult["results"] = [];
 
         if (config.recallMode === "query") {
-          const userMessage = event.prompt
-            || (event.messages ? getLastUserMessage(event.messages) : null);
+          const userMessage = event.messages
+            ? buildRecallQuery(event.messages)
+            : (event.prompt || null);
 
           if (userMessage && userMessage.length >= 5) {
             try {
@@ -1364,8 +1450,10 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
           }
         }
 
-        // Fallback: list mode
+        // Fallback: list mode (no emoji — list-based recall is not query-relevant)
+        let isListFallback = false;
         if (entries.length === 0) {
+          isListFallback = true;
           try {
             const listArgs: string[] = ["list"];
             if (config.tier === "all") {
@@ -1387,17 +1475,35 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
         // Apply type-weighted reranking
         const ranked = rerankByTypeWeight(entries, config.recallTypeWeight);
 
-        // Build context string with char budget
+        // Build context string with char budget (compact format for token efficiency)
+        const SCOPE_SHORT: Record<string, string> = { team: "t", private: "p", public: "pub" };
+        const TYPE_SHORT: Record<string, string> = { memory: "m", process: "pr", task: "tk" };
+
         let text = "## Active Memory (Palaia)\n\n";
         let chars = text.length;
 
         for (const entry of ranked) {
-          const line = `**${entry.title}** [${entry.scope}/${entry.type}]\n${entry.body}\n\n`;
+          const scopeKey = SCOPE_SHORT[entry.scope] || entry.scope;
+          const typeKey = TYPE_SHORT[entry.type] || entry.type;
+          const prefix = `[${scopeKey}/${typeKey}]`;
+
+          // If body starts with title (common), skip title to save tokens
+          let line: string;
+          if (entry.body.toLowerCase().startsWith(entry.title.toLowerCase())) {
+            line = `${prefix} ${entry.body}\n\n`;
+          } else {
+            line = `${prefix} ${entry.title}\n${entry.body}\n\n`;
+          }
+
           if (chars + line.length > maxChars) break;
           text += line;
           chars += line.length;
         }
 
+        // Persistent usage nudge — compact guidance for the agent
+        const USAGE_NUDGE = "[palaia] auto-capture=on. Manual write: --type process (SOPs/checklists) or --type task (todos with assignee/deadline) only. Conversation knowledge is auto-captured — do not duplicate with manual writes.";
+        text += USAGE_NUDGE + "\n\n";
+
         // Update recall counter for satisfaction/transparency nudges (Issue #87)
         let nudgeContext = "";
         try {
@@ -1416,8 +1522,13 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
         }
 
         // Track recall in session-isolated turn state for emoji reactions
+        // Only flag recall as meaningful if at least one result scores above threshold
+        // List-fallback never triggers brain emoji (not query-relevant)
+        const hasRelevantRecall = !isListFallback && entries.some(
+          (e) => typeof e.score === "number" && e.score >= config.recallMinScore,
+        );
         const sessionKey = resolveSessionKeyFromCtx(ctx);
-        if (sessionKey) {
+        if (sessionKey && hasRelevantRecall) {
           const turnState = getOrCreateTurnState(sessionKey);
           turnState.recallOccurred = true;
 
@@ -1523,7 +1634,10 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
             "--tags", tags.join(",") || "auto-capture",
           ];
 
-          const scope = sanitizeScope(config.captureScope || itemScope, config.captureScope || "team");
+          // Scope guardrail: config.captureScope overrides everything; otherwise max team (no public)
+          const scope = config.captureScope
+            ? sanitizeScope(config.captureScope, "team", true)
+            : sanitizeScope(itemScope, "team", false);
           args.push("--scope", scope);
 
           const project = config.captureProject || itemProject;
@@ -1548,16 +1662,32 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
               const effectiveProject = hintForProject?.project || r.project;
               const effectiveScope = hintForScope?.scope || r.scope;
 
+              // Project validation: reject unknown projects
+              let validatedProject = effectiveProject;
+              if (validatedProject && knownProjects.length > 0) {
+                const isKnown = knownProjects.some(
+                  (p) => p.name.toLowerCase() === validatedProject!.toLowerCase(),
+                );
+                if (!isKnown) {
+                  console.log(`[palaia] Auto-capture: unknown project "${validatedProject}" ignored`);
+                  validatedProject = null;
+                }
+              }
+
+              // Always include auto-capture tag for GC identification
+              const tags = [...r.tags];
+              if (!tags.includes("auto-capture")) tags.push("auto-capture");
+
               const args = buildWriteArgs(
                 r.content,
                 r.type,
-                r.tags,
-                effectiveProject,
+                tags,
+                validatedProject,
                 effectiveScope,
               );
               await run(args, { ...opts, timeoutMs: 10_000 });
               console.log(
-                `[palaia] LLM auto-captured: type=${r.type}, significance=${r.significance}, tags=${r.tags.join(",")}, project=${effectiveProject || "none"}, scope=${effectiveScope || "team"}`
+                `[palaia] LLM auto-captured: type=${r.type}, significance=${r.significance}, tags=${tags.join(",")}, project=${validatedProject || "none"}, scope=${effectiveScope || "team"}`
               );
             }
           }
@@ -1604,7 +1734,7 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
           }
         }
 
-        // Rule-based fallback
+        // Rule-based fallback (max 1 per turn)
         if (!llmHandled) {
           let captureData: { tags: string[]; type: string; summary: string } | null = null;
 
@@ -1623,6 +1753,11 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
             captureData = { tags: ["auto-capture"], type: "memory", summary };
           }
 
+          // Always include auto-capture tag for GC identification
+          if (!captureData.tags.includes("auto-capture")) {
+            captureData.tags.push("auto-capture");
+          }
+
           const hintForProject = collectedHints.find((h) => h.project);
           const hintForScope = collectedHints.find((h) => h.scope);
 

package/src/tools.ts

@@ -7,7 +7,7 @@
  */
 
 import { Type } from "@sinclair/typebox";
-import { runJson, type RunnerOpts } from "./runner.js";
+import { run, runJson, type RunnerOpts } from "./runner.js";
 import type { PalaiaPluginConfig } from "./config.js";
 import { sanitizeScope, isValidScope } from "./hooks.js";
 
@@ -217,6 +217,12 @@ export function registerTools(api: any, config: PalaiaPluginConfig): void {
             description: "Title for the entry",
           })
         ),
+        force: Type.Optional(
+          Type.Boolean({
+            description: "Skip duplicate check and write anyway",
+            default: false,
+          })
+        ),
       }),
       async execute(
         _id: string,
@@ -227,8 +233,47 @@ export function registerTools(api: any, config: PalaiaPluginConfig): void {
           type?: string;
           project?: string;
           title?: string;
+          force?: boolean;
         }
       ) {
+        // Duplicate guard: check for similar recent entries before writing
+        if (!params.force) {
+          try {
+            const dupCheckResult = await runJson<QueryResult>(
+              ["query", params.content, "--limit", "5"],
+              { ...opts, timeoutMs: 2000 },
+            );
+            if (dupCheckResult && Array.isArray(dupCheckResult.results)) {
+              const now = Date.now();
+              const oneDayMs = 24 * 60 * 60 * 1000;
+              for (const r of dupCheckResult.results) {
+                if (r.score > 0.8) {
+                  // Check if created in last 24h — use any available date field
+                  const meta = r as any;
+                  const createdStr = meta.created_at || meta.createdAt || meta.date || "";
+                  if (createdStr) {
+                    const createdTime = new Date(createdStr).getTime();
+                    if (!isNaN(createdTime) && (now - createdTime) < oneDayMs) {
+                      const title = r.title || (r.content || r.body || "").slice(0, 60);
+                      const dateStr = new Date(createdTime).toISOString().split("T")[0];
+                      return {
+                        content: [
+                          {
+                            type: "text" as const,
+                            text: `Similar entry already exists (score: ${r.score.toFixed(2)}, created: ${dateStr}): '${title}'. Use palaia edit ${r.id} to update, or confirm with --force to write anyway.`,
+                          },
+                        ],
+                      };
+                    }
+                  }
+                }
+              }
+            }
+          } catch {
+            // Duplicate check timed out or failed — proceed with write
+          }
+        }
+
         const args: string[] = ["write", params.content];
         if (params.scope) {
           if (!isValidScope(params.scope)) {