@byte5ai/palaia 2.0.12 → 2.1.0

package/package.json

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

package/src/hooks.ts

@@ -293,10 +293,14 @@ export async function sendReaction(
 
 /** Cached Slack bot token resolved from env or OpenClaw config. */
 let _cachedSlackToken: string | null | undefined;
+/** Timestamp when the token was cached (for TTL expiry). */
+let _slackTokenCachedAt = 0;
+/** TTL for cached Slack bot token in milliseconds (5 minutes). */
+const SLACK_TOKEN_CACHE_TTL_MS = 5 * 60 * 1000;
 
 /**
  * Resolve the Slack bot token from environment or OpenClaw config file.
- * Caches the result for the lifetime of the process.
+ * Caches the result with a 5-minute TTL — re-resolves after expiry.
  *
  * Resolution order:
  * 1. SLACK_BOT_TOKEN env var (explicit override)
@@ -306,12 +310,15 @@ let _cachedSlackToken: string | null | undefined;
  * Config path: OPENCLAW_CONFIG env var → ~/.openclaw/openclaw.json
  */
 async function resolveSlackBotToken(): Promise<string | null> {
-  if (_cachedSlackToken !== undefined) return _cachedSlackToken;
+  if (_cachedSlackToken !== undefined && (Date.now() - _slackTokenCachedAt) < SLACK_TOKEN_CACHE_TTL_MS) {
+    return _cachedSlackToken;
+  }
 
   // 1) Environment variable
   const envToken = process.env.SLACK_BOT_TOKEN?.trim();
   if (envToken) {
     _cachedSlackToken = envToken;
+    _slackTokenCachedAt = Date.now();
     return envToken;
   }
 
@@ -330,6 +337,7 @@ async function resolveSlackBotToken(): Promise<string | null> {
       const directToken = config?.channels?.slack?.botToken?.trim();
       if (directToken) {
         _cachedSlackToken = directToken;
+        _slackTokenCachedAt = Date.now();
         return directToken;
       }
 
@@ -337,6 +345,7 @@ async function resolveSlackBotToken(): Promise<string | null> {
       const accountToken = config?.channels?.slack?.accounts?.default?.botToken?.trim();
       if (accountToken) {
         _cachedSlackToken = accountToken;
+        _slackTokenCachedAt = Date.now();
         return accountToken;
       }
     } catch {
@@ -345,12 +354,14 @@ async function resolveSlackBotToken(): Promise<string | null> {
   }
 
   _cachedSlackToken = null;
+  _slackTokenCachedAt = Date.now();
   return null;
 }
 
 /** Reset cached token (for testing). */
 export function resetSlackTokenCache(): void {
   _cachedSlackToken = undefined;
+  _slackTokenCachedAt = 0;
 }
 
 async function sendSlackReaction(
@@ -733,6 +744,13 @@ For each piece of knowledge, return a JSON array of objects:
 - "project": which project this belongs to (from known projects list, or null if unclear)
 - "scope": "private" (personal preference, agent-specific), "team" (shared knowledge), or "public" (documentation)
 
+STRICT TASK CLASSIFICATION RULES — a "task" MUST have ALL three of:
+1. A clear, completable action (not just an observation or idea)
+2. An identifiable responsible party (explicitly named or unambiguously inferable from context)
+3. A concrete deliverable or measurable end state
+If ANY of these is missing, classify as "memory" instead of "task". When in doubt, use "memory".
+Observations, learnings, insights, opinions, and general knowledge are ALWAYS "memory", never "task".
+
 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.
@@ -892,9 +910,15 @@ export async function extractWithLLM(
   }
 
   const allTexts = extractMessageTexts(messages);
+  // Strip Palaia-injected recall context from user messages to prevent feedback loop
+  const cleanedTexts = allTexts.map(t =>
+    t.role === "user"
+      ? { ...t, text: stripPalaiaInjectedContext(t.text) }
+      : t
+  );
   // Only extract from recent exchanges — full history causes LLM timeouts
   // and dilutes extraction quality
-  const recentTexts = trimToRecentExchanges(allTexts);
+  const recentTexts = trimToRecentExchanges(cleanedTexts);
   const exchangeText = recentTexts
     .map((t) => `[${t.role}]: ${t.text}`)
     .join("\n");
@@ -908,7 +932,25 @@ export async function extractWithLLM(
 
   let tmpDir: string | null = null;
   try {
-    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "palaia-extract-"));
+    // Use a fixed base directory for extraction temp dirs and clean up stale ones
+    const extractBaseDir = path.join(os.tmpdir(), "palaia-extractions");
+    await fs.mkdir(extractBaseDir, { recursive: true });
+    // Clean up stale extraction dirs (older than 5 minutes)
+    try {
+      const entries = await fs.readdir(extractBaseDir, { withFileTypes: true });
+      const now = Date.now();
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          try {
+            const stat = await fs.stat(path.join(extractBaseDir, entry.name));
+            if (now - stat.mtimeMs > 5 * 60 * 1000) {
+              await fs.rm(path.join(extractBaseDir, entry.name), { recursive: true, force: true });
+            }
+          } catch { /* ignore individual cleanup errors */ }
+        }
+      }
+    } catch { /* ignore cleanup errors */ }
+    tmpDir = await fs.mkdtemp(path.join(extractBaseDir, "ext-"));
     const sessionId = `palaia-extract-${Date.now()}`;
     const sessionFile = path.join(tmpDir, "session.json");
 
@@ -1103,6 +1145,24 @@ export function extractSignificance(
   return { tags, type: primaryType, summary };
 }
 
+/**
+ * Strip Palaia-injected recall context from message text.
+ * The recall block is prepended to user messages by before_prompt_build via prependContext.
+ * OpenClaw merges it into the user message, so agent_end sees it as user content.
+ * Without stripping, auto-capture re-captures the injected memories → feedback loop.
+ *
+ * The block has a stable structure:
+ * - Starts with "## Active Memory (Palaia)"
+ * - Contains [t/m], [t/pr], [t/tk] prefixed entries
+ * - Ends with "[palaia] auto-capture=on..." nudge line
+ */
+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();
+}
+
 export function extractMessageTexts(messages: unknown[]): Array<{ role: string; text: string; provenance?: string }> {
   const result: Array<{ role: string; text: string; provenance?: string }> = [];
 
@@ -1232,7 +1292,11 @@ function isSystemOnlyContent(text: string): boolean {
  * - Hard-caps at 500 characters.
  */
 export function buildRecallQuery(messages: unknown[]): string {
-  const texts = extractMessageTexts(messages);
+  const texts = extractMessageTexts(messages).map(t =>
+    t.role === "user"
+      ? { ...t, text: stripPalaiaInjectedContext(t.text) }
+      : t
+  );
 
   // Step 1: Filter out inter_session messages (sub-agent results, sessions_send)
   const candidates = texts.filter(
@@ -1240,11 +1304,29 @@ export function buildRecallQuery(messages: unknown[]): string {
   );
 
   // Fallback: if no messages without provenance, use all user messages
-  const userMsgs = candidates.length > 0
+  const allUserMsgs = candidates.length > 0
     ? candidates
     : texts.filter(t => t.role === "user");
 
-  if (userMsgs.length === 0) return "";
+  if (allUserMsgs.length === 0) return "";
+
+  // Early exit: only scan the last 3 user messages or 2000 chars, whichever comes first
+  const MAX_SCAN_MSGS = 3;
+  const MAX_SCAN_CHARS = 2000;
+  let userMsgs: typeof allUserMsgs;
+  if (allUserMsgs.length <= MAX_SCAN_MSGS) {
+    userMsgs = allUserMsgs;
+  } else {
+    userMsgs = allUserMsgs.slice(-MAX_SCAN_MSGS);
+    // Extend backwards if total chars < MAX_SCAN_CHARS and more messages available
+    let totalChars = userMsgs.reduce((sum, m) => sum + m.text.length, 0);
+    let startIdx = allUserMsgs.length - MAX_SCAN_MSGS;
+    while (startIdx > 0 && totalChars < MAX_SCAN_CHARS) {
+      startIdx--;
+      totalChars += allUserMsgs[startIdx].text.length;
+      userMsgs = allUserMsgs.slice(startIdx);
+    }
+  }
 
   // Step 2: Strip envelopes from the last user message(s)
   let lastText = stripSystemPrefix(stripChannelEnvelope(userMsgs[userMsgs.length - 1].text.trim()));
@@ -1313,10 +1395,22 @@ export function rerankByTypeWeight(
 // Hook helpers
 // ============================================================================
 
-function buildRunnerOpts(config: PalaiaPluginConfig): RunnerOpts {
+/**
+ * Resolve per-agent workspace and agentId from hook context.
+ * Fallback chain: ctx.workspaceDir → config.workspace → cwd
+ * Agent chain: ctx.agentId → PALAIA_AGENT env var → undefined
+ */
+export function resolvePerAgentContext(ctx: any, config: PalaiaPluginConfig) {
+  return {
+    workspace: ctx?.workspaceDir || config.workspace,
+    agentId: ctx?.agentId || process.env.PALAIA_AGENT || undefined,
+  };
+}
+
+function buildRunnerOpts(config: PalaiaPluginConfig, overrides?: { workspace?: string }): RunnerOpts {
   return {
     binaryPath: config.binaryPath,
-    workspace: config.workspace,
+    workspace: overrides?.workspace || config.workspace,
     timeoutMs: config.timeoutMs,
   };
 }
@@ -1510,6 +1604,10 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
       // Prune stale entries to prevent memory leaks from crashed sessions (C-2)
       pruneStaleEntries();
 
+      // Per-agent workspace resolution (Issue #111)
+      const resolved = resolvePerAgentContext(ctx, config);
+      const hookOpts = buildRunnerOpts(config, { workspace: resolved.workspace });
+
       try {
         const maxChars = config.maxInjectedChars || 4000;
         const limit = Math.min(config.maxResults || 10, 20);
@@ -1525,15 +1623,22 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
             let serverQueried = false;
             if (config.embeddingServer) {
               try {
-                const mgr = getEmbedServerManager(opts);
-                const resp = await mgr.query({
-                  text: userMessage,
-                  top_k: limit,
-                  include_cold: config.tier === "all",
-                }, config.timeoutMs || 3000);
-                if (resp?.result?.results && Array.isArray(resp.result.results)) {
-                  entries = resp.result.results;
-                  serverQueried = true;
+                const mgr = getEmbedServerManager(hookOpts);
+                // If embed server workspace differs from resolved workspace, skip server and use CLI
+                const serverWorkspace = hookOpts.workspace;
+                const embedOpts = buildRunnerOpts(config);
+                if (serverWorkspace !== embedOpts.workspace) {
+                  logger.info(`[palaia] Embed server workspace mismatch (agent=${resolved.workspace}), falling back to CLI`);
+                } else {
+                  const resp = await mgr.query({
+                    text: userMessage,
+                    top_k: limit,
+                    include_cold: config.tier === "all",
+                  }, config.timeoutMs || 3000);
+                  if (resp?.result?.results && Array.isArray(resp.result.results)) {
+                    entries = resp.result.results;
+                    serverQueried = true;
+                  }
                 }
               } catch (serverError) {
                 logger.warn(`[palaia] Embed server query failed, falling back to CLI: ${serverError}`);
@@ -1547,7 +1652,7 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
                 if (config.tier === "all") {
                   queryArgs.push("--all");
                 }
-                const result = await runJson<QueryResult>(queryArgs, { ...opts, timeoutMs: 15000 });
+                const result = await runJson<QueryResult>(queryArgs, { ...hookOpts, timeoutMs: 15000 });
                 if (result && Array.isArray(result.results)) {
                   entries = result.results;
                 }
@@ -1569,7 +1674,7 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
             } else {
               listArgs.push("--tier", config.tier || "hot");
             }
-            const result = await runJson<QueryResult>(listArgs, opts);
+            const result = await runJson<QueryResult>(listArgs, hookOpts);
             if (result && Array.isArray(result.results)) {
               entries = result.results;
             }
@@ -1615,7 +1720,7 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
         // Update recall counter for satisfaction/transparency nudges (Issue #87)
         let nudgeContext = "";
         try {
-          const pluginState = await loadPluginState(config.workspace);
+          const pluginState = await loadPluginState(resolved.workspace);
           pluginState.successfulRecalls++;
           if (!pluginState.firstRecallTimestamp) {
             pluginState.firstRecallTimestamp = new Date().toISOString();
@@ -1624,7 +1729,7 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
           if (nudges.length > 0) {
             nudgeContext = "\n\n## Agent Nudge (Palaia)\n\n" + nudges.join("\n\n");
           }
-          await savePluginState(pluginState, config.workspace);
+          await savePluginState(pluginState, resolved.workspace);
         } catch {
           // Non-fatal
         }
@@ -1686,14 +1791,16 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
       // Resolve session key for turn state
       const sessionKey = resolveSessionKeyFromCtx(ctx);
 
-      // DEBUG: always log agent_end firing
+      // Per-agent workspace resolution (Issue #111)
+      const resolved = resolvePerAgentContext(ctx, config);
+      const hookOpts = buildRunnerOpts(config, { workspace: resolved.workspace });
 
       if (!event.success || !event.messages || event.messages.length === 0) {
         return;
       }
 
       try {
-        const agentName = process.env.PALAIA_AGENT || undefined;
+        const agentName = resolved.agentId;
 
         const allTexts = extractMessageTexts(event.messages);
 
@@ -1709,9 +1816,18 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
           collectedHints.push(...hints);
         }
 
+        // Strip Palaia-injected recall context from user messages to prevent feedback loop.
+        // 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
+        );
+
         // Only extract from recent exchanges — full history causes LLM timeouts
         // and dilutes extraction quality
-        const recentTexts = trimToRecentExchanges(allTexts);
+        const recentTexts = trimToRecentExchanges(cleanedTexts);
 
         // Build exchange text from recent window only
         const exchangeParts: string[] = [];
@@ -1725,7 +1841,7 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
           return;
         }
 
-        const knownProjects = await loadProjects(opts);
+        const knownProjects = await loadProjects(hookOpts);
 
         // Helper: build CLI args with metadata
         const buildWriteArgs = (
@@ -1793,7 +1909,7 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
                 validatedProject,
                 effectiveScope,
               );
-              await run(args, { ...opts, timeoutMs: 10_000 });
+              await run(args, { ...hookOpts, timeoutMs: 10_000 });
               logger.info(
                 `[palaia] LLM auto-captured: type=${r.type}, significance=${r.significance}, tags=${tags.join(",")}, project=${validatedProject || "none"}, scope=${effectiveScope || "team"}`
               );
@@ -1877,7 +1993,7 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
             hintForScope?.scope,
           );
 
-          await run(args, { ...opts, timeoutMs: 10_000 });
+          await run(args, { ...hookOpts, timeoutMs: 10_000 });
           logger.info(
             `[palaia] Rule-based auto-captured: type=${captureData.type}, tags=${captureData.tags.join(",")}`
           );

package/src/runner.ts

@@ -361,6 +361,11 @@ export class EmbedServerManager {
           clearTimeout(this.pendingRequest.timer);
           this.pendingRequest = null;
         }
+        // Reject all queued requests
+        for (const queued of this.requestQueue) {
+          queued.reject(new Error(`Embed server exited with code ${code}`));
+        }
+        this.requestQueue = [];
       });
 
       // Register cleanup
@@ -456,6 +461,16 @@ export class EmbedServerManager {
     await this.start();
   }
 
+  /** Maximum number of queued requests before rejecting */
+  private maxQueueSize = 10;
+  /** Queue of pending requests waiting to be sent */
+  private requestQueue: Array<{
+    request: Record<string, unknown>;
+    timeoutMs: number;
+    resolve: (value: any) => void;
+    reject: (reason: any) => void;
+  }> = [];
+
   private sendRequest(request: Record<string, unknown>, timeoutMs: number): Promise<any> {
     return new Promise((resolve, reject) => {
       if (!this.proc?.stdin?.writable) {
@@ -463,22 +478,46 @@ export class EmbedServerManager {
         return;
       }
 
-      // Only one request at a time (sequential protocol)
+      // If a request is already in flight, queue this one
       if (this.pendingRequest) {
-        reject(new Error("Embed server busy"));
+        if (this.requestQueue.length >= this.maxQueueSize) {
+          reject(new Error("Embed server queue full"));
+          return;
+        }
+        this.requestQueue.push({ request, timeoutMs, resolve, reject });
         return;
       }
 
-      const timer = setTimeout(() => {
-        this.pendingRequest = null;
-        reject(new Error(`Embed server request timed out after ${timeoutMs}ms`));
-      }, timeoutMs);
+      this._sendImmediate(request, timeoutMs, resolve, reject);
+    });
+  }
+
+  private _sendImmediate(
+    request: Record<string, unknown>,
+    timeoutMs: number,
+    resolve: (value: any) => void,
+    reject: (reason: any) => void,
+  ): void {
+    const timer = setTimeout(() => {
+      this.pendingRequest = null;
+      reject(new Error(`Embed server request timed out after ${timeoutMs}ms`));
+      this._drainQueue();
+    }, timeoutMs);
 
-      this.pendingRequest = { resolve, reject, timer };
+    this.pendingRequest = { resolve, reject, timer };
 
-      const line = JSON.stringify(request) + "\n";
-      this.proc.stdin!.write(line);
-    });
+    const line = JSON.stringify(request) + "\n";
+    this.proc!.stdin!.write(line);
+  }
+
+  private _drainQueue(): void {
+    if (this.pendingRequest || this.requestQueue.length === 0) return;
+    const next = this.requestQueue.shift()!;
+    if (!this.proc?.stdin?.writable) {
+      next.reject(new Error("Embed server not running"));
+      return;
+    }
+    this._sendImmediate(next.request, next.timeoutMs, next.resolve, next.reject);
   }
 
   private handleLine(line: string): void {
@@ -493,6 +532,8 @@ export class EmbedServerManager {
       } else {
         pending.resolve(msg);
       }
+      // Process next queued request
+      this._drainQueue();
     } catch {
       // Ignore non-JSON lines
     }