@caupulican/pi-adaptative 0.78.4 → 0.80.0

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

@@ -28,7 +28,7 @@ import { getChangelogPath, getNewEntries, parseChangelog } from "../../utils/cha
 import { copyToClipboard } from "../../utils/clipboard.js";
 import { extensionForImageMimeType, readClipboardImage } from "../../utils/clipboard-image.js";
 import { parseGitUrl } from "../../utils/git.js";
-import { getCwdRelativePath } from "../../utils/paths.js";
+import { getCwdRelativePath, resolvePath } from "../../utils/paths.js";
 import { getPiUserAgent } from "../../utils/pi-user-agent.js";
 import { killTrackedDetachedChildren } from "../../utils/shell.js";
 import { ensureTool } from "../../utils/tools-manager.js";
@@ -88,6 +88,62 @@ function isDeadTerminalError(error) {
     return code !== undefined && DEAD_TERMINAL_ERROR_CODES.has(code);
 }
 const ANTHROPIC_SUBSCRIPTION_AUTH_WARNING = "Anthropic subscription auth is active. Third-party harness usage draws from extra usage and is billed per token, not your Claude plan limits. Manage extra usage at https://claude.ai/settings/usage.";
+const AUTO_LEARN_DEFAULTS = {
+    enabled: false,
+    model: "active",
+    longSessionMessages: 32,
+    longSessionContextPercent: 70,
+    cooldownMinutes: 120,
+    leaseMinutes: 90,
+    maxConcurrentLearners: 2,
+    applyHighConfidence: false,
+    reflectionReview: true,
+    reflectionMinToolCalls: 5,
+    reflectionCooldownMinutes: 60,
+};
+const AUTONOMY_AUTO_LEARN_PRESETS = {
+    off: { ...AUTO_LEARN_DEFAULTS, enabled: false, reflectionReview: false },
+    safe: {
+        ...AUTO_LEARN_DEFAULTS,
+        enabled: true,
+        longSessionMessages: 48,
+        longSessionContextPercent: 80,
+        cooldownMinutes: 180,
+        leaseMinutes: 60,
+        maxConcurrentLearners: 1,
+        applyHighConfidence: false,
+        reflectionReview: true,
+        reflectionMinToolCalls: 8,
+        reflectionCooldownMinutes: 120,
+    },
+    balanced: {
+        ...AUTO_LEARN_DEFAULTS,
+        enabled: true,
+        longSessionMessages: 32,
+        longSessionContextPercent: 70,
+        cooldownMinutes: 120,
+        leaseMinutes: 90,
+        maxConcurrentLearners: 2,
+        applyHighConfidence: false,
+        reflectionReview: true,
+        reflectionMinToolCalls: 5,
+        reflectionCooldownMinutes: 60,
+    },
+    full: {
+        ...AUTO_LEARN_DEFAULTS,
+        enabled: true,
+        longSessionMessages: 8,
+        longSessionContextPercent: 50,
+        cooldownMinutes: 15,
+        leaseMinutes: 90,
+        maxConcurrentLearners: 3,
+        applyHighConfidence: true,
+        reflectionReview: true,
+        reflectionMinToolCalls: 1,
+        reflectionCooldownMinutes: 0,
+    },
+};
+const AUTONOMY_MODES = ["off", "safe", "balanced", "full"];
 function isAnthropicSubscriptionAuthKey(apiKey) {
     return typeof apiKey === "string" && apiKey.startsWith("sk-ant-oat");
 }
