@caupulican/pi-adaptative 0.80.59 → 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";
@@ -777,7 +778,7 @@ export class AgentSession {
     }
     /** File-based prompt templates */
     get promptTemplates() {
-        return this._resourceLoader.getPrompts().prompts;
+        return this._resourceLoader.getActivePrompts();
     }
     _normalizePromptSnippet(text) {
         if (!text)
@@ -886,7 +887,9 @@ export class AgentSession {
             ...loaderAppendSystemPrompt,
         ].filter((part) => Boolean(part));
         const appendSystemPrompt = appendSystemPromptParts.length > 0 ? appendSystemPromptParts.join("\n\n") : undefined;
-        const loadedSkills = this._resourceLoader.getSkills().skills;
+        // Only surface skills the active profile permits — the agent must not be told about (or able
+        // to invoke) a skill its profile blocks.
+        const loadedSkills = this._resourceLoader.getActiveSkills();
         const loadedContextFiles = this._resourceLoader.getAgentsFiles().agentsFiles;
         this._baseSystemPromptOptions = {
             cwd: this._cwd,
@@ -897,6 +900,7 @@ export class AgentSession {
             selectedTools: validToolNames,
             toolSnippets,
             promptGuidelines,
+            extensions: [...this._extensionRunner.activeExtensions],
         };
         return buildSystemPrompt(this._baseSystemPromptOptions);
     }
@@ -957,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;
@@ -1040,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) {
@@ -1133,9 +1164,11 @@ export class AgentSession {
         const spaceIndex = text.indexOf(" ");
         const skillName = spaceIndex === -1 ? text.slice(7) : text.slice(7, spaceIndex);
         const args = spaceIndex === -1 ? "" : text.slice(spaceIndex + 1).trim();
-        const skill = this.resourceLoader.getSkills().skills.find((s) => s.name === skillName);
+        // Resolve only against profile-active skills so a `/skill:` the active profile blocks cannot be
+        // expanded/invoked — by the user OR the agent — even if it loaded before a runtime profile switch.
+        const skill = this.resourceLoader.getActiveSkills().find((s) => s.name === skillName);
         if (!skill)
-            return text; // Unknown skill, pass through
+            return text; // Unknown or profile-blocked skill, pass through unchanged
         try {
             const content = readFileSync(skill.filePath, "utf-8");
             const body = stripResourceProfileBlocks(stripFrontmatter(content)).trim();
@@ -2031,7 +2064,7 @@ export class AgentSession {
                 source: "prompt",
                 sourceInfo: template.sourceInfo,
             }));
-            const skills = this._resourceLoader.getSkills().skills.map((skill) => ({
+            const skills = this._resourceLoader.getActiveSkills().map((skill) => ({
                 name: `skill:${skill.name}`,
                 description: skill.description,
                 source: "skill",
@@ -2197,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);