@byte5ai/palaia 2.3.5 → 2.5.1

package/src/hooks/capture.ts

@@ -144,7 +144,10 @@ function resolveExtensionAPIPath(): string | null {
 
   // Strategy 3: Sibling in global node_modules (plugin installed alongside openclaw)
   try {
-    const thisFile = typeof __dirname !== "undefined" ? __dirname : path.dirname(new URL(import.meta.url).pathname);
+    // __dirname is always available in CJS (our tsconfig module); the ESM
+    // fallback via import.meta.url is kept for jiti/ESM loaders at runtime.
+    // @ts-expect-error import.meta is valid at runtime under jiti/ESM but TS module=commonjs rejects it
+    const thisFile: string = typeof __dirname !== "undefined" ? __dirname : path.dirname(new URL(import.meta.url).pathname);
     // Walk up from plugin src/dist to node_modules, then into openclaw
     let dir = thisFile;
     for (let i = 0; i < 6; i++) {
@@ -469,11 +472,11 @@ export async function extractWithLLM(
   }
 
   const allTexts = extractMessageTexts(messages);
-  // Strip Palaia-injected recall context from user messages to prevent feedback loop
+  // Strip Palaia-injected recall context and private blocks from user messages
   const cleanedTexts = allTexts.map(t =>
     t.role === "user"
-      ? { ...t, text: stripPalaiaInjectedContext(t.text) }
-      : t
+      ? { ...t, text: stripPrivateBlocks(stripPalaiaInjectedContext(t.text)) }
+      : { ...t, text: stripPrivateBlocks(t.text) }
   );
   // Only extract from recent exchanges — full history causes LLM timeouts
   // and dilutes extraction quality
@@ -736,5 +739,19 @@ export function stripPalaiaInjectedContext(text: string): string {
   // Pattern: "## Active Memory (Palaia)" ... "[palaia] auto-capture=on..." + optional trailing newlines
   // The nudge line is always present and marks the end of the injected block
   const PALAIA_BLOCK_RE = /## Active Memory \(Palaia\)[\s\S]*?\[palaia\][^\n]*\n*/;
-  return text.replace(PALAIA_BLOCK_RE, '').trim();
+  // Also strip Session Briefing blocks
+  const BRIEFING_BLOCK_RE = /## Session Briefing \(Palaia\)[\s\S]*?(?=\n##|\n\n\n|$)/;
+  return text
+    .replace(PALAIA_BLOCK_RE, '')
+    .replace(BRIEFING_BLOCK_RE, '')
+    .trim();
+}
+
+/**
+ * Strip <private>...</private> blocks from text.
+ * Content inside private tags is excluded from memory capture.
+ * Inspired by claude-mem's privacy marker system.
+ */
+export function stripPrivateBlocks(text: string): string {
+  return text.replace(/<private>[\s\S]*?<\/private>/gi, '').trim();
 }

package/src/hooks/index.ts

@@ -119,6 +119,8 @@ import {
   extractMessageTexts,
   buildRecallQuery,
   rerankByTypeWeight,
+  formatEntryLine,
+  shouldUseCompactMode,
 } from "./recall.js";
 
 import {
@@ -151,6 +153,9 @@ import {
   filterBlocked,
 } from "../priorities.js";
 
+import { formatBriefing } from "./session.js";
+import { getOrCreateSessionState } from "./state.js";
+
 // ============================================================================
 // Logger (Issue: api.logger integration)
 // ============================================================================
@@ -190,6 +195,10 @@ export function registerHooks(api: OpenClawPluginApi, config: PalaiaPluginConfig
 
   const opts = buildRunnerOpts(config);
 
+  // Note: Session lifecycle hooks (session_start, session_end, before_reset,
+  // llm_input, llm_output, after_tool_call) are registered in index.ts entry
+  // point BEFORE this function, so they work for both ContextEngine and legacy paths.
+
   // ── Startup checks (H-2, H-3, captureModel validation) ────────
   (async () => {
     // H-2: Warn if no agent is configured
@@ -326,7 +335,7 @@ export function registerHooks(api: OpenClawPluginApi, config: PalaiaPluginConfig
     }
   });
 
-  // ── before_prompt_build (Issue #65: Query-based Recall) ────────
+  // ── before_prompt_build (Issue #65: Query-based Recall + v3.0 Session Briefing) ──
   if (config.memoryInject) {
     api.on("before_prompt_build", async (event: any, ctx: any) => {
       // Prune stale entries to prevent memory leaks from crashed sessions (C-2)
@@ -337,6 +346,34 @@ export function registerHooks(api: OpenClawPluginApi, config: PalaiaPluginConfig
       const hookOpts = buildRunnerOpts(config, { workspace: resolved.workspace });
 
       try {
+        // ── Session Briefing Injection (v3.0) ─────────────────────
+        // If a session briefing is pending (from session_start or model switch),
+        // prepend it to the recall context for seamless session continuity.
+        let briefingText = "";
+        let briefingSummary: string | null = null; // Kept for smart query fallback
+        const sessionKey = resolveSessionKeyFromCtx(ctx);
+        if (sessionKey) {
+          const sessState = getOrCreateSessionState(sessionKey);
+          // Wait for session_start briefing load (max 3s to avoid blocking)
+          if (sessState.briefingReady) {
+            await Promise.race([
+              sessState.briefingReady,
+              new Promise<void>(r => setTimeout(r, 3000)),
+            ]);
+          }
+          // Capture summary BEFORE clearing, for smart query fallback below
+          briefingSummary = sessState.pendingBriefing?.summary ?? null;
+          if (sessState.pendingBriefing && !sessState.briefingDelivered) {
+            briefingText = formatBriefing(sessState.pendingBriefing, config.sessionBriefingMaxChars);
+            sessState.briefingDelivered = true;
+            // Clear pending briefing after delivery (unless model switch re-triggers)
+            if (!sessState.modelSwitchDetected) {
+              sessState.pendingBriefing = null;
+            }
+            sessState.modelSwitchDetected = false;
+          }
+        }
+
         // Load and resolve priorities (Issue #121)
         const prio = await loadPriorities(resolved.workspace);
         const project = config.captureProject || undefined;
@@ -347,15 +384,25 @@ export function registerHooks(api: OpenClawPluginApi, config: PalaiaPluginConfig
           tier: config.tier,
         }, resolved.agentId, project);
 
-        const maxChars = resolvedPrio.maxInjectedChars || 4000;
+        // Reduce recall budget by briefing size
+        const maxChars = Math.max((resolvedPrio.maxInjectedChars || 4000) - briefingText.length, 500);
         const limit = Math.min(config.maxResults || 10, 20);
         let entries: QueryResult["results"] = [];
 
         if (config.recallMode === "query") {
-          const userMessage = event.messages
+          let userMessage = event.messages
             ? buildRecallQuery(event.messages)
             : (event.prompt || null);
 
+          // ── Smart Query Fallback (v3.0) ───────────────────────
+          // If query is too short or matches a continuation pattern,
+          // use the session summary as query for better recall results.
+          const CONTINUATION_PATTERN = /^(ja|ok|weiter|mach|genau|do it|yes|continue|go|proceed|sure|klar|passt|yep|yup|exactly|right)\b/i;
+          if (briefingSummary && userMessage && (userMessage.length < 10 || CONTINUATION_PATTERN.test(userMessage.trim()))) {
+            userMessage = briefingSummary.slice(0, 500);
+            logger.info("[palaia] Smart query fallback: using session summary as recall query");
+          }
+
           if (userMessage && userMessage.length >= 5) {
             // Try embed server first (fast path: ~0.5s), then CLI fallback (~3-14s)
             let serverQueried = false;
@@ -372,6 +419,7 @@ export function registerHooks(api: OpenClawPluginApi, config: PalaiaPluginConfig
                     text: userMessage,
                     top_k: limit,
                     include_cold: resolvedPrio.tier === "all",
+                    ...(resolvedPrio.scopeVisibility ? { scope_visibility: resolvedPrio.scopeVisibility } : {}),
                   }, config.timeoutMs || 3000);
                   if (resp?.result?.results && Array.isArray(resp.result.results)) {
                     entries = resp.result.results;
@@ -417,36 +465,37 @@ export function registerHooks(api: OpenClawPluginApi, config: PalaiaPluginConfig
               entries = result.results;
             }
           } catch {
+            // Still deliver briefing even if recall fails completely
+            if (briefingText) {
+              return { prependContext: briefingText };
+            }
             return;
           }
         }
 
-        if (entries.length === 0) return;
+        // If no recall entries but briefing exists, deliver briefing alone
+        if (entries.length === 0) {
+          if (briefingText) {
+            return { prependContext: briefingText };
+          }
+          return;
+        }
 
         // Apply type-weighted reranking and blocked filtering (Issue #121)
-        const rankedRaw = rerankByTypeWeight(entries, resolvedPrio.recallTypeWeight);
+        const rankedRaw = rerankByTypeWeight(entries, resolvedPrio.recallTypeWeight, config.recallRecencyBoost);
         const ranked = filterBlocked(rankedRaw, resolvedPrio.blocked);
 
-        // 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" };
-
+        // Build context string with char budget
+        // Progressive disclosure: compact mode for large stores (title + first line + ID)
+        const compact = shouldUseCompactMode(ranked.length);
         let text = "## Active Memory (Palaia)\n\n";
+        if (compact) {
+          text += "_Compact mode — use `memory_get <id>` for full details._\n\n";
+        }
         let chars = text.length;
 
         for (const entry of ranked) {
-          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`;
-          }
-
+          const line = formatEntryLine(entry, compact);
           if (chars + line.length > maxChars) break;
           text += line;
           chars += line.length;
@@ -483,7 +532,6 @@ export function registerHooks(api: OpenClawPluginApi, config: PalaiaPluginConfig
         const hasRelevantRecall = !isListFallback && entries.some(
           (e) => typeof e.score === "number" && e.score >= resolvedPrio.recallMinScore,
         );
-        const sessionKey = resolveSessionKeyFromCtx(ctx);
         if (sessionKey && hasRelevantRecall) {
           const turnState = getOrCreateTurnState(sessionKey);
           turnState.recallOccurred = true;
@@ -506,7 +554,7 @@ export function registerHooks(api: OpenClawPluginApi, config: PalaiaPluginConfig
 
         // Return prependContext + appendSystemContext for recall emoji
         return {
-          prependContext: text + nudgeContext,
+          prependContext: briefingText + text,
           appendSystemContext: config.showMemorySources
             ? "You used Palaia memory in this turn. Add \u{1f9e0} at the very end of your response (after everything else, on its own line)."
             : undefined,
@@ -559,14 +607,17 @@ export function registerHooks(api: OpenClawPluginApi, config: PalaiaPluginConfig
           collectedHints.push(...hints);
         }
 
-        // Strip Palaia-injected recall context from user messages to prevent feedback loop.
+        // Strip Palaia-injected recall context and private blocks from messages.
         // The recall block is prepended to user messages by before_prompt_build.
         // Without stripping, auto-capture would re-capture previously recalled memories.
-        const cleanedTexts = allTexts.map(t =>
-          t.role === "user"
-            ? { ...t, text: stripPalaiaInjectedContext(t.text) }
-            : t
-        );
+        // Private blocks (<private>...</private>) must be excluded from capture.
+        const { stripPrivateBlocks } = await import("./capture.js");
+        const cleanedTexts = allTexts.map(t => ({
+          ...t,
+          text: stripPrivateBlocks(
+            t.role === "user" ? stripPalaiaInjectedContext(t.text) : t.text
+          ),
+        }));
 
         // Only extract from recent exchanges — full history causes LLM timeouts
         // and dilutes extraction quality
@@ -586,6 +637,23 @@ export function registerHooks(api: OpenClawPluginApi, config: PalaiaPluginConfig
 
         const knownProjects = await loadProjects(hookOpts);
 
+        // Resolve effective capture scope from priorities (per-agent override, #147)
+        let effectiveCaptureScope = config.captureScope || "";
+        try {
+          const prio = await loadPriorities(resolved.workspace);
+          const resolvedCapturePrio = resolvePriorities(prio, {
+            recallTypeWeight: config.recallTypeWeight,
+            recallMinScore: config.recallMinScore,
+            maxInjectedChars: config.maxInjectedChars,
+            tier: config.tier,
+          }, agentName);
+          if (resolvedCapturePrio.captureScope) {
+            effectiveCaptureScope = resolvedCapturePrio.captureScope;
+          }
+        } catch {
+          // Fall through to config default
+        }
+
         // Helper: build CLI args with metadata
         const buildWriteArgs = (
           content: string,
@@ -601,9 +669,9 @@ export function registerHooks(api: OpenClawPluginApi, config: PalaiaPluginConfig
             "--tags", tags.join(",") || "auto-capture",
           ];
 
-          // Scope guardrail: config.captureScope overrides everything; otherwise max team (no public)
-          const scope = config.captureScope
-            ? sanitizeScope(config.captureScope, "team", true)
+          // Scope guardrail: priorities captureScope > config.captureScope > hint/LLM scope
+          const scope = effectiveCaptureScope
+            ? sanitizeScope(effectiveCaptureScope, "team", true)
             : sanitizeScope(itemScope, "team", false);
           args.push("--scope", scope);
 
@@ -821,7 +889,7 @@ export function registerHooks(api: OpenClawPluginApi, config: PalaiaPluginConfig
   // ── Startup Recovery Service ───────────────────────────────────
   api.registerService({
     id: "palaia-recovery",
-    start: async () => {
+    start: async (_ctx) => {
       const result = await recover(opts);
       if (result.replayed > 0) {
         logger.info(`[palaia] WAL recovery: replayed ${result.replayed} entries`);

package/src/hooks/recall.ts

@@ -26,6 +26,7 @@ export interface QueryResult {
     title?: string;
     type?: string;
     tags?: string[];
+    created?: string;
   }>;
 }
 
@@ -342,16 +343,36 @@ export interface RankedEntry {
   bm25Score?: number;
   embedScore?: number;
   weightedScore: number;
+  created?: string;
+  tags?: string[];
+}
+
+/**
+ * Calculate recency boost factor.
+ * Returns a multiplier: 1.0 (no boost) to 1.0 + boostFactor (max boost for very recent).
+ * Formula: 1 + boostFactor * exp(-hoursAgo / 24)
+ */
+function calcRecencyBoost(created: string | undefined, boostFactor: number): number {
+  if (!boostFactor || !created) return 1.0;
+  try {
+    const hoursAgo = (Date.now() - new Date(created).getTime()) / (1000 * 60 * 60);
+    if (hoursAgo < 0 || isNaN(hoursAgo)) return 1.0;
+    return 1.0 + boostFactor * Math.exp(-hoursAgo / 24);
+  } catch {
+    return 1.0;
+  }
 }
 
 export function rerankByTypeWeight(
   results: QueryResult["results"],
-  weights: RecallTypeWeights,
+  weights: Record<string, number>,
+  recencyBoost = 0,
 ): RankedEntry[] {
   return results
     .map((r) => {
       const type = r.type || "memory";
       const weight = weights[type] ?? 1.0;
+      const recency = calcRecencyBoost(r.created, recencyBoost);
       return {
         id: r.id,
         body: r.content || r.body || "",
@@ -362,8 +383,50 @@ export function rerankByTypeWeight(
         score: r.score,
         bm25Score: r.bm25_score,
         embedScore: r.embed_score,
-        weightedScore: r.score * weight,
+        weightedScore: r.score * weight * recency,
+        created: r.created,
+        tags: r.tags,
       };
     })
     .sort((a, b) => b.weightedScore - a.weightedScore);
 }
+
+// ── Context Formatting ──────────────────────────────────────────────────
+
+const SCOPE_SHORT: Record<string, string> = { team: "t", private: "p", public: "pub" };
+const TYPE_SHORT: Record<string, string> = { memory: "m", process: "pr", task: "tk" };
+
+/**
+ * Format a ranked entry as an injectable context line.
+ *
+ * In compact mode (progressive disclosure), only title + first line + ID are shown.
+ * The agent can use `memory_get <id>` for the full entry.
+ */
+export function formatEntryLine(entry: RankedEntry, compact: boolean): string {
+  const scopeKey = SCOPE_SHORT[entry.scope] || entry.scope;
+  const typeKey = TYPE_SHORT[entry.type] || entry.type;
+  const prefix = `[${scopeKey}/${typeKey}]`;
+
+  if (compact) {
+    // Compact: title + first line of body + ID reference
+    const firstLine = entry.body.split("\n")[0]?.slice(0, 120) || "";
+    const titlePart = entry.body.toLowerCase().startsWith(entry.title.toLowerCase())
+      ? firstLine
+      : `${entry.title} — ${firstLine}`;
+    return `${prefix} ${titlePart} [id:${entry.id}]\n`;
+  }
+
+  // Full: title + complete body
+  if (entry.body.toLowerCase().startsWith(entry.title.toLowerCase())) {
+    return `${prefix} ${entry.body}\n\n`;
+  }
+  return `${prefix} ${entry.title}\n${entry.body}\n\n`;
+}
+
+/**
+ * Determine if compact mode should be used based on result count.
+ * Above threshold, use compact mode to fit more entries in budget.
+ */
+export function shouldUseCompactMode(totalResults: number, threshold = 100): boolean {
+  return totalResults > threshold;
+}