@caupulican/pi-adaptative 0.80.58 → 0.80.60

package/dist/modes/interactive/interactive-mode.js

@@ -622,7 +622,7 @@ export class InteractiveMode {
         this.skillCommands.clear();
         const skillCommandList = [];
         if (this.settingsManager.getEnableSkillCommands()) {
-            for (const skill of this.session.resourceLoader.getSkills().skills) {
+            for (const skill of this.session.resourceLoader.getActiveSkills()) {
                 const commandName = `skill:${skill.name}`;
                 this.skillCommands.set(commandName, skill.filePath);
                 skillCommandList.push({
@@ -1316,7 +1316,7 @@ export class InteractiveMode {
                 const contextCompactList = formatCompactList(contextFiles.map((contextFile) => this.formatContextPath(contextFile.path)), { sort: false });
                 addLoadedSection("Context", contextCompactList, contextList);
             }
-            const skills = skillsResult.skills;
+            const skills = this.session.resourceLoader.getActiveSkills();
             if (skills.length > 0) {
                 const groups = this.buildScopeGroups(skills.map((skill) => ({ path: skill.filePath, sourceInfo: skill.sourceInfo })));
                 const skillList = this.formatScopeGroups(groups, {
@@ -2756,7 +2756,12 @@ export class InteractiveMode {
                 break;
             }
             case "agent_end":
-                if (!this.maybeStartAutoLearn()) {
+                // Native in-process reflection fully replaces the subprocess learning paths
+                // (continuous-learning AND autonomy-review) when enabled; otherwise fall back to legacy.
+                if (this.isNativeReflectionEnabled()) {
+                    this.maybeRunNativeReflection(event.messages);
+                }
+                else if (!this.maybeStartAutoLearn()) {
                     this.maybeStartAutonomyReview(event.messages);
                 }
                 if (this.settingsManager.getShowTerminalProgress()) {
@@ -4789,6 +4794,63 @@ export class InteractiveMode {
         }
         return { ...base, shouldRun: false, reason: "reflection thresholds not met" };
     }
+    /**
+     * Native reflection (R2) is the in-process replacement for the buggy `continuous-learning`
+     * subprocess. It runs when auto-learn is enabled and is not killed via `PI_NATIVE_REFLECTION=0`.
+     */
+    isNativeReflectionEnabled() {
+        if (process.env.PI_NATIVE_REFLECTION === "0")
+            return false;
+        if (process.env.PI_AUTO_LEARN_CHILD === "1")
+            return false;
+        return this.getEffectiveAutoLearnSettings().enabled;
+    }
+    /** Heuristic: does the user's turn text read like a correction/steer worth learning from? */
+    hasCorrectionSignal(userText) {
+        return /\b(next time|for future|from now on|remember this|don't|do not|avoid|instead|you should|should have|you forgot|you missed|not what i asked|wrong again)\b/i.test(userText);
+    }
+    /**
+     * End-of-loop native reflection: demand-gate the just-finished turn (zero-I/O) and, when
+     * warranted, run the in-process {@link AgentSession.runReflectionPass} as a fire-and-forget
+     * background microtask. No subprocess, no blocking of the UI.
+     */
+    maybeRunNativeReflection(messages) {
+        if (!this.isNativeReflectionEnabled())
+            return;
+        const settings = this.getEffectiveAutoLearnSettings();
+        const toolCallCount = this.countAgentToolCalls(messages);
+        const contextPercent = this.session.getContextUsage()?.percent ?? 0;
+        const contextHeadroomPct = Math.max(0, 100 - contextPercent);
+        const userText = messages
+            .filter((m) => String(m.role ?? "") === "user")
+            .map((m) => this.getAgentMessagePlainText(m))
+            .join("\n");
+        const hadCorrection = this.hasCorrectionSignal(userText);
+        // A correction is worth learning from even on a short turn; otherwise require a complex turn.
+        const trigger = hadCorrection
+            ? "corrective"
+            : toolCallCount >= Math.max(1, settings.complexTaskToolCalls ?? 12)
+                ? "complex"
+                : "none";
+        if (trigger === "none")
+            return;
+        const recentTurnText = messages
+            .map((m) => `${String(m.role ?? "")}: ${this.getAgentMessagePlainText(m)}`.trim())
+            .filter(Boolean)
+            .join("\n");
+        // Stable per-turn id so a duplicate scheduling/retry can't double-count the reflection cost.
+        const lastId = messages[messages.length - 1]?.id;
+        const reportId = lastId ? `reflection:${lastId}` : undefined;
+        void this.session
+            .runReflectionPass({
+            signals: { trigger, toolCallCount, hadCorrection, contextHeadroomPct, usefulLately: 0 },
+            recentTurnText,
+            reportId,
+        })
+            .catch(() => {
+            // best-effort background learning; never disrupt the session
+        });
+    }
     maybeStartAutoLearn() {
         if (process.env.PI_AUTO_LEARN_CHILD === "1")
             return false;
@@ -4964,7 +5026,10 @@ export class InteractiveMode {
                 thinkingLevel: this.session.thinkingLevel,
                 availableThinkingLevels: this.session.getAvailableThinkingLevels(),
                 currentTheme: this.settingsManager.getTheme() || "dark",
-                availableThemes: getAvailableThemes(),
+                // The picker offers only themes the active profile permits (no-bypass). The theme
+                // registry/renderer keeps the full set, so an already-applied theme still renders
+                // even if the profile would block re-selecting it.
+                availableThemes: getAvailableThemes().filter((name) => this.settingsManager.isResourceAllowedByProfile("themes", name)),
                 hideThinkingBlock: this.hideThinkingBlock,
                 collapseChangelog: this.settingsManager.getCollapseChangelog(),
                 enableInstallTelemetry: this.settingsManager.getEnableInstallTelemetry(),