@caupulican/pi-adaptative 0.81.40 → 0.81.41

package/dist/core/runtime-builder.js

@@ -46,6 +46,8 @@ import { evaluateSurfaceFitness } from "./model-router/fitness-gate.js";
 import { FitnessStore } from "./models/fitness-store.js";
 import { describeInFlightWorkUnit, getInFlightWorkUnits } from "./reload-blockers.js";
 import { ScoutController } from "./scout-controller.js";
+import { wrapToolWithCredentialExposureGuard } from "./secrets/credential-exposure-guard.js";
+import { SecretVault } from "./secrets/secret-vault.js";
 import { getSessionRole, isWorkerSession, WORKER_FORBIDDEN_TOOLS } from "./session-role.js";
 import { matchesResourceProfilePattern, } from "./settings-manager.js";
 import { createSyntheticSourceInfo } from "./source-info.js";
@@ -65,9 +67,12 @@ import { resolveToCwd } from "./tools/path-utils.js";
 import { createReadTool } from "./tools/read.js";
 import { createRunProcessToolDefinition } from "./tools/run-process.js";
 import { createRunToolkitScriptToolDefinition } from "./tools/run-toolkit-script.js";
+import { createSecretStoreToolDefinition } from "./tools/secret-store.js";
+import { disposePersistentShellSession } from "./tools/shell-session.js";
 import { createTaskStepsToolDefinition } from "./tools/task-steps.js";
 import { dispatchTmuxWorker } from "./tools/tmux-dispatch.js";
 import { createToolDefinitionFromAgentTool } from "./tools/tool-definition-wrapper.js";
+import { disposeWindowsShellState } from "./tools/windows-shell-state.js";
 import { createWorktreeSyncToolDefinition } from "./tools/worktree-sync.js";
 import { createLane } from "./worktree-sync/git-engine.js";
 import { WorktreeLaneGate } from "./worktree-sync/lane-gate.js";
