@caupulican/pi-adaptative 0.80.71 → 0.80.73

package/dist/core/agent-session.js

@@ -38,6 +38,7 @@ 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 { createCustomMessage } from "./messages.js";
 import { resolveProfileModelSettings } from "./model-resolver.js";
 import { expandPromptTemplate } from "./prompt-templates.js";
 import { stripResourceProfileBlocks } from "./resource-profile-blocks.js";
@@ -127,6 +128,12 @@ export class AgentSession {
     _effectivenessTracker = new EffectivenessTracker();
     /** R8: registry for deployment-supplied gateway channels + schedulers (lifecycle driven by the host runner). */
     _gatewayRegistry = new GatewayRegistry();
+    /** Cache for getSpawnedUsage(), keyed by session entry count (Bug #22 — avoid O(N) per render frame). */
+    _spawnedUsageCache;
+    /** Set on dispose so in-flight background reflection bails instead of writing to a dead session (Bug #21). */
+    _disposed = false;
+    /** Aborts in-flight background reflection completions on dispose (Bug #21). */
+    _reflectionAbort = new AbortController();
     _isChildSession;
     /** Memory providers registered by extensions via pi.registerMemoryProvider, applied on (re)init. */
     _pendingMemoryProviders = [];
@@ -676,6 +683,15 @@ export class AgentSession {
             this.agent.abort();
             // R8: stop any deployment-registered gateway channels / schedulers.
             void this._gatewayRegistry.stop().catch(() => { });
+            // Bug #21: abort any in-flight background reflection so it cannot keep spending tokens or
+            // write memory/skills against this now-disposed session.
+            this._disposed = true;
+            this._reflectionAbort.abort();
+            // Bug #20: clear the hooks this session installed on the shared agent so their closures stop
+            // pinning this (deactivated) session — and all its history/maps — in memory if the agent
+            // instance outlives the session.
+            this.agent.afterToolCall = undefined;
+            this.agent.transformContext = undefined;
         }
         catch {
             // Dispose must succeed even if an abort hook throws.
@@ -1111,7 +1127,11 @@ export class AgentSession {
                     if (recall) {
                         injectedRecall = recall;
                         recallQuery = expandedText;
-                        messages.push({ role: "user", content: [{ type: "text", text: recall }], timestamp: Date.now() });
+                        // Inject as a GC-managed custom context message (role "custom", customType
+                        // "memory_context"), NOT a persisted user message: the semantic-memory context-GC packs
+                        // stale recall pages so they don't accumulate forever (Bug #7), and the transcript index
+                        // only re-reads user/assistant text so recalled snippets can't recirculate (Bug #10).
+                        messages.push(createCustomMessage("memory_context", recall, false, undefined, new Date().toISOString()));
                     }
                 }
                 catch {
@@ -3296,8 +3316,15 @@ export class AgentSession {
         };
         return this.sessionManager.appendCustomEntry(SPAWNED_USAGE_CUSTOM_TYPE, report);
     }
-    /** Aggregate all recorded spawned-usage reports (see {@link addSpawnedUsage}). */
+    /**
+     * Aggregate all recorded spawned-usage reports (see {@link addSpawnedUsage}). Cached by the session
+     * entry count so the interactive footer (which calls this every render frame) is O(1) between turns
+     * instead of an O(N) scan on every keystroke (Bug #22). Recomputes only when entries change.
+     */
     getSpawnedUsage() {
+        const entryCount = this.sessionManager.getEntryCount?.() ?? this.sessionManager.getEntries().length;
+        if (this._spawnedUsageCache?.entryCount === entryCount)
+            return this._spawnedUsageCache.totals;
         let cost = 0;
         let reports = 0;
         for (const entry of this.sessionManager.getEntries()) {
@@ -3309,7 +3336,9 @@ export class AgentSession {
             cost += data.usage.cost.total;
             reports += 1;
         }
-        return { cost, reports };
+        const totals = { cost, reports };
+        this._spawnedUsageCache = { entryCount, totals };
+        return totals;
     }
     /**
      * Run a one-shot LLM completion fully ISOLATED from the main session — the load-bearing
@@ -3383,18 +3412,23 @@ export class AgentSession {
      * is best-effort: a model/parse error yields no writes, never throws into the caller.
      */
     async runReflectionPass(input) {
-        if (this._isChildSession)
+        if (this._isChildSession || this._disposed)
             return null;
         const plan = decideDemand(input.signals);
         if (plan.act === "skip")
             return null;
+        // Bug #21: tie this background pass to the session lifetime. Disposing the session aborts the
+        // in-flight completion (input.signal can add a more specific abort).
+        const signal = input.signal
+            ? AbortSignal.any([input.signal, this._reflectionAbort.signal])
+            : this._reflectionAbort.signal;
         const complete = (systemPrompt, userPrompt) => this.runIsolatedCompletion({
             systemPrompt,
             messages: [{ role: "user", content: [{ type: "text", text: userPrompt }], timestamp: Date.now() }],
             model: input.model,
             thinkingLevel: input.thinkingLevel ?? "low",
             maxTokens: plan.tokenBudget,
-            signal: input.signal,
+            signal,
         });
         const result = await new ReflectionEngine().reflect({
             recentTurnText: input.recentTurnText,
@@ -3404,8 +3438,12 @@ export class AgentSession {
             plan,
             complete,
         });
+        // Bug #21: if the session was disposed while the completion was in flight, do NOT write memory
+        // or skills against the dead session.
+        if (this._disposed)
+            return result;
         for (const write of result.writes) {
-            await this._applyReflectionWrite(write, input.signal);
+            await this._applyReflectionWrite(write, signal);
         }
         // Account the reflection's spend so it surfaces in the footer roll-up (net-token visibility).
         // Idempotent on reportId so a retried/duplicated pass cannot double-count.