@caupulican/pi-adaptative 0.80.75 → 0.80.77

package/dist/core/agent-session.js

@@ -24,6 +24,7 @@ import { formatNoApiKeyFoundMessage, formatNoModelSelectedMessage } from "./auth
 import { executeBashWithOperations } from "./bash-executor.js";
 import { calculateContextTokens, collectEntriesForBranchSummary, compact, estimateContextTokens, generateBranchSummary, prepareCompaction, shouldCompact, } from "./compaction/index.js";
 import { applyContextGc } from "./context-gc.js";
+import { downgradeReasoning, estimateTurnCostUsd, evaluateCostGuard } from "./cost-guard.js";
 import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
 import { exportSessionToHtml } from "./export-html/index.js";
 import { createToolHtmlRenderer } from "./export-html/tool-renderer.js";
@@ -33,6 +34,7 @@ import { disposeExtensionEventSubscriptions } from "./extensions/loader.js";
 import { emitSessionShutdownEvent } from "./extensions/runner.js";
 import { GatewayRegistry } from "./gateways/channel-provider.js";
 import { decideDemand, ReflectionEngine, } from "./learning/reflection-engine.js";
+import { isPromotedFrontmatter, SkillCurator } from "./learning/skill-curator.js";
 import { EffectivenessTracker } from "./memory/effectiveness-tracker.js";
 import { MemoryManager } from "./memory/memory-manager.js";
 import { FileStoreProvider } from "./memory/providers/file-store.js";
@@ -130,6 +132,12 @@ export class AgentSession {
     _gatewayRegistry = new GatewayRegistry();
     /** Cache for getSpawnedUsage(), keyed by session entry count (Bug #22 — avoid O(N) per render frame). */
     _spawnedUsageCache;
+    /** Latest proactive cost-guard decision (#34), for the host UI to surface. Undefined when disabled. */
+    _lastCostGuardDecision;
+    /** One-shot latch so the cost guard downgrades reasoning once per over-threshold episode, not every call. */
+    _costGuardDowngraded = false;
+    /** Lazily-built skill curator (#32) over `<agentDir>/skills`. */
+    _skillCuratorInstance;
     /** 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). */
@@ -288,9 +296,71 @@ export class AgentSession {
             if (this._extensionRunner.hasHandlers("context")) {
                 finalMessages = await this._extensionRunner.emitContext(currentMessages);
             }
-            return this._applyContextGc(finalMessages, true).messages;
+            const gcMessages = this._applyContextGc(finalMessages, true).messages;
+            this._applyCostGuard(gcMessages);
+            return gcMessages;
         };
     }