@@ -117,11 +122,22 @@ export class RuntimeBuilder {
     _toolPromptSnippets = new Map();
     _toolPromptGuidelines = new Map();
     _baseToolDefinitions = new Map();
+    /** Exact extensions the owner approved through the live-load API. Discovery never populates this set. */
+    _explicitLiveExtensionPaths = new Set();
     _reloadPromise;
     _reloadRequested = false;
+    _secretVault;
     deps;
     constructor(deps) {
         this.deps = deps;
+        this._secretVault = new SecretVault({
+            agentDir: deps.getAgentDir(),
+            onEnvironmentChanged: () => {
+                const sessionKey = deps.getShellSessionKey();
+                disposePersistentShellSession(sessionKey);
+                disposeWindowsShellState(sessionKey);
+            },
+        });
     }
     /**
      * Resolve the construction and activation policy once for a runtime generation. This is the
@@ -173,9 +189,9 @@ export class RuntimeBuilder {
             resolveScoutModel: async () => resolveScoutModel(this.deps.getModelRegistry(), this.deps.getSettingsManager().getScoutSettings().model, this.deps.getAgentDir(), (model) => this.deps.isModelExhausted(model)),
             getCwd: () => cwd,
             buildReadOnlyTools: (toolCwd) => [
-                createReadTool(toolCwd),
-                createGrepTool(toolCwd, { artifactStore }),
-                createFindTool(toolCwd, { artifactStore }),
+                wrapToolWithCredentialExposureGuard(createReadTool(toolCwd), toolCwd, this._secretVault),
+                wrapToolWithCredentialExposureGuard(createGrepTool(toolCwd, { artifactStore }), toolCwd, this._secretVault),
+                wrapToolWithCredentialExposureGuard(createFindTool(toolCwd, { artifactStore }), toolCwd, this._secretVault),
             ],
             streamFn: this.deps.getAgent().streamFn,
             fileExists: (path) => existsSync(resolveCwdPath(cwd, path)),
@@ -278,9 +294,13 @@ export class RuntimeBuilder {
             definition,
             sourceInfo: createSyntheticSourceInfo(`<builtin:${definition.name}>`, { source: "builtin" }),
         })), runner);
-        const toolRegistry = new Map(wrappedBuiltInTools.map((tool) => [tool.name, tool]));
+        const toolRegistry = new Map(wrappedBuiltInTools.map((tool) => {
+            const guarded = wrapToolWithCredentialExposureGuard(tool, this.deps.getCwd(), this._secretVault);
+            return [guarded.name, guarded];
+        }));
         for (const tool of wrappedExtensionTools) {
-            toolRegistry.set(tool.name, tool);
+            const guarded = wrapToolWithCredentialExposureGuard(tool, this.deps.getCwd(), this._secretVault);
+            toolRegistry.set(guarded.name, guarded);
         }
         this._toolRegistry = toolRegistry;
         const requestedBase = options?.activeToolNames
@@ -453,7 +473,12 @@ export class RuntimeBuilder {
                 shellPath,
                 sessionKey: this.deps.getShellSessionKey(),
                 platform: process.platform,
+                spawnHook: (context) => ({
+                    ...context,
+                    env: { ...context.env, ...this._secretVault.getEnvironmentForCwd(context.cwd) },
+                }),
             },
+            python: { environment: (cwd) => this._secretVault.getEnvironmentForCwd(cwd) },
             grep: { artifactStore: toolArtifactStore },
             find: { artifactStore: toolArtifactStore },
             artifact_retrieve: { artifactStore: toolArtifactStore },
@@ -496,8 +521,8 @@ export class RuntimeBuilder {
             if (toolAccess.allows("goal")) {
                 const goalToolDefinition = createGoalToolDefinition({
                     getGoalState: () => this.deps.getGoalStateSnapshot(),
-                    saveGoalState: (state) => {
-                        this.deps.saveGoalStateSnapshot(state);
+                    saveGoalState: (state, expected) => {
+                        this.deps.saveGoalStateSnapshot(state, expected);
                     },
                     // kind:"tool" evidence refs verify against real session records.
                     hasToolCallId: (toolCallId) => hasAnsweredToolCallOnBranch(this.deps.getSessionManager(), toolCallId),
@@ -564,6 +589,10 @@ export class RuntimeBuilder {
                 });
                 this._baseToolDefinitions.set(askQuestionToolDefinition.name, askQuestionToolDefinition);
             }
+            if (toolAccess.allows("secret_store")) {
+                const secretStoreToolDefinition = createSecretStoreToolDefinition({ vault: this._secretVault });
+                this._baseToolDefinitions.set(secretStoreToolDefinition.name, secretStoreToolDefinition);
+            }
             if (toolAccess.allows("delegate")) {
                 const delegateToolDefinition = createDelegateToolDefinition({
                     startWorkerDelegation: (args) => this.deps.startWorkerDelegation(args),
@@ -692,7 +721,7 @@ export class RuntimeBuilder {
                 extensionsResult.runtime.flagValues.set(name, value);
             }
         }
-        const extensions = this.deps.filterExtensionsForRuntime(extensionsResult.extensions);
+        const extensions = this.deps.filterExtensionsForRuntime(extensionsResult.extensions, this._explicitLiveExtensionPaths);
         const runtimeExtensionPaths = new Set(extensions.map((extension) => extension.path));
         extensionsResult.runtime.pendingProviderRegistrations =
             extensionsResult.runtime.pendingProviderRegistrations.filter((registration) => runtimeExtensionPaths.has(registration.extensionPath));
@@ -809,6 +838,15 @@ export class RuntimeBuilder {
                 deferExtensionDispose: true,
                 skipSettingsReload: true,
             });
+            // A live-load call is an exact session-owned grant. Resource discovery deliberately cannot
+            // recreate it without a profile, so restore only those approved paths into the new runtime
+            // generation before binding it.
+            for (const extensionPath of this._explicitLiveExtensionPaths) {
+                if (this.deps.isExtensionPathAllowed(extensionPath, "explicit") &&
+                    !this.deps.getResourceLoader().getLoadedExtension(extensionPath)) {
+                    await this._importExtension(extensionPath);
+                }
+            }
             // 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);
@@ -874,9 +912,23 @@ export class RuntimeBuilder {
      */
     async unloadExtensionLive(extensionPath) {
         this._assertReloadQuiescent("unload extension");
+        try {
+            await this._unloadExtensionLive(extensionPath, true, true);
+        }
+        catch (error) {
+            await this._recoverLiveExtensionFailure();
+            throw error;
+        }
+    }
+    async _unloadExtensionLive(extensionPath, revokeExplicitGrant, notify) {
         const ext = this.deps.getResourceLoader().getLoadedExtension(extensionPath);
+        const explicitGrantPath = ext?.path ?? extensionPath;
+        const hadExplicitGrant = this._explicitLiveExtensionPaths.has(explicitGrantPath);
+        if (revokeExplicitGrant) {
+            this._explicitLiveExtensionPaths.delete(explicitGrantPath);
+        }
         if (!ext) {
-            return; // Nothing to unload
+            return;
         }
         const previousRunner = this.deps.getExtensionRunner();
         try {
@@ -901,7 +953,7 @@ export class RuntimeBuilder {
                 flagValues: previousFlagValues,
                 includeAllExtensionTools: true,
             });
-            previousRunner.invalidate();
+            previousRunner.retire();
             const memorySnapshot = this.deps.createMemoryReloadSnapshot();
             this.deps.restoreMemoryReloadSnapshot({
                 ...memorySnapshot,
@@ -911,16 +963,13 @@ export class RuntimeBuilder {
             runtime.memoryProvidersByExtension.delete(ext.path);
             runtime.contextMemoryProvidersByExtension.delete(ext.path);
             await this.deps.initializeMemory();
-            // Notify extensions-changed listeners
-            this.deps.notifyExtensionsChanged();
+            if (notify) {
+                this.deps.notifyExtensionsChanged();
+            }
         }
         catch (error) {
-            // Fall back to full reload on error
-            try {
-                await this.reload();
-            }
-            catch {
-                // Suppress nested error; original error will be thrown below
+            if (revokeExplicitGrant && hadExplicitGrant) {
+                this._explicitLiveExtensionPaths.add(explicitGrantPath);
             }
             throw error;
         }
@@ -933,15 +982,26 @@ export class RuntimeBuilder {
      */
     async loadExtensionLive(extensionPath) {
         this._assertReloadQuiescent("load extension");
-        if (!this.deps.getSettingsManager().isResourceAllowedByProfile("extensions", extensionPath)) {
-            throw new Error(`Cannot load extension outside the active resource profile: ${extensionPath}`);
+        this._assertExtensionLoadAllowed(extensionPath, "explicit");
+        try {
+            await this._loadExtensionLive(extensionPath, "explicit", true);
+        }
+        catch (error) {
+            await this._recoverLiveExtensionFailure();
+            throw error;
         }
+    }
+    async _loadExtensionLive(extensionPath, authority, notify) {
         const previousRunner = this.deps.getExtensionRunner();
+        let explicitGrantPath;
+        let hadExplicitGrant = false;
         try {
             // Load the extension with fresh import
-            const { extension, error } = await this.deps.getResourceLoader().loadSingleExtension(extensionPath);
-            if (error || !extension) {
-                throw new Error(error || `Failed to load extension: ${extensionPath}`);
+            const extension = await this._importExtension(extensionPath);
+            if (authority === "explicit") {
+                explicitGrantPath = extension.path;
+                hadExplicitGrant = this._explicitLiveExtensionPaths.has(explicitGrantPath);
+                this._explicitLiveExtensionPaths.add(explicitGrantPath);
             }
             // Rebuild runtime to aggregate tools/commands/handlers/providers
             const activeToolNames = this.deps.getRequestedActiveToolNames() ?? this.deps.getActiveToolNames();
@@ -956,20 +1016,38 @@ export class RuntimeBuilder {
             // 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();
+            previousRunner.retire();
+            if (notify) {
+                this.deps.notifyExtensionsChanged();
+            }
         }
         catch (error) {
-            // Fall back to full reload on error
-            try {
-                await this.reload();
-            }
-            catch {
-                // Suppress nested error; original error will be thrown below
+            if (explicitGrantPath && !hadExplicitGrant) {
+                this._explicitLiveExtensionPaths.delete(explicitGrantPath);
             }
             throw error;
         }
     }
+    async _importExtension(extensionPath) {
+        const { extension, error } = await this.deps.getResourceLoader().loadSingleExtension(extensionPath);
+        if (error || !extension) {
+            throw new Error(error || `Failed to load extension: ${extensionPath}`);
+        }
+        return extension;
+    }
+    _assertExtensionLoadAllowed(extensionPath, authority) {
+        if (!this.deps.isExtensionPathAllowed(extensionPath, authority)) {
+            throw new Error(`Cannot load extension outside the active resource profile: ${extensionPath}`);
+        }
+    }
+    async _recoverLiveExtensionFailure() {
+        try {
+            await this.reload();
+        }
+        catch {
+            // Preserve the original live-operation error; recovery is best effort.
+        }
+    }
     /**
      * Reconcile loaded extensions with the active profile.
      * Loads extensions that should be enabled but aren't, and unloads extensions that shouldn't be.
@@ -980,66 +1058,41 @@ export class RuntimeBuilder {
         try {
             // Get all discoverable extension paths
             const allDiscoverablePaths = await this.deps.getResourceLoader().getDiscoverableExtensionPaths();
-            // Get the target enabled set based on profile filters
-            const targetEnabledSet = new Set();
-            for (const path of allDiscoverablePaths) {
-                if (this.deps.getSettingsManager().isResourceAllowedByProfile("extensions", path)) {
-                    targetEnabledSet.add(path);
-                }
-            }
-            // Get currently loaded set
             const loadedExtensions = this.deps.getResourceLoader().getExtensions().extensions;
-            const loadedSet = new Set();
-            for (const ext of loadedExtensions) {
-                loadedSet.add(ext.path);
-            }
-            // Collect unloads and loads
-            const toUnload = [];
-            const toLoad = [];
-            for (const path of loadedSet) {
-                if (!targetEnabledSet.has(path)) {
-                    toUnload.push(path);
-                }
+            const targetAuthorities = new Map();
+            for (const extension of this.deps.filterExtensionsForRuntime(loadedExtensions, this._explicitLiveExtensionPaths)) {
+                targetAuthorities.set(extension.path, "loaded");
             }
-            for (const path of targetEnabledSet) {
-                if (!loadedSet.has(path)) {
-                    toLoad.push(path);
+            for (const path of this._explicitLiveExtensionPaths) {
+                if (this.deps.isExtensionPathAllowed(path, "explicit")) {
+                    targetAuthorities.set(path, "explicit");
                 }
             }
-            // Apply unloads first, then loads, to minimize churn
-            // Collect errors but continue through all operations
-            const errors = [];
-            for (const path of toUnload) {
-                try {
-                    await this.unloadExtensionLive(path);
-                }
-                catch (error) {
-                    errors.push(error instanceof Error ? error : new Error(String(error)));
+            for (const path of allDiscoverablePaths) {
+                if (this.deps.isExtensionPathAllowed(path, "profile") && !targetAuthorities.has(path)) {
+                    targetAuthorities.set(path, "profile");
                 }
             }
-            for (const path of toLoad) {
-                try {
-                    await this.loadExtensionLive(path);
-                }
-                catch (error) {
-                    errors.push(error instanceof Error ? error : new Error(String(error)));
-                }
+            // Apply unloads first, then loads. A failed mutation stops the generation immediately; the
+            // outer recovery reload restores one coherent runtime instead of compounding partial changes.
+            for (const extension of [...loadedExtensions]) {
+                if (targetAuthorities.has(extension.path) || targetAuthorities.has(extension.resolvedPath))
+                    continue;
+                this._assertReloadQuiescent("reconcile extensions");
+                await this._unloadExtensionLive(extension.path, false, false);
             }
-            // If any errors occurred, throw the first one (already fell back to full reload in load/unload)
-            if (errors.length > 0) {
-                throw errors[0];
+            for (const [path, authority] of targetAuthorities) {
+                if (authority === "loaded" || this.deps.getResourceLoader().getLoadedExtension(path))
+                    continue;
+                this._assertReloadQuiescent("reconcile extensions");
+                this._assertExtensionLoadAllowed(path, authority);
+                await this._loadExtensionLive(path, authority, false);
             }
             // Single notification at the end
             this.deps.notifyExtensionsChanged();
         }
         catch (error) {
-            // Fall back to full reload on error
-            try {
-                await this.reload();
-            }
-            catch {
-                // Suppress nested error; original error will be thrown below
-            }
+            await this._recoverLiveExtensionFailure();
             throw error;
         }
     }