@caupulican/pi-adaptative 0.80.61 → 0.80.62

package/dist/core/agent-session.js

@@ -32,6 +32,7 @@ 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";
@@ -120,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 = [];
@@ -971,13 +974,21 @@ export class AgentSession {
         if (t.length < 12 || t.startsWith("/"))
             return false;
         const words = t.split(/\s+/).filter((w) => w.length >= 3);
-        return words.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
@@ -1066,6 +1077,8 @@ export class AgentSession {
                 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() });
                     }
                 }
@@ -1121,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.