@caupulican/pi-adaptative 0.90.6 → 0.90.11

package/dist/core/agent-session.js

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
-import { basename, dirname } from "node:path";
-import { projectToolsForProvider } from "@caupulican/pi-agent-core";
+import { basename } from "node:path";
+import { NATIVE_TOOL_PROTOCOL_RESIDUE_ERROR, projectToolsForProvider } from "@caupulican/pi-agent-core";
 import { AgentBusyError } from "@caupulican/pi-agent-core/agent";
 import { compactToolResultDetailsForRetention } from "@caupulican/pi-agent-core/message-retention";
 import { createCustomMessage } from "@caupulican/pi-agent-core/messages";
@@ -22,12 +22,15 @@ import { CompactionSupport } from "./compaction-support.js";
 import { buildContextCompositionReport, formatContextCompositionDashboard, } from "./context/context-composition.js";
 import { ContextPipeline } from "./context-pipeline.js";
 import { downgradeReasoning, estimateTurnCostUsd, evaluateCostGuard } from "./cost-guard.js";
-import { appendWorkerClaimSnapshot, getWorkerClaimSnapshots } from "./delegation/session-worker-claim.js";
+import { appendWorkerClaimSnapshot, getLatestWorkerClaimSnapshot, getWorkerClaimSnapshots, } from "./delegation/session-worker-claim.js";
+import { DurableCustomMessageTurnController } from "./durable-custom-message-turn-controller.js";
+import { ExtensionBindingController } from "./extension-binding-controller.js";
 import { FailureCorpusRecorder } from "./failure-corpus.js";
 import { ForegroundRecoveryController } from "./foreground-recovery-controller.js";
 import { ForegroundTerminalHandoffController } from "./foreground-terminal-handoff-controller.js";
 import { GatewayRegistry } from "./gateways/channel-provider.js";
 import { GoalSessionController } from "./goals/goal-session-controller.js";
+import { parseExplicitGoalStartAuthority } from "./goals/natural-language-goal.js";
 import { constrainStreamIdleToHttpTimeout } from "./http-dispatcher.js";
 import { HumanInputController } from "./human-input-controller.js";
 import { appendLearningDecisionSnapshot, getLearningDecisionSnapshots } from "./learning/session-learning-decision.js";
