@caupulican/pi-adaptative 0.80.54 → 0.80.57

package/dist/core/agent-session.js

@@ -31,7 +31,10 @@ import { createCoreDiagnosticsToolDefinitions } from "./extensions/builtin.js";
 import { ExtensionRunner, wrapRegisteredTools, } from "./extensions/index.js";
 import { disposeExtensionEventSubscriptions } from "./extensions/loader.js";
 import { emitSessionShutdownEvent } from "./extensions/runner.js";
+import { MemoryManager } from "./memory/memory-manager.js";
+import { FileStoreProvider } from "./memory/providers/file-store.js";
 import { compactToolResultDetailsForRetention } from "./message-retention.js";
+import { resolveProfileModelSettings } from "./model-resolver.js";
 import { expandPromptTemplate } from "./prompt-templates.js";
 import { stripResourceProfileBlocks } from "./resource-profile-blocks.js";
 import { CURRENT_SESSION_VERSION, getLatestCompactionEntry } from "./session-manager.js";
@@ -109,6 +112,13 @@ export class AgentSession {
     _allowedToolNames;
     _excludedToolNames;
     _toolProfileFilter;
+    _isExplicitModel;
+    _isExplicitThinking;
+    /** Plug-and-play memory subsystem. Recreated on each (re)initialize so reload is safe. */
+    _memoryManager = new MemoryManager();
+    _isChildSession;
+    /** Memory providers registered by extensions via pi.registerMemoryProvider, applied on (re)init. */
+    _pendingMemoryProviders = [];
     _baseToolsOverride;
     _sessionStartEvent;
     _extensionUIContext;
@@ -145,6 +155,9 @@ export class AgentSession {
         this._toolProfileFilter = config.toolProfileFilter
             ? { allow: config.toolProfileFilter.allow ?? [], block: config.toolProfileFilter.block ?? [] }
             : undefined;
+        this._isExplicitModel = config.isExplicitModel ?? false;
+        this._isExplicitThinking = config.isExplicitThinking ?? false;
+        this._isChildSession = config.isChildSession ?? process.env.PI_CHILD_SESSION === "1";
         this._baseToolsOverride = config.baseToolsOverride;
         this._sessionStartEvent = config.sessionStartEvent ?? { type: "session_start", reason: "startup" };
         // Always subscribe to agent events for internal handling
@@ -646,6 +659,9 @@ export class AgentSession {
         this._extensionRunner.invalidate("This extension ctx is stale after session replacement or reload. Do not use a captured pi or command ctx after ctx.newSession(), ctx.fork(), ctx.switchSession(), or ctx.reload(). For newSession, fork, and switchSession, move post-replacement work into withSession and use the ctx passed to withSession. For reload, do not use the old ctx after await ctx.reload().");
         this._disconnectFromAgent();
         this._eventListeners = [];
+        // Best-effort memory cleanup (release locks/handles). Write-side onSessionEnd is wired on a
+        // true session-end hook (P3); file-store shutdown is a no-op.
+        void this._memoryManager.shutdownAll().catch(() => { });
         cleanupSessionResources(this.sessionId);
     }
     // =========================================================================
@@ -862,6 +878,8 @@ export class AgentSession {
         const appendSystemPromptParts = [
             this._buildSelfModificationPrompt(),
             this._buildAutonomyPrompt(),
+            // Memory subsystem: static, frozen-per-session block (e.g. file-store MEMORY.md/USER.md).
+            this._memoryManager.buildSystemPromptBlock() || undefined,
             ...loaderAppendSystemPrompt,
         ].filter((part) => Boolean(part));
         const appendSystemPrompt = appendSystemPromptParts.length > 0 ? appendSystemPromptParts.join("\n\n") : undefined;
@@ -1933,6 +1951,8 @@ export class AgentSession {
         this._applyExtensionBindings(this._extensionRunner);
         await this._extensionRunner.emit(this._sessionStartEvent);
         await this.extendResourcesFromExtensions(this._sessionStartEvent.reason === "reload" ? "reload" : "startup");
+        // Initialize the memory subsystem after extensions have had a chance to register providers.
+        await this._initializeMemory();
     }
     async extendResourcesFromExtensions(reason) {
         if (!this._extensionRunner.hasHandlers("resources_discover")) {
@@ -2061,6 +2081,7 @@ export class AgentSession {
             getThinkingLevel: () => this.thinkingLevel,
             setThinkingLevel: (level) => this.setThinkingLevel(level),
             getExternalResourceRoots: () => this.settingsManager.getEffectiveExternalResourceRoots(),
+            registerMemoryProvider: (provider) => this.registerMemoryProvider(provider),
         }, {
             getModel: () => this.model,
             isIdle: () => !this.isStreaming,
@@ -2123,6 +2144,82 @@ export class AgentSession {
         const filter = this.settingsManager.getResourceProfileFilter("tools");
         return { allow: filter.allow ?? [], block: filter.block ?? [] };
     }
+    /**
+     * Re-resolve the active resource profile's model/thinking from current settings and apply it.
+     * Only acts when the profile actually binds model/thinking AND that field was not set by an
+     * explicit launch flag — so live profile edits apply on reload without clobbering an explicit
+     * --model/--thinking. A no-op for profiles that don't bind a model.
+     */
+    async _reapplyActiveProfileModelSettings() {
+        if (this._isExplicitModel && this._isExplicitThinking)
+            return;
+        const activeProfileNames = this.settingsManager.getActiveResourceProfileNames();
+        if (activeProfileNames.length === 0)
+            return;
+        const profileSettings = resolveProfileModelSettings({
+            activeProfileNames,
+            registry: this.settingsManager.getProfileRegistry(),
+            modelRegistry: this._modelRegistry,
+            cwd: this._cwd,
+        });
+        if (!this._isExplicitModel && profileSettings.model) {
+            const current = this.agent.state.model;
+            const next = profileSettings.model;
+            if (!current || current.provider !== next.provider || current.id !== next.id) {
+                // Mirror the startup/cycle path: set the model directly (no auth gate, no settings
+                // persist) so re-applying the profile model behaves like initial resolution rather
+                // than a runtime model switch. No model_select emit here — reload rebuilds the
+                // extension runtime and emits session_start("reload") right after, and the UI
+                // re-renders from session.model.
+                this.agent.state.model = next;
+                this.sessionManager.appendModelChange(next.provider, next.id);
+            }
+        }
+        if (!this._isExplicitThinking && profileSettings.thinkingLevel) {
+            this.setThinkingLevel(profileSettings.thinkingLevel);
+        }
+    }
+    /**
+     * (Re)build the memory subsystem: a fresh MemoryManager (reload-safe), register the bundled
+     * file-store + any extension-contributed providers, initialize, then surface the memory tools and
+     * the frozen system-prompt block. Best-effort: never throws into the session lifecycle.
+     */
+    async _initializeMemory() {
+        try {
+            // Release the previous generation's providers (locks/handles) before recreating, so a
+            // reload does not orphan the old MemoryManager. No-op on first init / for file-store.
+            await this._memoryManager.shutdownAll().catch(() => { });
+            const manager = new MemoryManager();
+            manager.registerProvider(new FileStoreProvider());
+            for (const provider of this._pendingMemoryProviders) {
+                try {
+                    manager.registerProvider(provider);
+                }
+                catch {
+                    // Duplicate name or reserved-tool collision — skip this provider, keep the rest.
+                }
+            }
+            this._memoryManager = manager;
+            await manager.initializeAll(this.sessionManager.getSessionId(), {
+                agentDir: this._agentDir,
+                cwd: this._cwd,
+                isChildSession: this._isChildSession,
+            });
+            // Surface memory tools + the frozen memory block now that providers are initialized.
+            // _refreshToolRegistry() ends in setActiveToolsByName(), which rebuilds AND assigns the
+            // system prompt (including the memory block), so no explicit _rebuildSystemPrompt is needed.
+            this._refreshToolRegistry();
+        }
+        catch (error) {
+            console.error("Memory subsystem init failed:", error instanceof Error ? error.message : String(error));
+        }
+    }
+    /** Register a memory provider contributed by an extension; applied on the next memory (re)init. */
+    registerMemoryProvider(provider) {
+        if (!this._pendingMemoryProviders.some((p) => p.name === provider.name)) {
+            this._pendingMemoryProviders.push(provider);
+        }
+    }
     _refreshToolRegistry(options) {
         const previousRegistryNames = new Set(this._toolRegistry.keys());
         const previousActiveToolNames = this.getActiveToolNames();
@@ -2150,6 +2247,11 @@ export class AgentSession {
                 definition,
                 sourceInfo: createSyntheticSourceInfo(`<sdk:${definition.name}>`, { source: "sdk" }),
             })),
+            // Memory subsystem provider tools (e.g. file-store's `memory` tool).
+            ...this._memoryManager.getToolDefinitions().map((definition) => ({
+                definition,
+                sourceInfo: createSyntheticSourceInfo(`<memory:${definition.name}>`, { source: "sdk" }),
+            })),
         ].filter((tool) => isAllowedTool(tool.definition.name));
         const definitionRegistry = new Map(Array.from(this._baseToolDefinitions.entries())
             .filter(([name]) => isAllowedTool(name))
@@ -2324,6 +2426,10 @@ export class AgentSession {
             // active profile's tools allow/block — or switching the active profile — would not
             // apply on /reload and allowed tools would stay missing.
             this._toolProfileFilter = this._deriveToolProfileFilter();
+            // Re-apply the active profile's model/thinking from the freshly reloaded settings, so a live
+            // profile edit (or switch) takes effect on /reload. Skipped when the launch used an explicit
+            // --model/--thinking flag, which must win over the profile across reloads.
+            await this._reapplyActiveProfileModelSettings();
             await this._resourceLoader.reload({ failOnExtensionErrors: true, deferExtensionDispose: true });
             resetApiProviders();
             this._buildRuntime({
@@ -2337,6 +2443,8 @@ export class AgentSession {
             });
             try {
                 this._doctorReloadRuntime();
+                // Reload starts memory providers fresh; loaded extensions re-register below.
+                this._pendingMemoryProviders = [];
                 const hasBindings = this._extensionUIContext ||
                     this._extensionCommandContextActions ||
                     this._extensionShutdownHandler ||
@@ -2356,6 +2464,8 @@ export class AgentSession {
             await emitSessionShutdownEvent(previousRunner, { type: "session_shutdown", reason: "reload" });
             previousRunner.invalidate();
             this._resourceLoader.commitReload?.();
+            // Re-derive the memory subsystem from the reloaded settings/providers.
+            await this._initializeMemory();
         }
         catch (error) {
             if (newRunner && newRunner !== previousRunner) {