@caupulican/pi-adaptative 0.80.7 → 0.80.9

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

@@ -26,6 +26,7 @@ import { formatMissingSessionCwdPrompt, MissingSessionCwdError } from "../../cor
 import { isAutoLearnSessionId, SessionManager } from "../../core/session-manager.js";
 import { BUILTIN_SLASH_COMMANDS } from "../../core/slash-commands.js";
 import { isInstallTelemetryEnabled } from "../../core/telemetry.js";
+import { hasProjectTrustInputs, ProjectTrustStore } from "../../core/trust-manager.js";
 import { getChangelogPath, getNewEntries, parseChangelog } from "../../utils/changelog.js";
 import { copyToClipboard } from "../../utils/clipboard.js";
 import { readClipboardImage } from "../../utils/clipboard-image.js";
@@ -63,6 +64,7 @@ import { ToolExecutionComponent } from "./components/tool-execution.js";
 import { ToolGroupComponent } from "./components/tool-group.js";
 import { getToolPanelActionKey, ToolPanelRegistry } from "./components/tool-panel-registry.js";
 import { TreeSelectorComponent } from "./components/tree-selector.js";
+import { TrustSelectorComponent } from "./components/trust-selector.js";
 import { UserMessageComponent } from "./components/user-message.js";
 import { UserMessageSelectorComponent } from "./components/user-message-selector.js";
 import { getAvailableThemes, getAvailableThemesWithPaths, getEditorTheme, getMarkdownTheme, getThemeByName, initTheme, onThemeChange, setRegisteredThemes, setTheme, setThemeInstance, stopThemeWatcher, Theme, theme, } from "./theme/theme.js";
@@ -158,6 +160,14 @@ function definedStringSet(values) {
     }
     return set;
 }
+function sanitizeAutoLearnPathPart(input, fallback) {
+    const cleaned = (input || fallback)
+        .replace(/[^a-zA-Z0-9._-]+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 80);
+    return cleaned || fallback;
+}
 function isOldAutoLearnArtifact(filePath, now, retentionMs) {
     const stats = fs.lstatSync(filePath);
     return stats.isFile() && now - stats.mtimeMs > retentionMs;
@@ -171,6 +181,22 @@ function removeOldAutoLearnArtifact(filePath, result, counter) {
         result.errors++;
     }
 }