@@ -114,6 +117,8 @@ export class AgentSession {
         this._pendingNextTurnMessages = [];
         this._streamingPromptSubmissionTail = Promise.resolve();
         this._unboundToolGrantWarnings = [];
+        /** Delegate provider-prompt-guideline bounding diagnostics (root-session delegate tool only). */
+        this._delegatePromptGuidelineWarnings = [];
         this._branchSummaryAbortController = undefined;
         this._turnIndex = 0;
         /** Per-agent persistent shell session identity: stable across runtime reloads, disposed with the session. */
@@ -211,6 +216,7 @@ export class AgentSession {
                 else if (event.message.role === "custom") {
                     // Persist as CustomMessageEntry
                     this.sessionManager.appendCustomMessageEntry(event.message.customType, event.message.content, event.message.display, event.message.details);
+                    this._durableCustomMessageTurns.notePersisted(event.message);
                     messagePersisted = true;
                 }
                 else if (event.message.role === "user" ||
@@ -224,9 +230,13 @@ export class AgentSession {
                 // Track the response for ordered retry/failover/compaction handling after agent_end.
                 if (event.message.role === "assistant") {
                     const assistantMsg = event.message;
+                    this._goals.recordExecutionUsage(assistantMsg);
                     if (messagePersisted) {
                         this._pipeline.observeProviderUsage(this.agent.state.messages, assistantMsg);
                     }
+                    if (assistantMsg.errorMessage?.startsWith(`${NATIVE_TOOL_PROTOCOL_RESIDUE_ERROR}:`)) {
+                        this._goals.markProtocolFailureBlocked(assistantMsg.errorMessage);
+                    }
                     this._foregroundRecovery.observeAssistant(assistantMsg);
                 }
             }
@@ -553,6 +563,8 @@ export class AgentSession {
             agent: this.agent,
             compaction: this._compaction,
             context: providerRequestContext,
+            admitGoalRequest: () => this._goals.admitProviderRequest(),
+            shouldStopGoalExecutionAfterTurn: () => this._goals.hasExecutionLeaseCrossedBudgetLimit(),
         });
         this._toolRecoveryLogger = new ToolRecoveryLogger({
             enabled: toolRepairSettings.logging,
@@ -578,11 +590,19 @@ export class AgentSession {
                 await this._drainQueuedExtensionCommands();
             },
         });
+        this._durableCustomMessageTurns = new DurableCustomMessageTurnController({
+            foreground: this._foregroundRecovery,
+            goals: this._goals,
+        });
         this._terminalHandoffs = new ForegroundTerminalHandoffController({
             foreground: this._foregroundRecovery,
             isDisposed: () => this._disposed,
+            getGoalStateSnapshot: () => this.getGoalStateSnapshot(),
             workerInputsWillWakeParent: (workerRequestIds) => this._humanInput.workerInputsWillWakeParent(workerRequestIds),
+            getWorkerClaimSnapshot: (laneId) => getLatestWorkerClaimSnapshot(getActiveSessionBranchEntries(this.sessionManager), laneId),
+            startCustomMessageTurn: (message, lease, goalId) => this._durableCustomMessageTurns.start(message, lease, goalId),
             sendCustomMessage: (message, options, lease) => this._sendCustomMessage(message, options, lease),
+            warn: (message) => this._emit({ type: "warning", message }),
         });
         this._modelRouter = new ModelRouterController({
             getAgent: () => this.agent,
@@ -693,15 +713,18 @@ export class AgentSession {
                 this._unboundToolGrantWarnings = warnings;
             },
             getUnboundToolGrantWarnings: () => this._unboundToolGrantWarnings,
+            setDelegatePromptGuidelineWarnings: (warnings) => {
+                this._delegatePromptGuidelineWarnings = warnings;
+            },
             createProfileFilterReloadSnapshot: () => this._profileFilter.createReloadSnapshot(),
             restoreProfileFilterReloadSnapshot: (snapshot) => this._profileFilter.restoreReloadSnapshot(snapshot),
             getActiveToolNames: () => this.getActiveToolNames(),
             setActiveToolsByName: (toolNames) => this.setActiveToolsByName(toolNames),
             normalizePromptSnippet: (text) => this._normalizePromptSnippet(text),
             normalizePromptGuidelines: (guidelines) => this._normalizePromptGuidelines(guidelines),
-            bindExtensionCore: (runner) => this._bindExtensionCore(runner),
-            applyExtensionBindings: (runner) => this._applyExtensionBindings(runner),
-            extendResourcesFromExtensions: (reason) => this.extendResourcesFromExtensions(reason),
+            bindExtensionCore: (runner) => this._extensionBinding.bindExtensionCore(runner),
+            applyExtensionBindings: (runner) => this._extensionBinding.applyExtensionBindings(runner),
+            extendResourcesFromExtensions: (reason) => this._extensionBinding.extendResourcesFromExtensions(reason),
             reapplyActiveProfileModelSettings: () => this._profileFilter.reapplyActiveProfileModelSettings(),
             notifyExtensionsChanged: () => this._notifyExtensionsChanged(),
             getToolArtifactStore: () => this._getToolArtifactStore(),
@@ -715,6 +738,7 @@ export class AgentSession {
             initializeMemory: () => this._memory.initialize(),
             getGoalStateSnapshot: () => this.getGoalStateSnapshot(),
             saveGoalStateSnapshot: (state) => this.saveGoalStateSnapshot(state),
+            authorizeGoalStartFromTool: (input) => this._goals.authorizeStartFromTool(input),
             getTaskStepsStateSnapshot: () => this.getTaskStepsStateSnapshot(),
             saveTaskStepsStateSnapshot: (state) => this.saveTaskStepsStateSnapshot(state),
             getContextGcReport: (messages) => this.getContextGcReport(messages),
@@ -743,6 +767,67 @@ export class AgentSession {
                 this._localRuntimeController.reconcile(this._collectEligibleLocalModelsForReconcile());
             },
         });
+        this._extensionBinding = new ExtensionBindingController({
+            getAgent: () => this.agent,
+            getExtensionRunner: () => this._extensionRunner,
+            getSessionStartEvent: () => this._sessionStartEvent,
+            getCwd: () => this._cwd,
+            getResourceLoader: () => this._resourceLoader,
+            getSessionManager: () => this.sessionManager,
+            getSettingsManager: () => this.settingsManager,
+            getModelRegistry: () => this._modelRegistry,
+            getModel: () => this.model,
+            getActiveToolNames: () => this.getActiveToolNames(),
+            getAllTools: () => this.getAllTools(),
+            setActiveToolsByName: (toolNames) => this.setActiveToolsByName(toolNames),
+            refreshToolRegistry: () => this._refreshToolRegistry(),
+            rebuildSystemPrompt: (toolNames) => this._rebuildSystemPrompt(toolNames),
+            setBaseSystemPrompt: (prompt) => {
+                this._baseSystemPrompt = prompt;
+            },
+            getPromptTemplates: () => this.promptTemplates,
+            getThinkingLevel: () => this.thinkingLevel,
+            setThinkingLevel: (level) => this.setThinkingLevel(level),
+            setModel: (model) => this.setModel(model),
+            sendCustomMessage: (message, options) => this.sendCustomMessage(message, options),
+            sendUserMessage: (content, options) => this.sendUserMessage(content, options),
+            setSessionName: (name) => this.setSessionName(name),
+            registerMemoryProvider: (provider) => this.registerMemoryProvider(provider),
+            registerContextMemoryProvider: (provider) => this.registerContextMemoryProvider(provider),
+            addSpawnedUsage: (usage, opts) => this.addSpawnedUsage(usage, opts),
+            recordManagedLane: (event) => this._backgroundLanes.recordManagedLane(event),
+            isForegroundBusy: () => this._foregroundRecovery.isBusy,
+            getPendingMessageCount: () => this.pendingMessageCount,
+            isStreaming: () => this.isStreaming,
+            isCompacting: () => this.isCompacting,
+            getContextUsage: () => this.getContextUsage(),
+            compactForExtension: (options) => this.compactForExtension(options),
+            reload: () => this.reload(),
+            abort: () => this.abort(),
+            getSystemPrompt: () => this.systemPrompt,
+            getExtensionCommandContextActions: () => this._extensionCommandContextActions,
+            refreshCurrentModelFromRegistry: () => this._refreshCurrentModelFromRegistry(),
+            initializeMemory: () => this._memory.initialize(),
+            getExtensionUIContext: () => this._extensionUIContext,
+            setExtensionUIContext: (uiContext) => {
+                this._extensionUIContext = uiContext;
+            },
+            getExtensionMode: () => this._extensionMode,
+            setExtensionMode: (mode) => {
+                this._extensionMode = mode;
+            },
+            setExtensionCommandContextActions: (actions) => {
+                this._extensionCommandContextActions = actions;
+            },
+            getExtensionShutdownHandler: () => this._extensionShutdownHandler,
+            setExtensionShutdownHandler: (handler) => {
+                this._extensionShutdownHandler = handler;
+            },
+            getExtensionErrorListener: () => this._extensionErrorListener,
+            setExtensionErrorListener: (listener) => {
+                this._extensionErrorListener = listener;
+            },
+        });
         this._analytics = new SessionAnalytics({
             getState: () => this.state,
             getMessages: () => this.messages,
@@ -1260,6 +1345,7 @@ export class AgentSession {
                 ...this._profileFilter.profileDeniedResourceObservations(),
                 ...this._profileFilter.getInertExtensionWarnings(),
                 ...this._unboundToolGrantWarnings,
+                ...this._delegatePromptGuidelineWarnings,
                 // Auto-built per-turn foreground envelope (observe-only; not enforced). Falls back to a
                 // live preview when no turn has run yet so /context always shows the current scope.
                 formatForegroundEnvelopeObservation(this._currentForegroundEnvelope ?? this._buildForegroundEnvelopeFromState()),
@@ -1281,8 +1367,8 @@ export class AgentSession {
             this._toolSelection.formatTimingReport(),
         ].join("\n\n");
     }
-    async flushToolRecoveryLogsForTests(timeoutMs = 1000) {
-        await this._toolRecoveryLogger.flush(timeoutMs);
+    async flushToolRecoveryLogsForTests() {
+        await this._toolRecoveryLogger.drain();
     }
     removeToolRepairRule(model, mode) {
         return this._toolProtocol.removeRepairRule(model, mode);
@@ -1668,6 +1754,7 @@ export class AgentSession {
             this.agent.subscribeToolCallHandoffRequest = undefined;
         });
         safely(() => this._extensionRunner.invalidate());
+        track(() => this._resourceLoader.dispose?.() ?? Promise.resolve());
         safely(() => this._disconnectFromAgent());
         this._eventListeners = [];
         // Let an aborted in-flight reflection reach its terminal state, then flush session-owned write
@@ -2009,6 +2096,8 @@ export class AgentSession {
         // response, whether the agent actually used the recalled context.
         let injectedRecall = "";
         let recallQuery = "";
+        let admittedGoalId = options?.goalExecutionId;
+        let goalToolStartAuthority;
         try {
             // Handle extension commands first. Programmatic extension messages may opt
             // into command handling; if the agent is currently streaming, queue the
@@ -2050,7 +2139,10 @@ export class AgentSession {
                 expandedText = expandPromptTemplate(expandedText, [...this.promptTemplates]);
             }
             if (!options?.internalContextType) {
+                goalToolStartAuthority = parseExplicitGoalStartAuthority(expandedText);
                 const admission = this._goals.admitExplicitChatGoal(expandedText);
+                if (admission.status === "started")
+                    admittedGoalId = admission.state.goalId;
                 if (admission.status === "unfinished_goal_exists") {
                     this._emit({
                         type: "warning",
@@ -2240,12 +2332,19 @@ export class AgentSession {
             return;
         }
         preflightResult?.(true);
+        const goalExecutionLease = this._goals.beginExecution(admittedGoalId, {
+            adoptNewGoal: goalToolStartAuthority !== undefined,
+            provisionalTokenBudget: goalToolStartAuthority?.tokenBudget,
+        });
+        this._goals.setStartAuthority(goalToolStartAuthority);
         try {
             this._toolProtocol.resetTurnState();
             await this._modelRouter.runRoutedTurn(messages, routedTurnModel, routedTurnRouteDecision);
             this._toolProtocol.recordParseOutcomeFromLastAssistant();
         }
         finally {
+            this._goals.setStartAuthority(undefined);
+            this._goals.endExecution(goalExecutionLease);
             // Normally consumed by the authoritative message_start. If execution failed before that
             // event, do not retain the early-painted message identity indefinitely.
             if (userMessage)
@@ -2684,79 +2783,9 @@ export class AgentSession {
     get autoCompactionEnabled() {
         return this.settingsManager.getCompactionEnabled();
     }
+    /** Public entry point delegating to {@link ExtensionBindingController.bindExtensions}. */
     async bindExtensions(bindings) {
-        if (bindings.uiContext !== undefined) {
-            this._extensionUIContext = bindings.uiContext;
-        }
-        if (bindings.mode !== undefined) {
-            this._extensionMode = bindings.mode;
-        }
-        if (bindings.commandContextActions !== undefined) {
-            this._extensionCommandContextActions = bindings.commandContextActions;
-        }
-        if (bindings.abortHandler !== undefined) {
-            this._extensionAbortHandler = bindings.abortHandler;
-        }
-        if (bindings.shutdownHandler !== undefined) {
-            this._extensionShutdownHandler = bindings.shutdownHandler;
-        }
-        if (bindings.onError !== undefined) {
-            this._extensionErrorListener = bindings.onError;
-        }
-        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._memory.initialize();
-    }
-    async extendResourcesFromExtensions(reason) {
-        if (!this._extensionRunner.hasHandlers("resources_discover")) {
-            return;
-        }
-        const { skillPaths, promptPaths, themePaths } = await this._extensionRunner.emitResourcesDiscover(this._cwd, reason);
-        if (skillPaths.length === 0 && promptPaths.length === 0 && themePaths.length === 0) {
-            return;
-        }
-        const extensionPaths = {
-            skillPaths: this.buildExtensionResourcePaths(skillPaths),
-            promptPaths: this.buildExtensionResourcePaths(promptPaths),
-            themePaths: this.buildExtensionResourcePaths(themePaths),
-        };
-        this._resourceLoader.extendResources(extensionPaths);
-        this._baseSystemPrompt = this._rebuildSystemPrompt(this.getActiveToolNames());
-        this.agent.state.systemPrompt = this._baseSystemPrompt;
-    }
-    buildExtensionResourcePaths(entries) {
-        return entries.map((entry) => {
-            const source = this.getExtensionSourceLabel(entry.extensionPath);
-            const baseDir = entry.extensionPath.startsWith("<") ? undefined : dirname(entry.extensionPath);
-            return {
-                path: entry.path,
-                metadata: {
-                    source,
-                    scope: "temporary",
-                    origin: "top-level",
-                    baseDir,
-                },
-            };
-        });
-    }
-    getExtensionSourceLabel(extensionPath) {
-        if (extensionPath.startsWith("<")) {
-            return `extension:${extensionPath.replace(/[<>]/g, "")}`;
-        }
-        const base = basename(extensionPath);
-        const name = base.replace(/\.(ts|js)$/, "");
-        return `extension:${name}`;
-    }
-    _applyExtensionBindings(runner) {
-        runner.setUIContext(this._extensionUIContext);
-        runner.setMode(this._extensionMode);
-        runner.bindCommandContext(this._extensionCommandContextActions);
-        this._extensionErrorUnsubscriber?.();
-        this._extensionErrorUnsubscriber = this._extensionErrorListener
-            ? runner.onError(this._extensionErrorListener)
-            : undefined;
+        return this._extensionBinding.bindExtensions(bindings);
     }
     _refreshCurrentModelFromRegistry() {
         const currentModel = this.model;
@@ -2769,123 +2798,6 @@ export class AgentSession {
         }
         this.agent.state.model = refreshedModel;
     }
-    _bindExtensionCore(runner) {
-        const getCommands = () => {
-            const extensionCommands = runner.getRegisteredCommands().map((command) => ({
-                name: command.invocationName,
-                description: command.description,
-                source: "extension",
-                sourceInfo: command.sourceInfo,
-            }));
-            const templates = this.promptTemplates.map((template) => ({
-                name: template.name,
-                description: template.description,
-                source: "prompt",
-                sourceInfo: template.sourceInfo,
-            }));
-            const skills = this._resourceLoader.getActiveSkills().map((skill) => ({
-                name: `skill:${skill.name}`,
-                description: skill.description,
-                source: "skill",
-                sourceInfo: skill.sourceInfo,
-            }));
-            return [...extensionCommands, ...templates, ...skills];
-        };
-        runner.bindCore({
-            sendMessage: (message, options) => {
-                this.sendCustomMessage(message, options).catch((err) => {
-                    runner.emitError({
-                        extensionPath: "<runtime>",
-                        event: "send_message",
-                        error: err instanceof Error ? err.message : String(err),
-                    });
-                });
-            },
-            sendUserMessage: (content, options) => {
-                this.sendUserMessage(content, options).catch((err) => {
-                    runner.emitError({
-                        extensionPath: "<runtime>",
-                        event: "send_user_message",
-                        error: err instanceof Error ? err.message : String(err),
-                    });
-                });
-            },
-            appendEntry: (customType, data) => {
-                this.sessionManager.appendCustomEntry(customType, data);
-            },
-            setSessionName: (name) => {
-                this.setSessionName(name);
-            },
-            getSessionName: () => {
-                return this.sessionManager.getSessionName();
-            },
-            setLabel: (entryId, label) => {
-                this.sessionManager.appendLabelChange(entryId, label);
-            },
-            getActiveTools: () => this.getActiveToolNames(),
-            getAllTools: () => this.getAllTools(),
-            setActiveTools: (toolNames) => this.setActiveToolsByName(toolNames),
-            refreshTools: () => this._refreshToolRegistry(),
-            getCommands,
-            setModel: async (model) => {
-                if (!this.modelRegistry.hasConfiguredAuth(model))
-                    return false;
-                await this.setModel(model);
-                return true;
-            },
-            getThinkingLevel: () => this.thinkingLevel,
-            setThinkingLevel: (level) => this.setThinkingLevel(level),
-            getExternalResourceRoots: () => this.settingsManager.getEffectiveExternalResourceRoots(),
-            registerMemoryProvider: (provider) => this.registerMemoryProvider(provider),
-            registerContextMemoryProvider: (provider) => this.registerContextMemoryProvider(provider),
-            reportSpawnedUsage: (usage, opts) => {
-                this.addSpawnedUsage(usage, opts);
-            },
-            reportManagedLane: (event) => {
-                this._backgroundLanes.recordManagedLane(event);
-            },
-        }, {
-            getModel: () => this.model,
-            isIdle: () => !this._foregroundRecovery.isBusy,
-            getSignal: () => this.agent.signal,
-            abort: () => {
-                if (this._extensionAbortHandler) {
-                    this._extensionAbortHandler();
-                    return;
-                }
-                void this.abort();
-            },
-            hasPendingMessages: () => this.pendingMessageCount > 0,
-            shutdown: () => {
-                this._extensionShutdownHandler?.();
-            },
-            getContextUsage: () => this.getContextUsage(),
-            compact: (options) => this.compactForExtension(options),
-            reload: () => {
-                if (this.isStreaming) {
-                    return Promise.reject(new Error("ctx.reload() cannot run while the agent is streaming or a tool call is active. Wait for ctx.isIdle(), queue a follow-up /reload, or use an idle command/event handler so hot reload cannot destabilize the UI."));
-                }
-                if (this.isCompacting) {
-                    return Promise.reject(new Error("ctx.reload() cannot run during context compaction or branch summarization. Let compaction finish before reloading so the session tree and UI remain stable."));
-                }
-                const actions = this._extensionCommandContextActions;
-                if (!actions) {
-                    return this.reload();
-                }
-                return actions.reload();
-            },
-            getSystemPrompt: () => this.systemPrompt,
-        }, {
-            registerProvider: (name, config) => {
-                this._modelRegistry.registerProvider(name, config);
-                this._refreshCurrentModelFromRegistry();
-            },
-            unregisterProvider: (name) => {
-                this._modelRegistry.unregisterProvider(name);
-                this._refreshCurrentModelFromRegistry();
-            },
-        });
-    }
     /** Register a memory provider contributed by an extension; applied on the next memory (re)init. */
     registerMemoryProvider(provider) {
         this._memory.registerMemoryProvider(provider);
@@ -3042,14 +2954,9 @@ export class AgentSession {
         return this._goals.getState();
     }
     /**
-     * Persist one submitted continuation pass's exact turn/wall-clock/token/spend contribution onto the active
-     * goal's durable cumulative accounting (see `GoalState.continuationTurnsUsed` et al.). This is the
-     * "persistence dep" `GoalLoopController` calls once per pass actually submitted — it, not the
-     * loop controller, is where usage gets attributed: it scans only assistant messages appended on
-     * the active branch after the pass's captured cursor. Compaction cannot erase or reattribute that
-     * append-only interval, and unrelated foreground turns outside the interval are excluded.
-     * A no-op when no goal state exists (defensive — in practice this is only ever called right
-     * after a pass the loop already confirmed was submitted against an active goal).
+     * Persist one submitted continuation pass's turn and active-wall-clock telemetry. Provider usage
+     * is charged separately at every assistant-response boundary under an identity-bound goal lease.
+     * A no-op when no goal state exists.
      */
     recordGoalContinuationPass(pass) {
         this._goals.recordContinuationPass(pass);