@caupulican/pi-adaptative 0.80.86 → 0.80.89

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

@@ -14,7 +14,10 @@ import lockfile from "proper-lockfile";
 import { APP_NAME, APP_TITLE, getAgentDir, getAuthPath, getDebugLogPath, getDocsPath, getShareViewerUrl, VERSION, } from "../../config.js";
 import { parseSkillBlock } from "../../core/agent-session.js";
 import { SessionImportFileNotFoundError } from "../../core/agent-session-runtime.js";
+import { formatAutonomyDiagnostics } from "../../core/autonomy/status.js";
+import { readAutoLearnSessionIdFromFile, reportCompletedAutoLearnUsageHelper } from "../../core/cost/session-usage.js";
 import { FooterDataProvider } from "../../core/footer-data-provider.js";
+import { DEFAULT_GOAL_CONTINUE_MAX_STALL_TURNS, DEFAULT_GOAL_CONTINUE_MAX_TURNS, DEFAULT_GOAL_CONTINUE_MAX_WALL_CLOCK_MINUTES, MAX_GOAL_CONTINUE_MAX_STALL_TURNS, MAX_GOAL_CONTINUE_MAX_TURNS, MAX_GOAL_CONTINUE_MAX_WALL_CLOCK_MINUTES, } from "../../core/goals/goal-continuation-defaults.js";
 import { configureHttpDispatcher, formatHttpIdleTimeoutMs } from "../../core/http-dispatcher.js";
 import { KeybindingsManager } from "../../core/keybindings.js";
 import { createCompactionSummaryMessage } from "../../core/messages.js";
@@ -22,6 +25,7 @@ import { cliProviderAliases, defaultModelPerProvider, findExactModelReferenceMat
 import { DefaultPackageManager } from "../../core/package-manager.js";
 import { BUILT_IN_PROVIDER_DISPLAY_NAMES } from "../../core/provider-display-names.js";
 import { getPendingReloadBlockers } from "../../core/reload-blockers.js";
+import { formatModelFitnessReport } from "../../core/research/model-fitness.js";
 import { resourceProfileSettingsChangedKinds } from "../../core/resource-profile-equality.js";
 import { formatMissingSessionCwdPrompt, MissingSessionCwdError } from "../../core/session-cwd.js";
 import { isAutoLearnSessionId, SessionManager } from "../../core/session-manager.js";
@@ -55,6 +59,7 @@ import { EarendilAnnouncementComponent } from "./components/earendil-announcemen
 import { ExtensionEditorComponent } from "./components/extension-editor.js";
 import { ExtensionInputComponent } from "./components/extension-input.js";
 import { ExtensionSelectorComponent } from "./components/extension-selector.js";
+import { FitnessRoleSelectorComponent } from "./components/fitness-role-selector.js";
 import { FooterComponent } from "./components/footer.js";
 import { formatKeyText, keyDisplayText, keyHint, keyText, rawKeyHint } from "./components/keybinding-hints.js";
 import { LoginDialogComponent } from "./components/login-dialog.js";
@@ -214,32 +219,6 @@ function removeAutoLearnArtifactPath(filePath, root) {
         return false;
     }
 }
-function readAutoLearnSessionIdFromFile(filePath) {
-    let fd;
-    try {
-        fd = fs.openSync(filePath, "r");
-        const buffer = Buffer.alloc(64 * 1024);
-        const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, 0);
-        const firstLine = buffer.toString("utf8", 0, bytesRead).split("\n", 1)[0]?.trim();
-        if (!firstLine)
-            return undefined;
-        const header = JSON.parse(firstLine);
-        return header.type === "session" && typeof header.id === "string" ? header.id : undefined;
-    }
-    catch {
-        return undefined;
-    }
-    finally {
-        if (fd !== undefined) {
-            try {
-                fs.closeSync(fd);
-            }
-            catch {
-                // Ignore close errors while pruning best-effort history artifacts.
-            }
-        }
-    }
-}
 function getAutoLearnSessionIdFromFileName(fileName) {
     return fileName.match(/_(auto-learn-[A-Za-z0-9._-]+)\.jsonl$/)?.[1];
 }