@@ -188,6 +244,8 @@ export class InteractiveMode {
     // Auto-compaction state
     autoCompactionLoader = undefined;
     autoCompactionEscapeHandler;
+    // Auto Learn background runner state
+    autoLearnLastStatus = "idle";
     // Auto-retry state
     retryLoader = undefined;
     retryCountdown = undefined;
@@ -504,8 +562,9 @@ export class InteractiveMode {
         this.footerDataProvider.onBranchChange(() => {
             this.ui.requestRender();
         });
-        // Initialize available provider count for footer display
+        // Initialize available provider count and Auto Learn status for footer display
         await this.updateAvailableProviderCount();
+        this.updateAutoLearnFooter();
     }
     /**
      * Update terminal title with session name and cwd.
@@ -2050,6 +2109,16 @@ export class InteractiveMode {
                 this.editor.setText("");
                 return;
             }
+            if (text === "/auto-learn" || text.startsWith("/auto-learn ")) {
+                this.handleAutoLearnCommand(text);
+                this.editor.setText("");
+                return;
+            }
+            if (text === "/autonomy" || text.startsWith("/autonomy ")) {
+                this.handleAutonomyCommand(text);
+                this.editor.setText("");
+                return;
+            }
             if (text === "/scoped-models") {
                 this.editor.setText("");
                 await this.showModelsSelector();
@@ -2371,6 +2440,9 @@ export class InteractiveMode {
                 break;
             }
             case "agent_end":
+                if (!this.maybeStartAutoLearn()) {
+                    this.maybeStartAutonomyReview(event.messages);
+                }
                 if (this.settingsManager.getShowTerminalProgress()) {
                     this.ui.terminal.setProgress(false);
                 }
@@ -3260,8 +3332,634 @@ export class InteractiveMode {
         this.ui.setFocus(focus);
         this.ui.requestRender();
     }
+    getAutoLearnModelAuthPriority(model) {
+        if (this.session.model && model.provider === this.session.model.provider && model.id === this.session.model.id) {
+            return 0;
+        }
+        const credential = this.session.modelRegistry.authStorage.get(model.provider);
+        if (credential?.type === "oauth")
+            return 1;
+        if (credential?.type === "api_key")
+            return 2;
+        const authStatus = this.session.modelRegistry.getProviderAuthStatus(model.provider);
+        switch (authStatus.source) {
+            case "runtime":
+                return 3;
+            case "environment":
+                return 4;
+            case "models_json_key":
+            case "models_json_command":
+            case "fallback":
+                return 5;
+            default:
+                return 6;
+        }
+    }
+    getAutoLearnModelAuthLabel(model) {
+        const credential = this.session.modelRegistry.authStorage.get(model.provider);
+        if (credential?.type === "oauth")
+            return "subscription";
+        if (credential?.type === "api_key")
+            return "API key";
+        const authStatus = this.session.modelRegistry.getProviderAuthStatus(model.provider);
+        switch (authStatus.source) {
+            case "runtime":
+                return authStatus.label ? `runtime ${authStatus.label}` : "runtime API key";
+            case "environment":
+                return authStatus.label ? `env ${authStatus.label}` : "environment API key";
+            case "models_json_key":
+                return "models.json API key";
+            case "models_json_command":
+                return "models.json command";
+            case "fallback":
+                return authStatus.label ?? "custom provider config";
+            default:
+                return "configured";
+        }
+    }
+    getAutoLearnModelOptions() {
+        this.session.modelRegistry.refresh();
+        const availableModels = this.session.modelRegistry.getAvailable();
+        const sortedModels = [...availableModels].sort((a, b) => {
+            const priorityDelta = this.getAutoLearnModelAuthPriority(a) - this.getAutoLearnModelAuthPriority(b);
+            if (priorityDelta !== 0)
+                return priorityDelta;
+            const providerDelta = this.session.modelRegistry
+                .getProviderDisplayName(a.provider)
+                .localeCompare(this.session.modelRegistry.getProviderDisplayName(b.provider));
+            if (providerDelta !== 0)
+                return providerDelta;
+            return a.id.localeCompare(b.id);
+        });
+        return sortedModels.map((model) => {
+            const providerName = this.session.modelRegistry.getProviderDisplayName(model.provider);
+            const authLabel = this.getAutoLearnModelAuthLabel(model);
+            const modelPattern = `${model.provider}/${model.id}`;
+            const currentLabel = this.session.model && model.provider === this.session.model.provider && model.id === this.session.model.id
+                ? " · current"
+                : "";
+            const displayName = model.name && model.name !== model.id ? ` · ${model.name}` : "";
+            return {
+                value: modelPattern,
+                label: modelPattern,
+                description: `${providerName} · ${authLabel}${currentLabel}${displayName}`,
+            };
+        });
+    }
+    getAutoLearnDataDir() {
+        return path.join(getAgentDir(), "auto-learn");
+    }
+    getAutoLearnStatePath() {
+        return path.join(this.getAutoLearnDataDir(), "state.json");
+    }
+    readAutoLearnState() {
+        try {
+            const statePath = this.getAutoLearnStatePath();
+            if (!fs.existsSync(statePath))
+                return {};
+            return JSON.parse(fs.readFileSync(statePath, "utf-8"));
+        }
+        catch {
+            return {};
+        }
+    }
+    writeAutoLearnState(state) {
+        const dir = this.getAutoLearnDataDir();
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(this.getAutoLearnStatePath(), `${JSON.stringify(state, null, 2)}\n`, "utf-8");
+    }
+    isAutoLearnPidAlive(pid) {
+        if (typeof pid !== "number" || pid <= 0)
+            return false;
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch (error) {
+            const code = error && typeof error === "object" && "code" in error ? String(error.code) : "";
+            return code === "EPERM";
+        }
+    }
+    pruneAutoLearnState(state, now = Date.now()) {
+        const runs = { ...(state.runs ?? {}) };
+        for (const [id, run] of Object.entries(runs)) {
+            if (run.expiresAt <= now || !this.isAutoLearnPidAlive(run.pid)) {
+                delete runs[id];
+            }
+        }
+        return { ...state, runs };
+    }
+    getAutoLearnPresetForAutonomyMode(mode, current = {}) {
+        const preset = AUTONOMY_AUTO_LEARN_PRESETS[mode] ?? AUTONOMY_AUTO_LEARN_PRESETS.off;
+        return { ...preset, model: current.model?.trim() || preset.model };
+    }
+    getEffectiveAutoLearnSettings() {
+        const settings = this.settingsManager.getAutoLearnSettings();
+        const preset = this.getAutoLearnPresetForAutonomyMode(this.settingsManager.getAutonomySettings().mode, settings);
+        return {
+            enabled: settings.enabled ?? preset.enabled,
+            model: settings.model?.trim() || preset.model,
+            longSessionMessages: settings.longSessionMessages ?? preset.longSessionMessages,
+            longSessionContextPercent: settings.longSessionContextPercent ?? preset.longSessionContextPercent,
+            cooldownMinutes: settings.cooldownMinutes ?? preset.cooldownMinutes,
+            leaseMinutes: settings.leaseMinutes ?? preset.leaseMinutes,
+            maxConcurrentLearners: settings.maxConcurrentLearners ?? preset.maxConcurrentLearners,
+            applyHighConfidence: settings.applyHighConfidence ?? preset.applyHighConfidence,
+            reflectionReview: settings.reflectionReview ?? preset.reflectionReview,
+            reflectionMinToolCalls: settings.reflectionMinToolCalls ?? preset.reflectionMinToolCalls,
+            reflectionCooldownMinutes: settings.reflectionCooldownMinutes ?? preset.reflectionCooldownMinutes,
+        };
+    }
+    getAutoLearnTenantKey() {
+        return `${this.sessionManager.getCwd()}::${this.session.sessionId}`;
+    }
+    getAutoLearnMessageCount() {
+        return this.sessionManager.getBranch().filter((entry) => entry.type === "message").length;
+    }
+    resolveAutoLearnModelPattern(settings) {
+        if (settings.model === "active") {
+            return this.session.model ? `${this.session.model.provider}/${this.session.model.id}` : undefined;
+        }
+        return settings.model;
+    }
+    getAutoLearnSpawnTarget() {
+        const overridePath = process.env.PI_AUTO_LEARN_CLI_PATH?.trim();
+        if (overridePath) {
+            return { command: overridePath, argsPrefix: [] };
+        }
+        const execBase = path.basename(process.execPath).toLowerCase();
+        const isScriptRuntime = execBase === "node" || execBase === "node.exe" || execBase === "bun" || execBase === "bun.exe";
+        if (!isScriptRuntime) {
+            return { command: process.execPath, argsPrefix: [] };
+        }
+        const cliPath = process.argv[1];
+        if (!cliPath || cliPath.startsWith("-")) {
+            return undefined;
+        }
+        return { command: process.execPath, argsPrefix: [cliPath] };
+    }
+    validateAutoLearnModelValue(value) {
+        const modelValue = value?.trim();
+        if (!modelValue || modelValue === "active")
+            return undefined;
+        const available = this.session.modelRegistry.getAvailable();
+        if (modelValue.includes("/")) {
+            const [provider, modelId] = modelValue.split("/", 2);
+            if (available.some((model) => model.provider === provider && model.id === modelId))
+                return undefined;
+            return `Auto Learn model "${modelValue}" is not in configured subscription/API models; saved as manual/unverified.`;
+        }
+        if (available.some((model) => model.id === modelValue))
+            return undefined;
+        return `Auto Learn model "${modelValue}" is not in configured subscription/API models; saved as manual/unverified.`;
+    }
+    validateSelfModificationSource(settings) {
+        if (!settings.enabled)
+            return undefined;
+        const rawPath = settings.sourcePath?.trim();
+        if (!rawPath)
+            return "Self modification is enabled, but no pi-adaptative source path is set.";
+        const sourcePath = resolvePath(rawPath, this.sessionManager.getCwd(), { trim: true });
+        if (!fs.existsSync(sourcePath))
+            return `Self modification source path does not exist: ${sourcePath}`;
+        if (!fs.existsSync(path.join(sourcePath, "package.json"))) {
+            return `Self modification source path has no package.json: ${sourcePath}`;
+        }
+        if (!fs.existsSync(path.join(sourcePath, "packages", "coding-agent"))) {
+            return `Self modification source path does not look like pi-adaptative (missing packages/coding-agent): ${sourcePath}`;
+        }
+        return undefined;
+    }
+    evaluateAutoLearn(force = false) {
+        const settings = this.getEffectiveAutoLearnSettings();
+        const state = this.pruneAutoLearnState(this.readAutoLearnState());
+        this.writeAutoLearnState(state);
+        const now = Date.now();
+        const tenant = this.getAutoLearnTenantKey();
+        const runningCount = Object.keys(state.runs ?? {}).length;
+        const lastLaunch = state.lastLaunchByTenant?.[tenant] ?? 0;
+        const cooldownMs = settings.cooldownMinutes * 60 * 1000;
+        const cooldownRemainingMs = Math.max(0, lastLaunch + cooldownMs - now);
+        const messageCount = this.getAutoLearnMessageCount();
+        const contextPercent = this.session.getContextUsage()?.percent ?? null;
+        if (!settings.enabled && !force) {
+            return {
+                shouldRun: false,
+                reason: "disabled",
+                messageCount,
+                contextPercent,
+                cooldownRemainingMs,
+                runningCount,
+            };
+        }
+        if (runningCount >= settings.maxConcurrentLearners) {
+            return {
+                shouldRun: false,
+                reason: `max learners running (${runningCount}/${settings.maxConcurrentLearners})`,
+                messageCount,
+                contextPercent,
+                cooldownRemainingMs,
+                runningCount,
+            };
+        }
+        if (!force && cooldownRemainingMs > 0) {
+            return {
+                shouldRun: false,
+                reason: "cooldown",
+                messageCount,
+                contextPercent,
+                cooldownRemainingMs,
+                runningCount,
+            };
+        }
+        if (force) {
+            return { shouldRun: true, reason: "manual", messageCount, contextPercent, cooldownRemainingMs, runningCount };
+        }
+        if (messageCount >= settings.longSessionMessages) {
+            return {
+                shouldRun: true,
+                reason: `message trigger (${messageCount}/${settings.longSessionMessages})`,
+                messageCount,
+                contextPercent,
+                cooldownRemainingMs,
+                runningCount,
+            };
+        }
+        if (contextPercent !== null && contextPercent >= settings.longSessionContextPercent) {
+            return {
+                shouldRun: true,
+                reason: `context trigger (${contextPercent.toFixed(1)}%/${settings.longSessionContextPercent}%)`,
+                messageCount,
+                contextPercent,
+                cooldownRemainingMs,
+                runningCount,
+            };
+        }
+        return {
+            shouldRun: false,
+            reason: "thresholds not met",
+            messageCount,
+            contextPercent,
+            cooldownRemainingMs,
+            runningCount,
+        };
+    }
+    buildAutonomyAuthorityPrompt() {
+        const autonomy = this.settingsManager.getAutonomySettings();
+        const selfModification = this.settingsManager.getSelfModificationSettings();
+        if (autonomy.mode !== "full") {
+            return [
+                "Authority mode: proposal-gated.",
+                "- You may autonomously query memory and run bounded learning tools.",
+                "- Durable memory writes require the configured high-confidence policy; skills, extensions, source, settings, publishing, tagging, and releases remain proposals unless the foreground user explicitly asks.",
+            ].join("\n");
+        }
+        const sourceAuthority = selfModification.enabled && selfModification.sourcePath?.trim()
+            ? `- Pi source: standing authority to edit the authorized selfModification.sourcePath (${selfModification.sourcePath.trim()}) for self-evolution improvements; inspect git status first, preserve unrelated user changes, run focused validation, and leave a clear rollback/test summary.`
+            : "- Pi source: no standing source-edit authority until selfModification.enabled and selfModification.sourcePath are set.";
+        return [
+            "Authority mode: FULL AUTONOMOUS standing grant.",
+            "- Memory: may apply high-confidence durable Automata memory/corrections after duplicate and corroboration checks.",
+            "- Skills: may create or patch user/project-owned procedural skills and support files; prefer updating existing umbrella skills; do not delete skills without making a recoverable archive/backup.",
+            "- User/project extensions and tools: may create or patch small scoped extensions/tools under Pi user/project roots when they address repeated workflow/tooling gaps; validate and keep changes auditable.",
+            "- Settings: may auto-tune autonomy/autoLearn settings to reduce bottlenecks; do not modify credentials, provider auth, package sources, or unrelated user preferences.",
+            sourceAuthority,
+            "- Hard stops without explicit foreground approval: publish, npm release, git push, tag creation, credential changes, destructive user-data deletion, network-exposed services, or authority expansion beyond this policy.",
+            "- Audit: final output must list changed paths/settings, commands/tests run, evidence, residual risks, and rollback guidance. If no safe validation is possible, leave the change as a proposal instead of applying it.",
+        ].join("\n");
+    }
+    buildAutoLearnPrompt(reason, settings, options = {}) {
+        const authorityBlock = this.buildAutonomyAuthorityPrompt();
+        const reflectionBlock = options.kind === "reflection" && options.turnDigest
+            ? `\n\nLatest completed turn digest (bounded; use only as current-session evidence, not as longitudinal proof):\n<turn_digest>\n${options.turnDigest}\n</turn_digest>`
+            : "";
+        const objective = options.kind === "reflection"
+            ? "review the latest completed turn for durable memory, skill, validation, and tooling-improvement cues, then run one bounded continuous-learning pass if the learning tools are available"
+            : "run one bounded continuous-learning pass for this Pi tenant";
+        return `You are Pi Auto Learn running as a background learner.\n\nObjective: ${objective}.\nTrigger: ${reason}.\n\n${authorityBlock}\n\nRequired workflow:\n1. Query existing durable memory/rules first when tools allow it.\n2. Run the available Auto Learn tooling, preferably learning_run_auto, with applyHighConfidence=${settings.applyHighConfidence}.\n3. Treat the latest-turn digest as current-session evidence only; do not auto-commit one-off cues unless deterministic tooling corroborates them.\n4. In mode=full, apply safe memory/skill/user-extension/authorized-source improvements under the standing grant above; otherwise keep them proposal-gated.\n5. Never cross hard-stop boundaries from the authority policy.\n6. If the learning tools are unavailable, report BLOCKED with the missing tool names and do not improvise.\n7. Finish with PASS, BLOCKED, or FAIL and concise evidence.${reflectionBlock}`;
+    }
+    launchAutoLearn(reason, force = false, options = {}) {
+        const settings = this.getEffectiveAutoLearnSettings();
+        const decision = this.evaluateAutoLearn(force);
+        if (!decision.shouldRun) {
+            return `Auto Learn not started: ${decision.reason}`;
+        }
+        const modelPattern = this.resolveAutoLearnModelPattern(settings);
+        if (!modelPattern) {
+            return "Auto Learn not started: no active model is available for model=active.";
+        }
+        const spawnTarget = this.getAutoLearnSpawnTarget();
+        if (!spawnTarget) {
+            return "Auto Learn not started: could not resolve current pi CLI path.";
+        }
+        const dir = this.getAutoLearnDataDir();
+        fs.mkdirSync(dir, { recursive: true });
+        const runId = `${Date.now()}-${crypto.randomUUID().slice(0, 8)}`;
+        const logPath = path.join(dir, `${runId}.log`);
+        const promptPath = path.join(dir, `${runId}.prompt.md`);
+        const outFd = fs.openSync(logPath, "a");
+        const kind = options.promptKind ?? "auto";
+        const prompt = this.buildAutoLearnPrompt(reason, settings, {
+            kind,
+            turnDigest: options.turnDigest,
+        });
+        fs.writeFileSync(promptPath, prompt, "utf-8");
+        const args = [
+            ...spawnTarget.argsPrefix,
+            "--print",
+            "--name",
+            `Auto Learn ${runId}`,
+            "--model",
+            modelPattern,
+            prompt,
+        ];
+        const child = spawn(spawnTarget.command, args, {
+            cwd: this.sessionManager.getCwd(),
+            detached: true,
+            stdio: ["ignore", outFd, outFd],
+            env: { ...process.env, PI_AUTO_LEARN_CHILD: "1" },
+        });
+        child.unref();
+        fs.closeSync(outFd);
+        const now = Date.now();
+        const state = this.pruneAutoLearnState(this.readAutoLearnState(), now);
+        if (options.cooldownKind === "reflection") {
+            state.lastReflectionByTenant = {
+                ...(state.lastReflectionByTenant ?? {}),
+                [this.getAutoLearnTenantKey()]: now,
+            };
+        }
+        else {
+            state.lastLaunchByTenant = { ...(state.lastLaunchByTenant ?? {}), [this.getAutoLearnTenantKey()]: now };
+        }
+        state.runs = {
+            ...(state.runs ?? {}),
+            [runId]: {
+                tenant: this.getAutoLearnTenantKey(),
+                pid: child.pid,
+                model: modelPattern,
+                reason,
+                startedAt: now,
+                expiresAt: now + settings.leaseMinutes * 60 * 1000,
+                cwd: this.sessionManager.getCwd(),
+                logPath,
+                promptPath,
+                kind,
+                autonomyMode: this.settingsManager.getAutonomySettings().mode,
+                authority: this.settingsManager.getAutonomySettings().mode === "full"
+                    ? "standing-full-autonomous"
+                    : "proposal-gated",
+            },
+        };
+        this.writeAutoLearnState(state);
+        this.autoLearnLastStatus = `running ${modelPattern}`;
+        this.updateAutoLearnFooter();
+        return `Auto Learn started (${reason}) with ${modelPattern}. Log: ${logPath}`;
+    }
+    sanitizeAutoLearnDigestText(text) {
+        return text
+            .replace(/-----BEGIN [A-Z ]*(?:PRIVATE|OPENSSH|RSA|DSA|EC) KEY-----[\s\S]*?-----END [A-Z ]*(?:PRIVATE|OPENSSH|RSA|DSA|EC) KEY-----/g, "[redacted-private-key]")
+            .replace(/\b(?:sk|pk)-(?:proj-)?[A-Za-z0-9_-]{12,}/g, "[redacted-api-key]")
+            .replace(/\bsk-ant-[A-Za-z0-9_-]{12,}/g, "[redacted-api-key]")
+            .replace(/\b(?:ghp|gho|ghu|ghs|github_pat)_[A-Za-z0-9_]{20,}/g, "[redacted-github-token]")
+            .replace(/\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g, "[redacted-aws-access-key]")
+            .replace(/(?:Bearer\s+)[A-Za-z0-9._-]{16,}/gi, "Bearer [redacted]")
+            .replace(/([?&](?:key|token|api_key|access_token|secret|password)=)[^&\s]+/gi, "$1[redacted]")
+            .replace(/((?:access|refresh|token|apiKey|api_key|password|secret|authorization|auth)\s*[:=]\s*)[^\s,'"}]{8,}/gi, "$1[redacted]");
+    }
+    capAutoLearnDigestText(text, maxChars) {
+        const compact = this.sanitizeAutoLearnDigestText(text).replace(/\s+/g, " ").trim();
+        if (compact.length <= maxChars)
+            return compact;
+        return `${compact.slice(0, Math.max(0, maxChars - 20)).trimEnd()} …[truncated]`;
+    }
+    getAgentMessagePlainText(message) {
+        const raw = message;
+        const content = raw.content;
+        if (typeof content === "string")
+            return content;
+        if (!Array.isArray(content))
+            return "";
+        const parts = [];
+        for (const block of content) {
+            if (!block || typeof block !== "object")
+                continue;
+            const item = block;
+            if (item.type === "text" && typeof item.text === "string")
+                parts.push(item.text);
+            if (item.type === "toolCall" && typeof item.name === "string")
+                parts.push(`[tool call: ${item.name}]`);
+        }
+        return parts.join("\n");
+    }
+    countAgentToolCalls(messages) {
+        let toolCalls = 0;
+        let toolResults = 0;
+        for (const message of messages) {
+            const raw = message;
+            const role = String(raw.role ?? "");
+            if (role === "toolResult" || role === "bashExecution")
+                toolResults++;
+            const content = raw.content;
+            if (!Array.isArray(content))
+                continue;
+            for (const block of content) {
+                if (block && typeof block === "object" && block.type === "toolCall") {
+                    toolCalls++;
+                }
+            }
+        }
+        return Math.max(toolCalls, toolResults);
+    }
+    buildAutonomyReviewDigest(messages) {
+        const lines = [];
+        for (const message of messages.slice(-18)) {
+            const raw = message;
+            const role = String(raw.role ?? "message");
+            const label = role === "toolResult" && typeof raw.toolName === "string" ? `toolResult:${raw.toolName}` : role;
+            const text = this.capAutoLearnDigestText(this.getAgentMessagePlainText(message), 700);
+            if (text)
+                lines.push(`${label}: ${text}`);
+        }
+        const digest = lines.join("\n---\n");
+        return this.capAutoLearnDigestText(digest || "[No textual turn digest available.]", 6000);
+    }
+    evaluateAutonomyReview(messages) {
+        const settings = this.getEffectiveAutoLearnSettings();
+        const autonomy = this.settingsManager.getAutonomySettings();
+        const state = this.pruneAutoLearnState(this.readAutoLearnState());
+        this.writeAutoLearnState(state);
+        const now = Date.now();
+        const tenant = this.getAutoLearnTenantKey();
+        const runningCount = Object.keys(state.runs ?? {}).length;
+        const lastReflection = state.lastReflectionByTenant?.[tenant] ?? 0;
+        const cooldownMs = settings.reflectionCooldownMinutes * 60 * 1000;
+        const cooldownRemainingMs = Math.max(0, lastReflection + cooldownMs - now);
+        const messageCount = this.getAutoLearnMessageCount();
+        const contextPercent = this.session.getContextUsage()?.percent ?? null;
+        const toolCalls = this.countAgentToolCalls(messages);
+        const userText = messages
+            .filter((message) => String(message.role ?? "") === "user")
+            .map((message) => this.getAgentMessagePlainText(message))
+            .join("\n");
+        const correctionSignal = /\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);
+        const base = { messageCount, contextPercent, cooldownRemainingMs, runningCount, toolCalls };
+        if (!settings.enabled)
+            return { ...base, shouldRun: false, reason: "disabled" };
+        if (!settings.reflectionReview)
+            return { ...base, shouldRun: false, reason: "reflection disabled" };
+        if (runningCount >= settings.maxConcurrentLearners) {
+            return {
+                ...base,
+                shouldRun: false,
+                reason: `max learners running (${runningCount}/${settings.maxConcurrentLearners})`,
+            };
+        }
+        if (cooldownRemainingMs > 0)
+            return { ...base, shouldRun: false, reason: "reflection cooldown" };
+        if (correctionSignal) {
+            return {
+                ...base,
+                shouldRun: true,
+                reason: "reflection correction signal",
+                digest: this.buildAutonomyReviewDigest(messages),
+            };
+        }
+        if (autonomy.mode === "full") {
+            return {
+                ...base,
+                shouldRun: true,
+                reason: "full autonomy post-turn review",
+                digest: this.buildAutonomyReviewDigest(messages),
+            };
+        }
+        if (toolCalls >= settings.reflectionMinToolCalls) {
+            return {
+                ...base,
+                shouldRun: true,
+                reason: `reflection tool trigger (${toolCalls}/${settings.reflectionMinToolCalls})`,
+                digest: this.buildAutonomyReviewDigest(messages),
+            };
+        }
+        return { ...base, shouldRun: false, reason: "reflection thresholds not met" };
+    }
+    maybeStartAutoLearn() {
+        if (process.env.PI_AUTO_LEARN_CHILD === "1")
+            return false;
+        const decision = this.evaluateAutoLearn(false);
+        if (!decision.shouldRun) {
+            this.autoLearnLastStatus = decision.reason;
+            this.updateAutoLearnFooter();
+            return false;
+        }
+        const message = this.launchAutoLearn(decision.reason, false);
+        this.showStatus(message);
+        return message.startsWith("Auto Learn started");
+    }
+    maybeStartAutonomyReview(messages) {
+        if (process.env.PI_AUTO_LEARN_CHILD === "1")
+            return false;
+        const decision = this.evaluateAutonomyReview(messages);
+        if (!decision.shouldRun)
+            return false;
+        const message = this.launchAutoLearn(decision.reason, true, {
+            cooldownKind: "reflection",
+            promptKind: "reflection",
+            turnDigest: decision.digest,
+        });
+        this.showStatus(message);
+        return message.startsWith("Auto Learn started");
+    }
+    updateAutoLearnFooter() {
+        const settings = this.getEffectiveAutoLearnSettings();
+        if (!settings.enabled) {
+            this.footerDataProvider.setExtensionStatus("auto-learn", undefined);
+            return;
+        }
+        this.footerDataProvider.setExtensionStatus("auto-learn", theme.fg("accent", `learn: ${this.autoLearnLastStatus}`));
+        this.footer.invalidate();
+        this.ui.requestRender();
+    }
+    formatAutoLearnStatus() {
+        const settings = this.getEffectiveAutoLearnSettings();
+        const decision = this.evaluateAutoLearn(false);
+        const state = this.pruneAutoLearnState(this.readAutoLearnState());
+        const runs = Object.entries(state.runs ?? {});
+        const contextText = decision.contextPercent === null ? "unknown" : `${decision.contextPercent.toFixed(1)}%`;
+        const cooldownText = decision.cooldownRemainingMs > 0 ? `${Math.ceil(decision.cooldownRemainingMs / 60000)}m remaining` : "ready";
+        const runLines = runs.length
+            ? runs
+                .map(([id, run]) => `- ${id}: ${run.model}, kind=${run.kind ?? "auto"}, authority=${run.authority ?? "unknown"}, pid=${run.pid ?? "?"}, log=${run.logPath}`)
+                .join("\n")
+            : "- none";
+        const reflectionLast = state.lastReflectionByTenant?.[this.getAutoLearnTenantKey()] ?? 0;
+        const reflectionCooldownRemainingMs = Math.max(0, reflectionLast + settings.reflectionCooldownMinutes * 60 * 1000 - Date.now());
+        const reflectionCooldownText = reflectionCooldownRemainingMs > 0 ? `${Math.ceil(reflectionCooldownRemainingMs / 60000)}m remaining` : "ready";
+        return `Auto Learn status\nEnabled: ${settings.enabled}\nModel: ${settings.model}\nNext decision: ${decision.shouldRun ? "ready" : decision.reason}\nMessages: ${decision.messageCount}/${settings.longSessionMessages}\nContext: ${contextText}/${settings.longSessionContextPercent}%\nCooldown: ${cooldownText}\nReflection review: ${settings.reflectionReview ? "enabled" : "disabled"} (tool trigger ${settings.reflectionMinToolCalls}, cooldown ${reflectionCooldownText})\nRunning leases: ${runs.length}/${settings.maxConcurrentLearners}\nRuns:\n${runLines}`;
+    }
+    formatAutonomyStatus() {
+        const autonomy = this.settingsManager.getAutonomySettings();
+        const settings = this.getEffectiveAutoLearnSettings();
+        const autoLearnState = this.pruneAutoLearnState(this.readAutoLearnState());
+        const running = Object.entries(autoLearnState.runs ?? {});
+        const safety = autonomy.mode === "full"
+            ? "standing grant for memory, skills, user/project extensions, autonomy/autoLearn tuning, and authorized selfModification.sourcePath edits; hard stops still require explicit foreground approval"
+            : "proposal-gated outside configured high-confidence memory policy";
+        const reflectionLine = autonomy.mode === "full"
+            ? `Reflection review: ${settings.reflectionReview ? "enabled" : "disabled"}; post-turn when concurrency allows; cooldown=${settings.reflectionCooldownMinutes}m`
+            : `Reflection review: ${settings.reflectionReview ? "enabled" : "disabled"}; tool trigger=${settings.reflectionMinToolCalls}; cooldown=${settings.reflectionCooldownMinutes}m`;
+        return [
+            "Autonomy status",
+            `Mode: ${autonomy.mode}${autonomy.mode === "full" ? " (standing autonomy)" : ""}`,
+            `Auto Learn: ${settings.enabled ? "enabled" : "disabled"}; model=${settings.model}; applyHighConfidence=${settings.applyHighConfidence}`,
+            `Long-session trigger: ${settings.longSessionMessages} messages or ${settings.longSessionContextPercent}% context; cooldown=${settings.cooldownMinutes}m`,
+            reflectionLine,
+            `Running learners: ${running.length}/${settings.maxConcurrentLearners}`,
+            `Standing authority: ${safety}`,
+            `Audit/log dir: ${this.getAutoLearnDataDir()}`,
+            "Use /autonomy off|safe|balanced|full to switch presets. Advanced overrides remain in /settings → Auto Learn Advanced.",
+        ].join("\n");
+    }
+    applyAutonomyMode(mode, scope = "global") {
+        const currentAutoLearn = this.settingsManager.getAutoLearnSettings();
+        const preset = this.getAutoLearnPresetForAutonomyMode(mode, currentAutoLearn);
+        this.settingsManager.setAutonomySettings({ mode }, scope);
+        this.settingsManager.setAutoLearnSettings(preset, scope);
+        this.updateAutoLearnFooter();
+    }
+    handleAutonomyCommand(text) {
+        const action = text.slice("/autonomy".length).trim() || "status";
+        if (AUTONOMY_MODES.includes(action)) {
+            const mode = action;
+            this.applyAutonomyMode(mode);
+            this.showStatus(`Autonomy mode set to ${mode}${mode === "full" ? " (standing autonomy)" : ""}.`);
+            return;
+        }
+        if (action === "status") {
+            this.chatContainer.addChild(new Spacer(1));
+            this.chatContainer.addChild(new Text(this.formatAutonomyStatus(), 1, 0));
+            this.ui.requestRender();
+            return;
+        }
+        this.showStatus("Usage: /autonomy [status|off|safe|balanced|full]");
+    }
+    handleAutoLearnCommand(text) {
+        const action = text.slice("/auto-learn".length).trim() || "status";
+        if (action === "run" || action === "now" || action === "run-now") {
+            this.showStatus(this.launchAutoLearn("manual", true));
+            return;
+        }
+        if (action === "status") {
+            this.chatContainer.addChild(new Spacer(1));
+            this.chatContainer.addChild(new Text(this.formatAutoLearnStatus(), 1, 0));
+            this.ui.requestRender();
+            return;
+        }
+        this.showStatus("Usage: /auto-learn [status|run]");
+    }
     showSettingsSelector() {
         this.showSelector((done) => {
+            const projectSettings = this.settingsManager.getProjectSettings();
             const selector = new SettingsSelectorComponent({
                 autoCompact: this.session.autoCompactionEnabled,
                 showImages: this.settingsManager.getShowImages(),
@@ -3289,6 +3987,16 @@ export class InteractiveMode {
                 clearOnShrink: this.settingsManager.getClearOnShrink(),
                 showTerminalProgress: this.settingsManager.getShowTerminalProgress(),
                 warnings: this.settingsManager.getWarnings(),
+                selfModification: this.settingsManager.getSelfModificationSettings(),
+                selfModificationScope: projectSettings.selfModification ? "project" : "global",
+                autonomy: this.settingsManager.getAutonomySettings(),
+                autonomyScope: projectSettings.autonomy ? "project" : "global",
+                autoLearn: this.settingsManager.getAutoLearnSettings(),
+                autoLearnScope: projectSettings.autoLearn ? "project" : "global",
+                autoLearnModelOptions: this.getAutoLearnModelOptions(),
+                currentModelPattern: this.session.model
+                    ? `${this.session.model.provider}/${this.session.model.id}`
+                    : undefined,
             }, {
                 onAutoCompactChange: (enabled) => {
                     this.session.setAutoCompactionEnabled(enabled);
@@ -3409,6 +4117,27 @@ export class InteractiveMode {
                 onWarningsChange: (warnings) => {
                     this.settingsManager.setWarnings(warnings);
                 },
+                onSelfModificationChange: (settings, scope) => {
+                    this.settingsManager.setSelfModificationSettings(settings, scope);
+                    const validationMessage = this.validateSelfModificationSource(settings);
+                    if (validationMessage) {
+                        this.showWarning(validationMessage);
+                    }
+                    this.showStatus(`Self modification settings saved to ${scope}. Start a new session or /reload for system-prompt guardrails to fully refresh.`);
+                },
+                onAutonomyChange: (settings, scope) => {
+                    this.applyAutonomyMode(settings.mode ?? "off", scope);
+                    this.showStatus(`Autonomy mode ${settings.mode ?? "off"} saved to ${scope}. Use /autonomy status.`);
+                },
+                onAutoLearnChange: (settings, scope) => {
+                    this.settingsManager.setAutoLearnSettings(settings, scope);
+                    const validationMessage = this.validateAutoLearnModelValue(settings.model);
+                    if (validationMessage) {
+                        this.showWarning(validationMessage);
+                    }
+                    this.updateAutoLearnFooter();
+                    this.showStatus(`Auto Learn settings saved to ${scope}. Use /auto-learn status or /auto-learn run.`);
+                },
                 onCancel: () => {
                     done();
                     this.ui.requestRender();