+function isPathInside(target, root) {
+    const resolvedTarget = path.resolve(target);
+    const resolvedRoot = path.resolve(root);
+    return resolvedTarget === resolvedRoot || resolvedTarget.startsWith(`${resolvedRoot}${path.sep}`);
+}
+function removeAutoLearnArtifactPath(filePath, root) {
+    if (!isPathInside(filePath, root))
+        return false;
+    try {
+        fs.rmSync(filePath, { recursive: true, force: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function readAutoLearnSessionIdFromFile(filePath) {
     let fd;
     try {
@@ -232,24 +258,20 @@ function pruneAutoLearnSessionFiles(dir, activeSessionIds, now, retentionMs, res
         removeOldAutoLearnArtifact(filePath, result, "sessionFiles");
     }
 }
-export function pruneAutoLearnConversationHistory(options) {
-    const result = { promptFiles: 0, logFiles: 0, sessionFiles: 0, errors: 0 };
-    const dataDir = path.resolve(options.dataDir);
-    const now = options.now ?? Date.now();
-    const retentionMs = options.retentionMs ?? AUTO_LEARN_HISTORY_RETENTION_MS;
-    const activeRunIds = definedStringSet(options.activeRunIds);
-    const activeSessionIds = definedStringSet(options.activeSessionIds);
-    if (retentionMs <= 0 || !fs.existsSync(dataDir))
-        return result;
+function pruneAutoLearnRunArtifacts(dir, activeRunIds, now, retentionMs, result) {
     let entries;
     try {
-        entries = fs.readdirSync(dataDir, { withFileTypes: true });
+        entries = fs.readdirSync(dir, { withFileTypes: true });
     }
     catch {
-        result.errors++;
-        return result;
+        return;
     }
     for (const entry of entries) {
+        const filePath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            pruneAutoLearnRunArtifacts(filePath, activeRunIds, now, retentionMs, result);
+            continue;
+        }
         if (!entry.isFile())
             continue;
         const promptRunId = entry.name.endsWith(".prompt.md") ? entry.name.slice(0, -".prompt.md".length) : undefined;
@@ -257,7 +279,6 @@ export function pruneAutoLearnConversationHistory(options) {
         const runId = promptRunId ?? logRunId;
         if (!runId || activeRunIds.has(runId))
             continue;
-        const filePath = path.join(dataDir, entry.name);
         let shouldPrune = false;
         try {
             shouldPrune = isOldAutoLearnArtifact(filePath, now, retentionMs);
@@ -270,7 +291,18 @@ export function pruneAutoLearnConversationHistory(options) {
             continue;
         removeOldAutoLearnArtifact(filePath, result, promptRunId ? "promptFiles" : "logFiles");
     }
-    pruneAutoLearnSessionFiles(path.join(dataDir, "sessions"), activeSessionIds, now, retentionMs, result);
+}
+export function pruneAutoLearnConversationHistory(options) {
+    const result = { promptFiles: 0, logFiles: 0, sessionFiles: 0, errors: 0 };
+    const dataDir = path.resolve(options.dataDir);
+    const now = options.now ?? Date.now();
+    const retentionMs = options.retentionMs ?? AUTO_LEARN_HISTORY_RETENTION_MS;
+    const activeRunIds = definedStringSet(options.activeRunIds);
+    const activeSessionIds = definedStringSet(options.activeSessionIds);
+    if (retentionMs <= 0 || !fs.existsSync(dataDir))
+        return result;
+    pruneAutoLearnRunArtifacts(dataDir, activeRunIds, now, retentionMs, result);
+    pruneAutoLearnSessionFiles(dataDir, activeSessionIds, now, retentionMs, result);
     return result;
 }
 export function buildAutoLearnSpawnArgs(spawnTarget, options) {
@@ -704,6 +736,7 @@ export class InteractiveMode {
         await this.rebindCurrentSession();
         // Render initial messages AFTER showing loaded resources
         this.renderInitialMessages();
+        this.renderProjectTrustWarningIfNeeded();
         // Set up theme file watcher
         onThemeChange(() => {
             this.ui.invalidate();
@@ -718,6 +751,15 @@ export class InteractiveMode {
         await this.updateAvailableProviderCount();
         this.updateAutoLearnFooter();
     }
+    renderProjectTrustWarningIfNeeded() {
+        if (this.settingsManager.isProjectTrusted() || !hasProjectTrustInputs(this.sessionManager.getCwd())) {
+            return;
+        }
+        if (this.chatContainer.children.length > 0) {
+            this.chatContainer.addChild(new Spacer(1));
+        }
+        this.chatContainer.addChild(new Text(theme.fg("warning", "This project is not trusted. Project instructions (AGENTS.md/CLAUDE.md/GEMINI.md), .pi resources, and project packages are ignored. Use /trust to save a trust decision, then restart pi."), 1, 0));
+    }
     /**
      * Update terminal title with session name and cwd.
      */
@@ -2389,6 +2431,11 @@ export class InteractiveMode {
                 this.editor.setText("");
                 return;
             }
+            if (text === "/trust") {
+                this.showTrustSelector();
+                this.editor.setText("");
+                return;
+            }
             if (text === "/login" || text.startsWith("/login ")) {
                 await this.showOAuthSelector("login", text.slice("/login".length).trim() || undefined);
                 this.editor.setText("");
@@ -3759,13 +3806,21 @@ export class InteractiveMode {
     getAutoLearnTenantKey() {
         return `${this.sessionManager.getCwd()}::${this.session.sessionId}`;
     }
+    getAutoLearnTenantId() {
+        const cwdHash = crypto.createHash("sha256").update(this.sessionManager.getCwd()).digest("hex").slice(0, 8);
+        const sessionPart = sanitizeAutoLearnPathPart(this.session.sessionId, "session");
+        return `${sessionPart}-${cwdHash}`;
+    }
+    getAutoLearnTenantDataDir() {
+        return path.join(this.getAutoLearnDataDir(), "tenants", this.getAutoLearnTenantId());
+    }
     getAutoLearnMessageCount() {
         return this.sessionManager.getBranch().filter((entry) => entry.type === "message").length;
     }
     buildAutoLearnDecisionFromState(state, settings, force = false) {
         const now = Date.now();
         const tenant = this.getAutoLearnTenantKey();
-        const runningCount = Object.keys(state.runs ?? {}).length;
+        const runningCount = Object.values(state.runs ?? {}).filter((run) => run.tenant === tenant).length;
         const lastLaunch = state.lastLaunchByTenant?.[tenant] ?? 0;
         const cooldownMs = settings.cooldownMinutes * 60 * 1000;
         const cooldownRemainingMs = Math.max(0, lastLaunch + cooldownMs - now);
@@ -3784,7 +3839,7 @@ export class InteractiveMode {
         if (runningCount >= settings.maxConcurrentLearners) {
             return {
                 shouldRun: false,
-                reason: `max learners running (${runningCount}/${settings.maxConcurrentLearners})`,
+                reason: `max tenant learners running (${runningCount}/${settings.maxConcurrentLearners})`,
                 messageCount,
                 contextPercent,
                 cooldownRemainingMs,
@@ -3926,7 +3981,7 @@ export class InteractiveMode {
         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}`;
+        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. Memory confrontation is mandatory before accepting, merging, upgrading, or rejecting learning candidates.\n2. Run the available Auto Learn tooling, preferably learning_run_auto, with applyHighConfidence=${settings.applyHighConfidence}. Process candidate validation in vectorized chunks/batches; avoid scalar per-candidate memory queries except for final selected writes.\n3. Apply the learning validation tree to each candidate chunk: (a) Why is this good for the user? (b) Is it unique, or similar to existing memory/skills/agents so it should merge or upgrade existing knowledge? (c) Will this make Pi a better agent? Candidates that cannot answer all three are noise.\n4. Treat the latest-turn digest as current-session evidence only; do not auto-commit one-off cues unless deterministic tooling and memory confrontation corroborate them.\n5. In mode=full, apply safe memory/skill/user-extension/authorized-source improvements under the standing grant above; otherwise keep them proposal-gated.\n6. Never cross hard-stop boundaries from the authority policy.\n7. If the learning tools are unavailable, report BLOCKED with the missing tool names and do not improvise.\n8. Finish with PASS, BLOCKED, or FAIL and concise evidence, including chunk counts, merge/upgrade decisions, and cleanup/purge status.${reflectionBlock}`;
     }
     reserveAutoLearnRun(params) {
         return this.withAutoLearnStateLock((current) => {
@@ -3993,6 +4048,20 @@ export class InteractiveMode {
             return { result: undefined, next };
         });
     }
+    cleanupCompletedAutoLearnRun(runId, artifactPaths) {
+        const dataDir = this.getAutoLearnDataDir();
+        const removed = artifactPaths.filter((filePath) => removeAutoLearnArtifactPath(filePath, dataDir)).length;
+        this.withAutoLearnStateLock((current) => {
+            const state = this.pruneAutoLearnState(current);
+            const runs = { ...(state.runs ?? {}) };
+            delete runs[runId];
+            return { result: undefined, next: { ...state, runs } };
+        });
+        if (removed > 0) {
+            this.autoLearnLastStatus = `cleaned ${removed} artifact(s)`;
+            this.updateAutoLearnFooter();
+        }
+    }
     markAutoLearnReservationRunning(reservation, pid, settings) {
         this.withAutoLearnStateLock((current) => {
             const now = Date.now();
@@ -4028,14 +4097,14 @@ export class InteractiveMode {
         if (!spawnTarget) {
             return "Auto Learn not started: could not resolve current pi CLI path.";
         }
-        const dir = this.getAutoLearnDataDir();
+        const dir = this.getAutoLearnTenantDataDir();
         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 kind = options.promptKind ?? "auto";
-        const sessionDir = path.join(dir, "sessions");
-        const sessionId = `auto-learn-${kind}-${runId}`;
+        const sessionDir = path.join(dir, "sessions", runId);
+        const sessionId = `auto-learn-${kind}-${this.getAutoLearnTenantId()}-${runId}`;
         fs.mkdirSync(sessionDir, { recursive: true });
         const prompt = this.buildAutoLearnPrompt(reason, settings, {
             kind,
@@ -4129,6 +4198,10 @@ export class InteractiveMode {
             return `Auto Learn not started: failed to spawn background learner. Log: ${logPath}`;
         }
         const childPid = child.pid;
+        child.once("exit", (code) => {
+            if (code === 0)
+                this.cleanupCompletedAutoLearnRun(reservation.runId, [promptPath, logPath, sessionDir]);
+        });
         child.unref();
         this.markAutoLearnReservationRunning(reservation, childPid, settings);
         this.autoLearnLastStatus = `running ${modelPattern}`;
@@ -4212,7 +4285,7 @@ export class InteractiveMode {
         });
         const now = Date.now();
         const tenant = this.getAutoLearnTenantKey();
-        const runningCount = Object.keys(state.runs ?? {}).length;
+        const runningCount = Object.values(state.runs ?? {}).filter((run) => run.tenant === tenant).length;
         const lastReflection = state.lastReflectionByTenant?.[tenant] ?? 0;
         const cooldownMs = settings.reflectionCooldownMinutes * 60 * 1000;
         const cooldownRemainingMs = Math.max(0, lastReflection + cooldownMs - now);
@@ -4233,7 +4306,7 @@ export class InteractiveMode {
             return {
                 ...base,
                 shouldRun: false,
-                reason: `max learners running (${runningCount}/${settings.maxConcurrentLearners})`,
+                reason: `max tenant learners running (${runningCount}/${settings.maxConcurrentLearners})`,
             };
         }
         if (cooldownRemainingMs > 0)
@@ -4305,7 +4378,9 @@ export class InteractiveMode {
         const settings = this.getEffectiveAutoLearnSettings();
         const decision = this.evaluateAutoLearn(false);
         const state = this.getPrunedAutoLearnState();
-        const runs = Object.entries(state.runs ?? {});
+        const tenant = this.getAutoLearnTenantKey();
+        const runs = Object.entries(state.runs ?? {}).filter(([, run]) => run.tenant === tenant);
+        const otherTenantRuns = Object.values(state.runs ?? {}).filter((run) => run.tenant !== tenant).length;
         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
@@ -4333,13 +4408,15 @@ export class InteractiveMode {
         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})\nHistory retention: 7 days for internal Auto Learn prompts/logs/sessions\nRunning leases: ${runs.length}/${settings.maxConcurrentLearners}\nPi auto-reload blockers: ${reloadBlockers.pending ? reloadBlockers.reason : "none"}\n${reloadBlockerLines}\nRuns:\n${runLines}`;
+        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})\nHistory retention: 7 days for internal Auto Learn prompts/logs/sessions\nRunning tenant leases: ${runs.length}/${settings.maxConcurrentLearners}\nOther tenant leases: ${otherTenantRuns}\nTenant artifact dir: ${this.getAutoLearnTenantDataDir()}\nPi auto-reload blockers: ${reloadBlockers.pending ? reloadBlockers.reason : "none"}\n${reloadBlockerLines}\nRuns:\n${runLines}`;
     }
     formatAutonomyStatus() {
         const autonomy = this.settingsManager.getAutonomySettings();
         const settings = this.getEffectiveAutoLearnSettings();
         const autoLearnState = this.getPrunedAutoLearnState();
-        const running = Object.entries(autoLearnState.runs ?? {});
+        const tenant = this.getAutoLearnTenantKey();
+        const running = Object.entries(autoLearnState.runs ?? {}).filter(([, run]) => run.tenant === tenant);
+        const otherTenantRunning = Object.values(autoLearnState.runs ?? {}).filter((run) => run.tenant !== tenant).length;
         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";
@@ -4352,10 +4429,12 @@ export class InteractiveMode {
             `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}`,
+            `Running tenant learners: ${running.length}/${settings.maxConcurrentLearners}`,
+            `Other tenant learners: ${otherTenantRunning}`,
             "History retention: 7 days for internal Auto Learn prompts/logs/sessions",
             `Standing authority: ${safety}`,
             `Audit/log dir: ${this.getAutoLearnDataDir()}`,
+            `Tenant artifact dir: ${this.getAutoLearnTenantDataDir()}`,
             "Use /autonomy off|safe|balanced|full to switch presets. Advanced overrides remain in /settings → Auto Learn Advanced.",
         ].join("\n");
     }
@@ -4918,6 +4997,28 @@ export class InteractiveMode {
             return { component: selector, focus: selector };
         });
     }
+    showTrustSelector() {
+        const cwd = this.sessionManager.getCwd();
+        const trustStore = new ProjectTrustStore(this.runtimeHost.services.agentDir);
+        const savedDecision = trustStore.get(cwd);
+        this.showSelector((done) => {
+            const selector = new TrustSelectorComponent({
+                cwd,
+                savedDecision,
+                projectTrusted: this.settingsManager.isProjectTrusted(),
+                onSelect: (trusted) => {
+                    trustStore.set(cwd, trusted);
+                    done();
+                    this.showStatus(`Saved trust decision: ${trusted ? "trusted" : "untrusted"}. Restart pi for this to take effect.`);
+                },
+                onCancel: () => {
+                    done();
+                    this.ui.requestRender();
+                },
+            });
+            return { component: selector, focus: selector };
+        });
+    }
     showSessionSelector() {
         this.showSelector((done) => {
             const selector = new SessionSelectorComponent((onProgress) => SessionManager.list(this.sessionManager.getCwd(), this.sessionManager.getSessionDir(), onProgress), (onProgress) => this.sessionManager.usesDefaultSessionDir()