@@ -872,6 +851,9 @@ export class InteractiveMode {
                 const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
                 this.showError(errorMessage);
             }
+            finally {
+                this.refreshAutonomyFooterStatus();
+            }
         }
         if (initialMessages) {
             for (const message of initialMessages) {
@@ -882,6 +864,9 @@ export class InteractiveMode {
                     const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
                     this.showError(errorMessage);
                 }
+                finally {
+                    this.refreshAutonomyFooterStatus();
+                }
             }
         }
         // Main interactive loop
@@ -894,8 +879,15 @@ export class InteractiveMode {
                 const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
                 this.showError(errorMessage);
             }
+            finally {
+                this.refreshAutonomyFooterStatus();
+            }
         }
     }
+    refreshAutonomyFooterStatus() {
+        this.footerDataProvider.setAutonomyStatusSnapshot(this.session.getAutonomyStatusSnapshot());
+        this.footer.invalidate();
+    }
     async checkForPackageUpdates() {
         if (process.env.PI_OFFLINE) {
             return [];
@@ -2443,11 +2435,16 @@ export class InteractiveMode {
                 const images = this.takeClipboardImagesForText(text);
                 this.editor.addToHistory?.(text);
                 this.editor.setText("");
-                await this.session.prompt(text, {
-                    streamingBehavior: queueAsFollowUp ? "followUp" : "steer",
-                    images,
-                    processSlashCommands: false,
-                });
+                try {
+                    await this.session.prompt(text, {
+                        streamingBehavior: queueAsFollowUp ? "followUp" : "steer",
+                        images,
+                        processSlashCommands: false,
+                    });
+                }
+                finally {
+                    this.refreshAutonomyFooterStatus();
+                }
                 this.updatePendingMessagesDisplay();
                 this.ui.requestRender();
                 return;
@@ -2468,6 +2465,24 @@ export class InteractiveMode {
                 this.editor.setText("");
                 return;
             }
+            if (text === "/fitness" || text.startsWith("/fitness ")) {
+                const fitnessArgs = text.slice("/fitness".length).trim();
+                this.editor.setText("");
+                if (fitnessArgs.length === 0) {
+                    // No args: open the model picker, probe the selection, then offer role assignment.
+                    this.showFitnessModelSelector();
+                }
+                else {
+                    // Explicit ref: same handler as /autonomy fitness.
+                    this.handleAutonomyCommand(`/autonomy fitness ${fitnessArgs}`);
+                }
+                return;
+            }
+            if (text === "/context") {
+                this.showStatus(this.session.formatContextCompositionDashboard());
+                this.editor.setText("");
+                return;
+            }
             if (text === "/scoped-models") {
                 this.editor.setText("");
                 await this.showModelsSelector();
@@ -2520,6 +2535,11 @@ export class InteractiveMode {
                 this.editor.setText("");
                 return;
             }
+            if (text === "/goal-continue" || text.startsWith("/goal-continue ")) {
+                await this.handleGoalContinueCommand(text);
+                this.editor.setText("");
+                return;
+            }
             if (text === "/changelog") {
                 this.handleChangelogCommand();
                 this.editor.setText("");
@@ -3610,7 +3630,12 @@ export class InteractiveMode {
             if (this.isExtensionCommand(text)) {
                 this.editor.addToHistory?.(text);
                 this.editor.setText("");
-                await this.session.prompt(text);
+                try {
+                    await this.session.prompt(text);
+                }
+                finally {
+                    this.refreshAutonomyFooterStatus();
+                }
             }
             else {
                 const images = this.takeClipboardImagesForText(text);
@@ -3624,7 +3649,12 @@ export class InteractiveMode {
             const images = this.takeClipboardImagesForText(text);
             this.editor.addToHistory?.(text);
             this.editor.setText("");
-            await this.session.prompt(text, { streamingBehavior: "followUp", images });
+            try {
+                await this.session.prompt(text, { streamingBehavior: "followUp", images });
+            }
+            finally {
+                this.refreshAutonomyFooterStatus();
+            }
             this.updatePendingMessagesDisplay();
             this.ui.requestRender();
         }
@@ -3996,8 +4026,13 @@ export class InteractiveMode {
             const promptOptions = this.session.isStreaming
                 ? { images: firstPrompt.images, streamingBehavior: firstPrompt.mode }
                 : { images: firstPrompt.images };
-            const promptPromise = this.session.prompt(firstPrompt.text, promptOptions).catch((error) => {
+            const promptPromise = this.session
+                .prompt(firstPrompt.text, promptOptions)
+                .catch((error) => {
                 restoreQueue(error);
+            })
+                .finally(() => {
+                this.refreshAutonomyFooterStatus();
             });
             // Queue remaining messages
             for (const message of rest) {
@@ -4534,9 +4569,26 @@ export class InteractiveMode {
             return { result: undefined, next };
         });
     }
-    cleanupCompletedAutoLearnRun(runId, artifactPaths) {
+    reportCompletedAutoLearnUsage(runId, sessionDir, sessionId, logPath) {
+        try {
+            reportCompletedAutoLearnUsageHelper({
+                runId,
+                sessionDir,
+                sessionId,
+                logPath,
+                parentSession: this.session,
+                appendLog: (p, msg) => this.appendAutoLearnLog(p, msg),
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.appendAutoLearnLog(logPath, `Auto Learn usage report failed: ${message}`);
+        }
+    }
+    cleanupCompletedAutoLearnRun(runId, options) {
+        this.reportCompletedAutoLearnUsage(runId, options.sessionDir, options.sessionId, options.logPath);
         const dataDir = this.getAutoLearnDataDir();
-        for (const filePath of artifactPaths)
+        for (const filePath of options.artifactPaths)
             removeAutoLearnArtifactPath(filePath, dataDir);
         this.withAutoLearnStateLock((current) => {
             const state = this.pruneAutoLearnState(current);
@@ -4681,8 +4733,14 @@ export class InteractiveMode {
         }
         const childPid = child.pid;
         child.once("exit", (code) => {
-            if (code === 0)
-                this.cleanupCompletedAutoLearnRun(reservation.runId, [promptPath, logPath, sessionDir]);
+            if (code === 0) {
+                this.cleanupCompletedAutoLearnRun(reservation.runId, {
+                    artifactPaths: [promptPath, logPath, sessionDir],
+                    sessionDir,
+                    sessionId,
+                    logPath,
+                });
+            }
         });
         child.unref();
         this.markAutoLearnReservationRunning(reservation, childPid, settings);
@@ -5071,6 +5129,72 @@ export class InteractiveMode {
         this.settingsManager.setAutoLearnSettings(preset, scope);
         this.updateAutoLearnFooter();
     }
+    /** /fitness with no args: pick a model from the configured registry, probe it, assign a role. */
+    showFitnessModelSelector() {
+        this.showSelector((done) => {
+            const selector = new ModelSelectorComponent(this.ui, this.session.model, this.settingsManager, this.session.modelRegistry, this.session.scopedModels, async (model) => {
+                done();
+                await this.runFitnessAndAssign(`${model.provider}/${model.id}`);
+            }, () => {
+                done();
+                this.ui.requestRender();
+            });
+            return { component: selector, focus: selector };
+        });
+    }
+    /** Probe a model's fitness, show the report, then offer one-step role assignment. */
+    async runFitnessAndAssign(modelRef) {
+        this.showStatus(`Model fitness probe running on ${modelRef}… (6 surfaces; local models may take a few minutes)`);
+        try {
+            const outcome = await this.session.runModelFitness({ model: modelRef });
+            if (!outcome.started) {
+                this.showStatus(`Model fitness skipped: ${outcome.skipReason}`);
+                return;
+            }
+            this.chatContainer.addChild(new Spacer(1));
+            this.chatContainer.addChild(new Text(formatModelFitnessReport(outcome.model, outcome.report), 1, 0));
+            this.ui.requestRender();
+            this.showSelector((done) => {
+                const selector = new FitnessRoleSelectorComponent(outcome.model, (role) => {
+                    done();
+                    this.assignFitnessRole(outcome.model, role);
+                }, () => {
+                    done();
+                    this.ui.requestRender();
+                });
+                return { component: selector, focus: selector };
+            });
+        }
+        catch (error) {
+            this.showError(error instanceof Error ? error.message : String(error));
+        }
+    }
+    /** Persist a role assignment from the post-probe selector into the matching settings. */
+    assignFitnessRole(modelRef, role) {
+        if (role === "none") {
+            this.showStatus(`Fitness result for ${modelRef} saved. Assign a role later from /settings.`);
+            return;
+        }
+        if (role === "curator") {
+            const current = this.settingsManager.getContextCurationSettings();
+            this.settingsManager.setContextCurationSettings({ ...current, enabled: true, model: modelRef });
+            this.showStatus(`Context curation enabled with ${modelRef} as the curator.`);
+            return;
+        }
+        const router = this.settingsManager.getModelRouterSettings();
+        const field = role === "router-cheap"
+            ? "cheapModel"
+            : role === "router-medium"
+                ? "mediumModel"
+                : role === "router-expensive"
+                    ? "expensiveModel"
+                    : role === "judge"
+                        ? "judgeModel"
+                        : "learningModel";
+        this.settingsManager.setModelRouterSettings({ ...router, [field]: modelRef });
+        const hint = router.enabled ? "" : " Model router is currently disabled — enable it in /settings → Model Router.";
+        this.showStatus(`${modelRef} set as ${role.replace("router-", "router ")} model.${hint}`);
+    }
     handleAutonomyCommand(text) {
         const action = text.slice("/autonomy".length).trim() || "status";
         if (AUTONOMY_MODES.includes(action)) {
@@ -5085,7 +5209,75 @@ export class InteractiveMode {
             this.ui.requestRender();
             return;
         }
-        this.showStatus("Usage: /autonomy [status|off|safe|balanced|full]");
+        if (action === "diagnostics") {
+            this.chatContainer.addChild(new Spacer(1));
+            this.chatContainer.addChild(new Text(formatAutonomyDiagnostics(this.session.getAutonomyDiagnosticSnapshot()), 1, 0));
+            this.ui.requestRender();
+            return;
+        }
+        if (action.startsWith("rollback")) {
+            const auditId = action.slice("rollback".length).trim();
+            if (!auditId) {
+                this.showStatus("Usage: /autonomy rollback <auditId> (see /autonomy diagnostics for audit ids)");
+                return;
+            }
+            void this.session
+                .rollbackLearningWrite(auditId)
+                .then((result) => {
+                this.showStatus(result.ok ? `Rolled back learning change ${auditId}.` : `Rollback skipped: ${result.reason}`);
+            })
+                .catch((error) => {
+                const message = error instanceof Error ? error.message : String(error);
+                this.showStatus(`Rollback failed: ${message}`);
+            });
+            return;
+        }
+        if (action.startsWith("fitness")) {
+            const rest = action.slice("fitness".length).trim().split(/\s+/).filter(Boolean);
+            const modelPattern = rest[0];
+            if (!modelPattern) {
+                this.showStatus("Usage: /autonomy fitness <model-pattern> [trials]");
+                return;
+            }
+            const trials = rest[1] ? Number(rest[1]) : undefined;
+            this.showStatus(`Model fitness probe running on ${modelPattern}…`);
+            void this.session
+                .runModelFitness({ model: modelPattern, trials: Number.isFinite(trials) ? trials : undefined })
+                .then((outcome) => {
+                if (!outcome.started) {
+                    this.showStatus(`Model fitness skipped: ${outcome.skipReason}`);
+                    return;
+                }
+                this.chatContainer.addChild(new Spacer(1));
+                this.chatContainer.addChild(new Text(formatModelFitnessReport(outcome.model, outcome.report), 1, 0));
+                this.ui.requestRender();
+            })
+                .catch((error) => {
+                const message = error instanceof Error ? error.message : String(error);
+                this.showStatus(`Model fitness failed: ${message}`);
+            });
+            return;
+        }
+        if (action === "research") {
+            this.showStatus("Research lane: running…");
+            void this.session
+                .runResearchLaneOnce()
+                .then((outcome) => {
+                if (!outcome.started) {
+                    this.showStatus(`Research lane skipped: ${outcome.skipReason ?? "unknown"}`);
+                    return;
+                }
+                const status = outcome.record?.status ?? "unknown";
+                const reason = outcome.record?.reasonCode ? ` (${outcome.record.reasonCode})` : "";
+                this.showStatus(`Research lane ${status}${reason}`);
+            })
+                .catch((error) => {
+                const message = error instanceof Error ? error.message : String(error);
+                this.showStatus(`Research lane failed: ${message}`);
+            });
+            return;
+        }
+        this.showStatus("Usage: /autonomy [status|diagnostics|research|rollback <auditId>|off|safe|balanced|full]");
     }
     handleAutoLearnCommand(text) {
         const action = text.slice("/auto-learn".length).trim() || "status";
@@ -5153,11 +5345,21 @@ export class InteractiveMode {
                 selfModificationScope: projectSettings.selfModification ? "project" : "global",
                 autonomy: this.settingsManager.getAutonomySettings(),
                 autonomyScope: projectSettings.autonomy ? "project" : "global",
+                researchLane: this.settingsManager.getResearchLaneSettings(),
+                researchLaneScope: projectSettings.researchLane ? "project" : "global",
+                workerDelegation: this.settingsManager.getWorkerDelegationSettings(),
+                workerDelegationScope: projectSettings.workerDelegation ? "project" : "global",
+                contextCuration: this.settingsManager.getContextCurationSettings(),
+                contextCurationScope: projectSettings.contextPolicy?.curation ? "project" : "global",
                 modelRouter: this.settingsManager.getModelRouterSettings(),
                 modelRouterScope: projectSettings.modelRouter ? "project" : "global",
                 autoLearn: this.settingsManager.getAutoLearnSettings(),
                 autoLearnScope: projectSettings.autoLearn ? "project" : "global",
                 autoLearnModelOptions: this.getAutoLearnModelOptions(),
+                contextPolicyEnforcement: this.settingsManager.getContextPromptEnforcementSettings(),
+                contextPolicyEnforcementScope: projectSettings.contextPolicy?.enforcement ? "project" : "global",
+                contextMemoryRetrieval: this.settingsManager.getMemoryRetrievalSettings(),
+                contextMemoryRetrievalScope: projectSettings.contextPolicy?.memory ? "project" : "global",
                 currentModelPattern: this.session.model
                     ? `${this.session.model.provider}/${this.session.model.id}`
                     : undefined,
@@ -5298,6 +5500,18 @@ export class InteractiveMode {
                     this.applyAutonomyMode(settings.mode ?? "off", scope);
                     this.showStatus(`Autonomy mode ${settings.mode ?? "off"} saved to ${scope}. Use /autonomy status.`);
                 },
+                onResearchLaneChange: (settings, scope) => {
+                    this.settingsManager.setResearchLaneSettings(settings, scope);
+                    this.showStatus(`Research lane settings saved to ${scope}. Use /autonomy research or /autonomy diagnostics.`);
+                },
+                onWorkerDelegationChange: (settings, scope) => {
+                    this.settingsManager.setWorkerDelegationSettings(settings, scope);
+                    this.showStatus(`Worker delegation settings saved to ${scope}. The delegate tool uses them.`);
+                },
+                onContextCurationChange: (settings, scope) => {
+                    this.settingsManager.setContextCurationSettings(settings, scope);
+                    this.showStatus(`Context curation settings saved to ${scope}. Run /fitness <model> first if the model is unprobed.`);
+                },
                 onModelRouterChange: (settings, scope) => {
                     this.settingsManager.setModelRouterSettings(settings, scope);
                     for (const value of [settings.cheapModel, settings.expensiveModel, settings.learningModel]) {
@@ -5318,6 +5532,14 @@ export class InteractiveMode {
                     this.updateAutoLearnFooter();
                     this.showStatus(`Auto Learn settings saved to ${scope}. Use /auto-learn status or /auto-learn run.`);
                 },
+                onContextPolicyEnforcementChange: (settings, scope) => {
+                    this.settingsManager.setContextPromptEnforcementSettings(settings, scope);
+                    this.showStatus(`Context/prompt-policy settings saved to ${scope}.`);
+                },
+                onContextMemoryRetrievalChange: (settings, scope) => {
+                    this.settingsManager.setMemoryRetrievalSettings(settings, scope);
+                    this.showStatus(`Context/memory-retrieval settings saved to ${scope}.`);
+                },
                 onResourcesHubAction: (action) => {
                     done();
                     void this.handleResourcesHubAction(action);
@@ -7290,6 +7512,53 @@ export class InteractiveMode {
         this.chatContainer.addChild(new Text(theme.fg("dim", `Session name set: ${name}`), 1, 0));
         this.ui.requestRender();
     }
+    parseGoalContinueCommand(text) {
+        const usage = "Usage: /goal-continue [maxTurns 1-20] [maxStallTurns 0-100] [maxMinutes 0-1440]";
+        const parts = text.trim().split(/\s+/).slice(1);
+        if (parts.length > 3) {
+            return { ok: false, error: usage };
+        }
+        const parseBoundedInteger = (value, fallback, min, max) => {
+            if (value === undefined || value.length === 0)
+                return fallback;
+            if (!/^\d+$/.test(value))
+                return undefined;
+            const parsed = Number.parseInt(value, 10);
+            if (!Number.isSafeInteger(parsed) || parsed < min || parsed > max)
+                return undefined;
+            return parsed;
+        };
+        const maxTurns = parseBoundedInteger(parts[0], DEFAULT_GOAL_CONTINUE_MAX_TURNS, 1, MAX_GOAL_CONTINUE_MAX_TURNS);
+        const maxStallTurns = parseBoundedInteger(parts[1], DEFAULT_GOAL_CONTINUE_MAX_STALL_TURNS, 0, MAX_GOAL_CONTINUE_MAX_STALL_TURNS);
+        const maxWallClockMinutes = parseBoundedInteger(parts[2], DEFAULT_GOAL_CONTINUE_MAX_WALL_CLOCK_MINUTES, 0, MAX_GOAL_CONTINUE_MAX_WALL_CLOCK_MINUTES);
+        if (maxTurns === undefined || maxStallTurns === undefined || maxWallClockMinutes === undefined) {
+            return { ok: false, error: usage };
+        }
+        return { ok: true, maxTurns, maxStallTurns, maxWallClockMinutes };
+    }
+    async handleGoalContinueCommand(text) {
+        const parsed = this.parseGoalContinueCommand(text);
+        if (!parsed.ok) {
+            this.showError(parsed.error);
+            return;
+        }
+        this.showStatus(`Goal continuation started: up to ${parsed.maxTurns} turn(s), stall limit ${parsed.maxStallTurns}, wall-clock limit ${parsed.maxWallClockMinutes || "disabled"} minute(s).`);
+        try {
+            const result = await this.session.continueGoalLoop({
+                maxTurns: parsed.maxTurns,
+                maxStallTurns: parsed.maxStallTurns,
+                maxWallClockMinutes: parsed.maxWallClockMinutes,
+            });
+            const continuation = result.finalSnapshot.continuation;
+            this.showStatus(`Goal continuation stopped: ${result.stopReason}; submitted ${result.turnsSubmitted} turn(s); latest decision ${continuation.action}/${continuation.reasonCode}.`);
+        }
+        catch (error) {
+            this.showError(`Goal continuation failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            this.refreshAutonomyFooterStatus();
+        }
+    }
     handleSessionCommand() {
         const stats = this.session.getSessionStats();
         const sessionName = this.sessionManager.getSessionName();