@caupulican/pi-adaptative 0.80.60 → 0.80.61

package/dist/core/agent-session.js

@@ -34,6 +34,7 @@ import { emitSessionShutdownEvent } from "./extensions/runner.js";
 import { decideDemand, ReflectionEngine, } from "./learning/reflection-engine.js";
 import { MemoryManager } from "./memory/memory-manager.js";
 import { FileStoreProvider } from "./memory/providers/file-store.js";
+import { TranscriptRecallProvider } from "./memory/providers/transcript-recall.js";
 import { compactToolResultDetailsForRetention } from "./message-retention.js";
 import { resolveProfileModelSettings } from "./model-resolver.js";
 import { expandPromptTemplate } from "./prompt-templates.js";
@@ -960,6 +961,18 @@ export class AgentSession {
         }
         return this._promptUnserialized(text, options);
     }
+    /**
+     * Zero-I/O gate for cross-session recall (R3): skip trivial turns (short acks, slash commands) so
+     * recall only runs when it could plausibly help. The provider's similarity cutoff is the real
+     * filter — this just avoids the index query on turns that obviously don't warrant it.
+     */
+    _shouldAttemptRecall(text) {
+        const t = text.trim();
+        if (t.length < 12 || t.startsWith("/"))
+            return false;
+        const words = t.split(/\s+/).filter((w) => w.length >= 3);
+        return words.length >= 3;
+    }
     async _promptUnserialized(text, options) {
         const expandPromptTemplates = options?.expandPromptTemplates ?? true;
         const processSlashCommands = options?.processSlashCommands ?? expandPromptTemplates;
@@ -1043,8 +1056,23 @@ export class AgentSession {
             if (lastAssistant) {
                 await this._checkCompaction(lastAssistant, false);
             }
-            // Build messages array (custom message if any, then user message)
+            // Build messages array (recall page, then custom message if any, then user message)
             messages = [];
+            // R3: cross-session similarity recall. For a substantive turn, ask the memory providers to
+            // prefetch a relevant <memory_context> page from past sessions and prepend it as data ahead of
+            // the user message. Best-effort and gated: trivial turns are skipped, and providers return ""
+            // (no page) when nothing is relevant — so it stays net-negative and the GC packs stale pages.
+            if (this._shouldAttemptRecall(expandedText)) {
+                try {
+                    const recall = await this._memoryManager.prefetch(expandedText);
+                    if (recall) {
+                        messages.push({ role: "user", content: [{ type: "text", text: recall }], timestamp: Date.now() });
+                    }
+                }
+                catch {
+                    // recall must never break a turn
+                }
+            }
             // Add user message
             const userContent = [{ type: "text", text: expandedText }];
             if (currentImages) {
@@ -2202,6 +2230,9 @@ export class AgentSession {
             await this._memoryManager.shutdownAll().catch(() => { });
             const manager = new MemoryManager();
             manager.registerProvider(new FileStoreProvider());
+            // Bundled read-only cross-session recall (R3): indexes past-session transcripts and answers
+            // prefetch() with a <memory_context> page. Never writes.
+            manager.registerProvider(new TranscriptRecallProvider());
             for (const provider of this._pendingMemoryProviders) {
                 try {
                     manager.registerProvider(provider);