+    /**
+     * Proactive per-turn cost guard (#34): estimate the USD cost of the about-to-be-submitted turn and,
+     * when it exceeds the user's ceiling, record a warning decision (for the host UI to surface) and —
+     * if configured to `downgrade` — step reasoning effort down ONCE per over-threshold episode to curb a
+     * runaway billing spike. Disabled by default (`maxTurnUsd<=0`), so it never alters behavior unless the
+     * user opts in. Best-effort: never throws into the turn.
+     */
+    _applyCostGuard(messages) {
+        try {
+            const guard = this.settingsManager.getCostGuardSettings();
+            if (guard.maxTurnUsd <= 0 || !this.model?.cost) {
+                this._lastCostGuardDecision = undefined;
+                return;
+            }
+            const inputTokens = this._estimateCurrentContextTokens(messages);
+            const maxOutputTokens = this.model.maxTokens ?? 4096;
+            const estUsd = estimateTurnCostUsd({ inputTokens, maxOutputTokens, cost: this.model.cost });
+            const decision = evaluateCostGuard(estUsd, { maxTurnUsd: guard.maxTurnUsd, action: guard.action });
+            this._lastCostGuardDecision = decision;
+            if (!decision.over) {
+                this._costGuardDowngraded = false; // back under the ceiling — re-arm the one-shot downgrade
+                return;
+            }
+            if (guard.action === "downgrade" && !this._costGuardDowngraded && this.supportsThinking()) {
+                const next = downgradeReasoning(this.thinkingLevel);
+                if (next !== this.thinkingLevel) {
+                    this.setThinkingLevel(next);
+                    this._costGuardDowngraded = true;
+                }
+            }
+        }
+        catch {
+            // cost guard must never disrupt a turn
+        }
+    }
+    /** Latest cost-guard decision (for the host footer/UI to surface a warning). Undefined if disabled. */
+    getLastCostGuardDecision() {
+        return this._lastCostGuardDecision;
+    }
+    get _skillCurator() {
+        if (!this._skillCuratorInstance) {
+            this._skillCuratorInstance = new SkillCurator(join(this._agentDir, "skills"));
+        }
+        return this._skillCuratorInstance;
+    }
+    /**
+     * Skill curator (#32): PROPOSE (never auto-apply) archival of stale reflection-promoted skills and
+     * consolidation of overlapping ones. The host surfaces these (e.g. a `/curate` command) for approval.
+     */
+    proposeSkillCuration(options) {
+        return this._skillCurator.proposeCuration(Date.now(), options);
+    }
+    /** Archive a promoted skill into `skills/.archive/` (restorable, non-destructive). Returns true if moved. */
+    archivePromotedSkill(name) {
+        return this._skillCurator.archiveSkill(name);
+    }
+    /** Restore a previously-archived promoted skill. Returns true if moved back. */
+    restorePromotedSkill(name) {
+        return this._skillCurator.restoreSkill(name);
+    }
     _installAgentTurnRefresh() {
         const previousPrepareNextTurn = this.agent.prepareNextTurn?.bind(this.agent);
         this.agent.prepareNextTurn = async (signal) => {
@@ -1282,6 +1352,11 @@ export class AgentSession {
             return text; // Unknown or profile-blocked skill, pass through unchanged
         try {
             const content = readFileSync(skill.filePath, "utf-8");
+            // Curator (#32): record use of a reflection-PROMOTED skill so stale ones can later be proposed
+            // for archival. Only promoted skills carry the marker, so hand-authored skills are untouched.
+            if (isPromotedFrontmatter(content)) {
+                this._skillCurator.recordUse(skill.name, Date.now());
+            }
             const body = stripResourceProfileBlocks(stripFrontmatter(content)).trim();
             const skillBlock = `<skill name="${skill.name}" location="${skill.filePath}">\nReferences are relative to ${skill.baseDir}.\n\n${body}\n</skill>`;
             return args ? `${skillBlock}\n\n${args}` : skillBlock;
@@ -3405,7 +3480,7 @@ export class AgentSession {
         const options = {
             maxTokens: opts.maxTokens,
             signal: opts.signal,
-            cacheRetention: "none",
+            cacheRetention: opts.cacheRetention ?? "none",
         };
         // pi-ai's `reasoning` option does not include "off" (that's the provider default already).
         if (thinkingLevel !== "off") {
@@ -3465,6 +3540,9 @@ export class AgentSession {
             thinkingLevel: input.thinkingLevel ?? "low",
             maxTokens: plan.tokenBudget,
             signal,
+            // The reflection system prompt is static (#33) — let the provider cache the prefix so
+            // repeated passes only pay for the variable tail.
+            cacheRetention: "short",
         });
         const result = await new ReflectionEngine().reflect({
             recentTurnText: input.recentTurnText,
@@ -3555,7 +3633,9 @@ export class AgentSession {
                 return; // do not overwrite an existing skill
             mkdirSync(dir, { recursive: true });
             const safeDescription = description.replace(/[\r\n]+/g, " ").trim();
-            const content = `---\nname: ${name}\ndescription: ${safeDescription}\n---\n\n<!-- Auto-generated by the reflection engine (R7 memory-to-behavior). Review and refine. -->\n\n${body.trim()}\n`;
+            // `promoted: true` marks this as reflection-generated so the curator (#32) can lifecycle-manage
+            // it (archive/consolidate) WITHOUT ever touching hand-authored user skills.
+            const content = `---\nname: ${name}\ndescription: ${safeDescription}\npromoted: true\n---\n\n<!-- Auto-generated by the reflection engine (R7 memory-to-behavior). Review and refine. -->\n\n${body.trim()}\n`;
             writeFileSync(file, content, "utf-8");
         }
         catch {