@caupulican/pi-adaptative 0.81.26 → 0.81.29

package/dist/core/runtime-builder.js

@@ -34,7 +34,7 @@
  */
 import { existsSync, readFileSync } from "node:fs";
 import { isAbsolute, join } from "node:path";
-import { resetApiProviders } from "@caupulican/pi-ai";
+import { DEFAULT_ACTIVE_TOOL_NAMES } from "./default-tool-surface.js";
 import { createCoreDiagnosticsToolDefinitions } from "./extensions/builtin.js";
 import { ExtensionRunner, wrapRegisteredTools, } from "./extensions/index.js";
 import { disposeExtensionEventSubscriptions } from "./extensions/loader.js";
@@ -49,6 +49,7 @@ import { buildReflexUserPrompt, parseReflexPlan, REFLEX_INTERPRETER_SYSTEM_PROMP
 import { executeToolkitScript } from "./toolkit/script-runner.js";
 import { createContextScoutToolDefinition } from "./tools/context-scout.js";
 import { createDelegateToolDefinition } from "./tools/delegate.js";
+import { createDelegateStatusToolDefinition } from "./tools/delegate-status.js";
 import { createFindTool } from "./tools/find.js";
 import { createGoalToolDefinition } from "./tools/goal.js";
 import { createGrepTool } from "./tools/grep.js";
@@ -68,6 +69,8 @@ export class RuntimeBuilder {
     _toolPromptSnippets = new Map();
     _toolPromptGuidelines = new Map();
     _baseToolDefinitions = new Map();
+    _reloadPromise;
+    _reloadRequested = false;
     deps;
     constructor(deps) {
         this.deps = deps;
@@ -201,26 +204,26 @@ export class RuntimeBuilder {
         this._toolRegistry = toolRegistry;
         const requestedBase = options?.activeToolNames ? [...options.activeToolNames] : [...previousActiveToolNames];
         const nextActiveToolNames = requestedBase.filter((name) => isAllowedTool(name));
-        const autoActivated = [];
+        const persistentAutoActivated = [];
         if (allowedToolNames) {
             for (const toolName of this._toolRegistry.keys()) {
                 if (allowedToolNames.has(toolName)) {
                     nextActiveToolNames.push(toolName);
-                    autoActivated.push(toolName);
+                    persistentAutoActivated.push(toolName);
                 }
             }
         }
         else if (options?.includeAllExtensionTools) {
             for (const tool of wrappedExtensionTools) {
                 nextActiveToolNames.push(tool.name);
-                autoActivated.push(tool.name);
+                persistentAutoActivated.push(tool.name);
             }
         }
         else if (!options?.activeToolNames) {
             for (const toolName of this._toolRegistry.keys()) {
                 if (!previousRegistryNames.has(toolName)) {
                     nextActiveToolNames.push(toolName);
-                    autoActivated.push(toolName);
+                    persistentAutoActivated.push(toolName);
                 }
             }
         }
@@ -242,7 +245,6 @@ export class RuntimeBuilder {
                 }
                 if (matchesResourceProfilePattern(toolName, explicitAllowPatterns)) {
                     nextActiveToolNames.push(toolName);
-                    autoActivated.push(toolName);
                 }
             }
             // G13: an explicit grant that binds to NO registered tool is a silent no-op — typo'd
@@ -260,14 +262,29 @@ export class RuntimeBuilder {
         // guarantee, not just this settings/profile refresh flow.
         this.deps.setActiveToolsByName([...new Set(nextActiveToolNames)]);
         // setActiveToolsByName just stored the profile-filtered ACTIVE set as the request; restore
-        // the true pre-filter request (plus this refresh's auto-activations) so an internal refresh
-        // can never permanently narrow it.
-        this.deps.setRequestedActiveToolNames([...new Set([...requestedBase, ...autoActivated])]);
+        // the true pre-filter request (plus non-profile auto-activations) so an internal refresh can
+        // never permanently narrow it. Explicit profile grants are generation-local activations: if
+        // profile A names grep and profile B later grants "*", A must not pin grep into B's request.
+        this.deps.setRequestedActiveToolNames([...new Set([...requestedBase, ...persistentAutoActivated])]);
     }
     _createReloadRuntimeSnapshot() {
         const agent = this.deps.getAgent();
+        const toolProfileFilter = this.deps.getToolProfileFilter();
+        const requestedActiveToolNames = this.deps.getRequestedActiveToolNames();
         return {
             extensionRunner: this.deps.getExtensionRunner(),
+            settings: this.deps.getSettingsManager().createReloadSnapshot(),
+            modelRegistry: this.deps.getModelRegistry().createReloadSnapshot(),
+            model: agent.state.model,
+            thinkingLevel: agent.state.thinkingLevel,
+            sessionLeafId: this.deps.getSessionManager().getLeafId(),
+            toolProfileFilter: toolProfileFilter
+                ? { allow: [...toolProfileFilter.allow], block: [...toolProfileFilter.block] }
+                : undefined,
+            requestedActiveToolNames: requestedActiveToolNames ? [...requestedActiveToolNames] : undefined,
+            memory: this.deps.createMemoryReloadSnapshot(),
+            profileFilter: this.deps.createProfileFilterReloadSnapshot(),
+            unboundToolGrantWarnings: [...this.deps.getUnboundToolGrantWarnings()],
             baseToolDefinitions: this._baseToolDefinitions,
             toolRegistry: this._toolRegistry,
             toolDefinitions: this._toolDefinitions,
@@ -279,6 +296,15 @@ export class RuntimeBuilder {
         };
     }
     _restoreReloadRuntimeSnapshot(snapshot) {
+        this.deps.getSettingsManager().restoreReloadSnapshot(snapshot.settings);
+        this.deps.getModelRegistry().restoreReloadSnapshot(snapshot.modelRegistry);
+        this.deps.setToolProfileFilter(snapshot.toolProfileFilter
+            ? { allow: [...snapshot.toolProfileFilter.allow], block: [...snapshot.toolProfileFilter.block] }
+            : undefined);
+        this.deps.setRequestedActiveToolNames(snapshot.requestedActiveToolNames ? [...snapshot.requestedActiveToolNames] : undefined);
+        this.deps.restoreMemoryReloadSnapshot(snapshot.memory);
+        this.deps.restoreProfileFilterReloadSnapshot(snapshot.profileFilter);
+        this.deps.setUnboundToolGrantWarnings([...snapshot.unboundToolGrantWarnings]);
         // setExtensionRunner restores both _extensionRunner and _extensionRunnerRef.current together
         // (the same field-then-ref pair the host wrote at every assignment site); nothing reads the
         // ref between the two writes, so folding them is unobservable.
@@ -289,9 +315,18 @@ export class RuntimeBuilder {
         this._toolPromptSnippets = snapshot.toolPromptSnippets;
         this._toolPromptGuidelines = snapshot.toolPromptGuidelines;
         const agent = this.deps.getAgent();
+        agent.state.model = snapshot.model;
+        agent.state.thinkingLevel = snapshot.thinkingLevel;
         agent.state.tools = snapshot.agentTools;
         agent.state.systemPrompt = snapshot.agentSystemPrompt;
         this.deps.setBaseSystemPrompt(snapshot.baseSystemPrompt);
+        const sessionManager = this.deps.getSessionManager();
+        if (snapshot.sessionLeafId === null) {
+            sessionManager.resetLeaf();
+        }
+        else {
+            sessionManager.branch(snapshot.sessionLeafId);
+        }
         this.deps.applyExtensionBindings(snapshot.extensionRunner);
     }
     _doctorReloadRuntime() {
@@ -321,11 +356,11 @@ export class RuntimeBuilder {
         const shellCommandPrefix = settingsManager.getShellCommandPrefix();
         const shellPath = settingsManager.getShellPath();
         const baseToolsOverride = this.deps.getBaseToolsOverride();
-        // grep/find must not emit a "Full output: artifact tool-output:<id>" handle that
-        // nothing can resolve. If artifact_retrieve is explicitly excluded/blocked/outside
-        // an active allowlist, don't hand grep/find an artifact store at all: they fall
-        // back to their pre-existing bounded preview/truncation behavior, with no
-        // payload/meta files ever written and no retrieval promise made.
+        // Artifact-producing tools must not emit a "Full output: artifact tool-output:<id>" handle
+        // that nothing can resolve. If artifact_retrieve is explicitly excluded/blocked/outside
+        // an active allowlist, don't hand grep/find/run_toolkit_script an artifact store at all:
+        // they fall back to their bounded preview/truncation behavior, with no payload/meta files
+        // ever written and no retrieval promise made.
         const toolArtifactStore = this.deps.isToolOrCommandAllowedByProfile("artifact_retrieve")
             ? this.deps.getToolArtifactStore()
             : undefined;
@@ -351,9 +386,15 @@ export class RuntimeBuilder {
             });
             this._baseToolDefinitions.set(goalToolDefinition.name, goalToolDefinition);
             const delegateToolDefinition = createDelegateToolDefinition({
+                startWorkerDelegation: (args) => this.deps.startWorkerDelegation(args),
                 runWorkerDelegation: (args) => this.deps.runWorkerDelegationOnce(args),
             });
+            const delegateStatusToolDefinition = createDelegateStatusToolDefinition({
+                getLaneRecords: () => this.deps.getWorkerLaneRecords(),
+                getWorkerResultSnapshots: () => this.deps.getWorkerResultSnapshots(),
+            });
             this._baseToolDefinitions.set(delegateToolDefinition.name, delegateToolDefinition);
+            this._baseToolDefinitions.set(delegateStatusToolDefinition.name, delegateStatusToolDefinition);
             // Registered but not default-active: probes spend tokens on the probed model, so
             // activation is an explicit choice (settings/profile/setActiveTools or /autonomy fitness).
             const modelFitnessToolDefinition = createModelFitnessToolDefinition({
@@ -369,6 +410,7 @@ export class RuntimeBuilder {
             const runToolkitScriptToolDefinition = createRunToolkitScriptToolDefinition({
                 getScripts: () => this.deps.getSettingsManager().getToolkitScripts(),
                 execute: (script, scriptArgs) => executeToolkitScript({ script, scriptArgs, cwd: this.deps.getCwd() }),
+                artifactStore: toolArtifactStore,
                 // Reflex brain (fitness-gated local model): resolves ambiguous requests into a
                 // registry pick. Best-effort — absent/unfit brain keeps the shortlist behavior.
                 interpret: async (request, scripts) => {
@@ -408,29 +450,60 @@ export class RuntimeBuilder {
         extensionsResult.runtime.pendingProviderRegistrations =
             extensionsResult.runtime.pendingProviderRegistrations.filter((registration) => runtimeExtensionPaths.has(registration.extensionPath));
         const runner = new ExtensionRunner(extensions, extensionsResult.runtime, this.deps.getCwd(), this.deps.getSessionManager(), this.deps.getModelRegistry());
+        const offBuildErrors = options.onError ? runner.onError(options.onError) : undefined;
         this.deps.setExtensionRunner(runner);
-        this.deps.bindExtensionCore(runner);
+        try {
+            this.deps.bindExtensionCore(runner);
+        }
+        catch (error) {
+            offBuildErrors?.();
+            throw error;
+        }
         this.deps.applyExtensionBindings(runner);
         const defaultActiveToolNames = baseToolsOverride
             ? Object.keys(baseToolsOverride)
-            : [
-                "read",
-                "bash",
-                "edit",
-                "write",
-                "context_audit",
-                "goal",
-                "delegate",
-                "run_toolkit_script",
-                ...(settingsManager.getScoutSettings().enabled ? ["context_scout"] : []),
-            ];
+            : [...DEFAULT_ACTIVE_TOOL_NAMES, ...(settingsManager.getScoutSettings().enabled ? ["context_scout"] : [])];
         const baseActiveToolNames = options.activeToolNames ?? defaultActiveToolNames;
         this.refreshToolRegistry({
             activeToolNames: baseActiveToolNames,
             includeAllExtensionTools: options.includeAllExtensionTools,
         });
+        return offBuildErrors;
+    }
+    reload() {
+        if (this._reloadPromise) {
+            // State can change while a generation is being validated. Coalesce any number of
+            // overlapping requests into one follow-up generation instead of silently treating a
+            // later profile/settings mutation as part of the already-snapshotted generation.
+            this._reloadRequested = true;
+            return this._reloadPromise;
+        }
+        const reloadPromise = this._drainReloadRequests();
+        this._reloadPromise = reloadPromise;
+        return reloadPromise;
     }
-    async reload() {
+    async _drainReloadRequests() {
+        let finalError;
+        try {
+            do {
+                this._reloadRequested = false;
+                try {
+                    await this._reloadOnce();
+                    finalError = undefined;
+                }
+                catch (error) {
+                    finalError = error;
+                }
+            } while (this._reloadRequested);
+            if (finalError !== undefined)
+                throw finalError;
+        }
+        finally {
+            this._reloadPromise = undefined;
+            this._reloadRequested = false;
+        }
+    }
+    async _reloadOnce() {
         if (this.deps.isStreaming()) {
             throw new Error("Cannot reload while the agent is streaming or a tool call is active");
         }
@@ -443,8 +516,10 @@ export class RuntimeBuilder {
         // active set — otherwise a reload under a small model permanently shrinks the restorable set.
         const activeToolNames = this.deps.getRequestedActiveToolNames() ?? this.deps.getActiveToolNames();
         const previousFlagValues = previousRunner.getFlagValues();
+        const previousExtensionProviderNames = previousRunner.getRegisteredProviderNames();
         const reloadErrors = [];
         let newRunner;
+        let offReloadErrors;
         try {
             await this.deps.getSettingsManager().reload();
             // Re-derive the resource-profile tool filter from the freshly reloaded settings.
@@ -453,21 +528,30 @@ export class RuntimeBuilder {
             // active profile's tools allow/block — or switching the active profile — would not
             // apply on /reload and allowed tools would stay missing.
             this.deps.setToolProfileFilter(this.deps.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.deps.reapplyActiveProfileModelSettings();
-            await this.deps.getResourceLoader().reload({ failOnExtensionErrors: true, deferExtensionDispose: true });
-            resetApiProviders();
-            this.buildRuntime({
+            // Resource discovery must consume this exact settings generation. A second settings read here
+            // could combine profile state from one generation with resources from the next.
+            await this.deps.getResourceLoader().reload({
+                failOnExtensionErrors: true,
+                deferExtensionDispose: true,
+                skipSettingsReload: true,
+            });
+            // Replace the previous extension-owned provider generation before binding the new one. The
+            // bulk refresh also preserves API/OAuth streams for surviving non-extension providers.
+            this.deps.getModelRegistry().unregisterProviders(previousExtensionProviderNames);
+            offReloadErrors = this.buildRuntime({
                 activeToolNames,
                 flagValues: previousFlagValues,
                 includeAllExtensionTools: true,
+                onError: (error) => {
+                    reloadErrors.push(`${error.extensionPath} ${error.event}: ${error.error}`);
+                },
             });
             newRunner = this.deps.getExtensionRunner();
-            const offDoctorErrors = newRunner.onError((error) => {
-                reloadErrors.push(`${error.extensionPath} ${error.event}: ${error.error}`);
-            });
+            // Extensions are now bound and their queued providers/models are registered, so a profile may
+            // safely select a model contributed by an extension granted in that same profile generation.
+            await this.deps.reapplyActiveProfileModelSettings();
+            // Model capability and system-prompt/tool exposure must reflect the newly selected model.
+            this.refreshToolRegistry({ activeToolNames, includeAllExtensionTools: true });
             try {
                 this._doctorReloadRuntime();
                 // Reload starts memory providers fresh; loaded extensions re-register below.
@@ -483,22 +567,24 @@ export class RuntimeBuilder {
                 }
             }
             finally {
-                offDoctorErrors();
+                offReloadErrors?.();
+                offReloadErrors = undefined;
             }
             if (reloadErrors.length > 0) {
                 throw new Error(`Extension reload failed doctor: ${reloadErrors.slice(0, 6).join("; ")}`);
             }
             await emitSessionShutdownEvent(previousRunner, { type: "session_shutdown", reason: "reload" });
             previousRunner.invalidate();
-            this.deps.getResourceLoader().commitReload?.();
+            await this.deps.getResourceLoader().commitReload?.();
             // Re-derive the memory subsystem from the reloaded settings/providers.
             await this.deps.initializeMemory();
         }
         catch (error) {
+            offReloadErrors?.();
             if (newRunner && newRunner !== previousRunner) {
                 newRunner.invalidate("This extension ctx was discarded because reload failed and Pi restored the previous valid runtime.");
             }
-            this.deps.getResourceLoader().rollbackReload?.();
+            await this.deps.getResourceLoader().rollbackReload?.();
             this._restoreReloadRuntimeSnapshot(snapshot);
             throw error;
         }
@@ -526,6 +612,8 @@ export class RuntimeBuilder {
             await this.deps.getExtensionRunner().emitToExtension(ext, { type: "session_shutdown", reason: "unload" });
             // Unregister its providers (keyed by the extension's own path, as registered)
             const runtime = this.deps.getResourceLoader().getExtensions().runtime;
+            const ownedMemoryProviders = runtime.memoryProvidersByExtension.get(ext.path) ?? new Set();
+            const ownedContextMemoryProviders = runtime.contextMemoryProvidersByExtension.get(ext.path) ?? new Set();
             for (const name of runtime.getProvidersForExtension(ext.path)) {
                 runtime.unregisterProvider(name, ext.path);
             }
@@ -542,6 +630,15 @@ export class RuntimeBuilder {
                 includeAllExtensionTools: true,
             });
             previousRunner.invalidate();
+            const memorySnapshot = this.deps.createMemoryReloadSnapshot();
+            this.deps.restoreMemoryReloadSnapshot({
+                ...memorySnapshot,
+                pendingMemoryProviders: memorySnapshot.pendingMemoryProviders.filter((provider) => !ownedMemoryProviders.has(provider)),
+                pendingContextMemoryProviders: memorySnapshot.pendingContextMemoryProviders.filter((provider) => !ownedContextMemoryProviders.has(provider)),
+            });
+            runtime.memoryProvidersByExtension.delete(ext.path);
+            runtime.contextMemoryProvidersByExtension.delete(ext.path);
+            await this.deps.initializeMemory();
             // Notify extensions-changed listeners
             this.deps.notifyExtensionsChanged();
         }
@@ -586,6 +683,9 @@ export class RuntimeBuilder {
             });
             // Run session_start lifecycle for the new extension only
             await this.deps.getExtensionRunner().emitToExtension(extension, { type: "session_start", reason: "load" });
+            // Activate newly registered legacy/context providers immediately. Reinitialization also
+            // refreshes provider tools and preserves all providers owned by existing extensions.
+            await this.deps.initializeMemory();
             // Notify extensions-changed listeners
             this.deps.notifyExtensionsChanged();
         }