@caupulican/pi-adaptative 0.80.60 → 0.80.62

package/dist/core/agent-session.js

@@ -32,8 +32,10 @@ import { ExtensionRunner, wrapRegisteredTools, } from "./extensions/index.js";
 import { disposeExtensionEventSubscriptions } from "./extensions/loader.js";
 import { emitSessionShutdownEvent } from "./extensions/runner.js";
 import { decideDemand, ReflectionEngine, } from "./learning/reflection-engine.js";
+import { EffectivenessTracker } from "./memory/effectiveness-tracker.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";
@@ -119,6 +121,8 @@ export class AgentSession {
     _isExplicitThinking;
     /** Plug-and-play memory subsystem. Recreated on each (re)initialize so reload is safe. */
     _memoryManager = new MemoryManager();
+    /** R4: tracks whether injected recall is actually used, to adapt the recall gate. */
+    _effectivenessTracker = new EffectivenessTracker();
     _isChildSession;
     /** Memory providers registered by extensions via pi.registerMemoryProvider, applied on (re)init. */
     _pendingMemoryProviders = [];
@@ -960,11 +964,31 @@ 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);
+        // R4 adaptive gate: if recall has rarely been used lately (enough samples to trust the signal),
+        // raise the bar so we only recall on clearly substantial turns — and relax it again once recall
+        // starts paying off. Never fully disabled, so the loop can recover.
+        const recallRarelyUseful = this._effectivenessTracker.sampleCount >= 5 && this._effectivenessTracker.usefulLately() < 0.15;
+        return words.length >= (recallRarelyUseful ? 6 : 3);
+    }
     async _promptUnserialized(text, options) {
         const expandPromptTemplates = options?.expandPromptTemplates ?? true;
         const processSlashCommands = options?.processSlashCommands ?? expandPromptTemplates;
         const preflightResult = options?.preflightResult;
         let messages;
+        // R4 effectiveness feedback: remember the recall page + the query so we can score, after the
+        // response, whether the agent actually used the recalled context.
+        let injectedRecall = "";
+        let recallQuery = "";
         try {
             // Handle extension commands first. Programmatic extension messages may opt
             // into command handling; if the agent is currently streaming, queue the
@@ -1043,8 +1067,25 @@ 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) {
+                        injectedRecall = recall;
+                        recallQuery = expandedText;
+                        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) {
@@ -1093,6 +1134,19 @@ export class AgentSession {
         }
         preflightResult?.(true);
         await this._runAgentPrompt(messages);
+        // R4: score whether the agent actually used the recalled context, so the recall gate can adapt.
+        if (injectedRecall) {
+            const response = this._findLastAssistantMessage();
+            const responseText = response
+                ? response.content
+                    .filter((c) => c.type === "text")
+                    .map((c) => c.text)
+                    .join(" ")
+                : "";
+            if (responseText) {
+                this._effectivenessTracker.recordRecallOutcome(injectedRecall, recallQuery, responseText);
+            }
+        }
     }
     /**
      * Try to execute an extension command. Returns true if command was found and executed.
@@ -2202,6 +2256,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);