@caupulican/pi-adaptative 0.81.42 → 0.81.43

package/dist/modes/interactive/auto-learn-controller.js

@@ -3,7 +3,7 @@
  *
  * Extracted verbatim from interactive-mode.ts (god-file decomposition). Owns the disk-backed
  * Auto Learn run-state machine (state.json + lockfile), the background-learner spawn/prune
- * lifecycle, and the in-process native reflection pass. It takes narrow deps (a live session
+ * lifecycle, and the interactive task-contract nudge. It takes narrow deps (a live session
  * accessor, a self-modification-source resolver that stays in the host, and a small UI callback
  * surface) rather than the whole InteractiveMode instance.
  */
@@ -15,7 +15,8 @@ import { spawn } from "child_process";
 import lockfile from "proper-lockfile";
 import { getAgentDir } from "../../config.js";
 import { readAutoLearnSessionIdFromFile, reportCompletedAutoLearnUsageHelper } from "../../core/cost/session-usage.js";
-import { resolveCliModel } from "../../core/model-resolver.js";
+import { analyzeReflectionTurn } from "../../core/learning/reflection-turn-analysis.js";
+import { isProcessAlive } from "../../core/process-liveness.js";
 import { describeInFlightWorkUnit, getInFlightWorkUnits, getPendingReloadBlockers, } from "../../core/reload-blockers.js";
 import { checkTaskStepsContract, INITIAL_TASK_CONTRACT_STREAK, } from "../../core/tasks/task-contract-monitor.js";
 import { getProcessWorkRun } from "../../utils/work-directory.js";
@@ -133,71 +134,57 @@ function removeAutoLearnArtifactPath(filePath, root) {
 function getAutoLearnSessionIdFromFileName(fileName) {
     return fileName.match(/_(auto-learn-[A-Za-z0-9._-]+)\.jsonl$/)?.[1];
 }
-function pruneAutoLearnSessionFiles(dir, activeSessionIds, now, retentionMs, result) {
-    let entries;
+function readAutoLearnDirectoryEntries(dir) {
     try {
-        entries = fs.readdirSync(dir, { withFileTypes: true });
+        return fs.readdirSync(dir, { withFileTypes: true });
     }
     catch {
-        return;
+        return [];
     }
-    for (const entry of entries) {
-        const filePath = path.join(dir, entry.name);
-        if (entry.isDirectory()) {
-            pruneAutoLearnSessionFiles(filePath, activeSessionIds, now, retentionMs, result);
-            continue;
-        }
-        if (!entry.isFile() || !entry.name.endsWith(".jsonl"))
-            continue;
-        let shouldPrune = false;
-        try {
-            shouldPrune = isOldAutoLearnArtifact(filePath, now, retentionMs);
-        }
-        catch {
-            result.errors++;
-            continue;
+}
+function visitAutoLearnFiles(root, visit) {
+    const pendingDirectories = [root];
+    while (pendingDirectories.length > 0) {
+        const dir = pendingDirectories.pop();
+        for (const entry of readAutoLearnDirectoryEntries(dir)) {
+            const filePath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                pendingDirectories.push(filePath);
+            }
+            else if (entry.isFile()) {
+                visit(filePath, entry.name);
+            }
         }
-        if (!shouldPrune)
-            continue;
-        const sessionId = readAutoLearnSessionIdFromFile(filePath) ?? getAutoLearnSessionIdFromFileName(entry.name);
-        if (!sessionId || !isAutoLearnSessionId(sessionId) || activeSessionIds.has(sessionId))
-            continue;
-        removeOldAutoLearnArtifact(filePath, result, "sessionFiles");
     }
 }
-function pruneAutoLearnRunArtifacts(dir, activeRunIds, now, retentionMs, result) {
-    let entries;
+function shouldPruneAutoLearnArtifact(filePath, now, retentionMs, result) {
     try {
-        entries = fs.readdirSync(dir, { withFileTypes: true });
+        return isOldAutoLearnArtifact(filePath, now, retentionMs);
     }
     catch {
-        return;
+        result.errors++;
+        return false;
     }
-    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;
-        const logRunId = entry.name.endsWith(".log") ? entry.name.slice(0, -".log".length) : undefined;
+}
+function pruneAutoLearnSessionFiles(dir, activeSessionIds, now, retentionMs, result) {
+    visitAutoLearnFiles(dir, (filePath, fileName) => {
+        if (!fileName.endsWith(".jsonl") || !shouldPruneAutoLearnArtifact(filePath, now, retentionMs, result))
+            return;
+        const sessionId = readAutoLearnSessionIdFromFile(filePath) ?? getAutoLearnSessionIdFromFileName(fileName);
+        if (!sessionId || !isAutoLearnSessionId(sessionId) || activeSessionIds.has(sessionId))
+            return;
+        removeOldAutoLearnArtifact(filePath, result, "sessionFiles");
+    });
+}
+function pruneAutoLearnRunArtifacts(dir, activeRunIds, now, retentionMs, result) {
+    visitAutoLearnFiles(dir, (filePath, fileName) => {
+        const promptRunId = fileName.endsWith(".prompt.md") ? fileName.slice(0, -".prompt.md".length) : undefined;
+        const logRunId = fileName.endsWith(".log") ? fileName.slice(0, -".log".length) : undefined;
         const runId = promptRunId ?? logRunId;
-        if (!runId || activeRunIds.has(runId))
-            continue;
-        let shouldPrune = false;
-        try {
-            shouldPrune = isOldAutoLearnArtifact(filePath, now, retentionMs);
-        }
-        catch {
-            result.errors++;
-            continue;
-        }
-        if (!shouldPrune)
-            continue;
+        if (!runId || activeRunIds.has(runId) || !shouldPruneAutoLearnArtifact(filePath, now, retentionMs, result))
+            return;
         removeOldAutoLearnArtifact(filePath, result, promptRunId ? "promptFiles" : "logFiles");
-    }
+    });
 }
 export function pruneAutoLearnConversationHistory(options) {
     const result = { promptFiles: 0, logFiles: 0, sessionFiles: 0, errors: 0 };
@@ -235,39 +222,18 @@ export function findAutoLearnSpawnNullByteInput(command, args) {
     return argIndex === -1 ? undefined : `args[${argIndex}]`;
 }
 export class AutoLearnController {
-    // Native-reflection debounce: prevents back-to-back/overlapping background reflection passes (cost
-    // guard). `_nativeReflectionInFlight` blocks a second pass while one runs; `_lastNativeReflectionAt`
-    // enforces a minimum gap between passes. A debounce-skipped turn's text is BUFFERED in
-    // `_pendingReflectionText` (not dropped) and folded into the next pass, so no corrective feedback is
-    // lost — reflection sees only the current turn's messages, so dropping a skipped turn would lose its
-    // learning entirely (bug #29).
-    _nativeReflectionInFlight = false;
-    _lastNativeReflectionAt = 0;
-    _pendingReflectionText = [];
-    static NATIVE_REFLECTION_MIN_INTERVAL_MS = 45_000;
-    static PENDING_REFLECTION_MAX_CHARS = 12_000;
-    // Cheap turn-boundary task_steps contract nudge. Tracks the consecutive-violation streak
-    // across turns so `checkTaskStepsContractNudge` (invoked from the existing per-turn `agent_end`
-    // pass below) can fire exactly one advisory harness note per sustained-violation streak. No model
-    // calls; best-effort coupling to whichever per-turn branch runs (native reflection or the
-    // auto-learn/autonomy-review pair) — see `checkTaskStepsContractNudge` for the rationale.
-    _taskContractStreak = INITIAL_TASK_CONTRACT_STREAK;
-    deps;
     constructor(deps) {
+        // Cheap turn-boundary task_steps contract nudge. Tracks the consecutive-violation streak
+        // across turns so `checkTaskStepsContractNudge` (invoked from the existing per-turn `agent_end`
+        // pass below) can fire exactly one advisory harness note per sustained-violation streak. No model
+        // calls; best-effort coupling to whichever per-turn branch runs (native reflection or the
+        // auto-learn/autonomy-review pair) — see `checkTaskStepsContractNudge` for the rationale.
+        this._taskContractStreak = INITIAL_TASK_CONTRACT_STREAK;
         this.deps = deps;
     }
     get session() {
         return this.deps.getSession();
     }
-    get sessionManager() {
-        return this.deps.getSession().sessionManager;
-    }
-    get settingsManager() {
-        return this.deps.getSession().settingsManager;
-    }
-    get ui() {
-        return this.deps.ui;
-    }
     getAutoLearnModelAuthPriority(model) {
         if (this.session.model && model.provider === this.session.model.provider && model.id === this.session.model.id) {
             return 0;
@@ -419,16 +385,7 @@ export class AutoLearnController {
         }
     }
     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";
-        }
+        return isProcessAlive(pid);
     }
     pruneAutoLearnState(state, now = Date.now()) {
         const runs = { ...(state.runs ?? {}) };
@@ -467,8 +424,8 @@ export class AutoLearnController {
         return { ...preset, model: current.model?.trim() || preset.model };
     }
     getEffectiveAutoLearnSettings() {
-        const settings = this.settingsManager.getAutoLearnSettings();
-        const preset = this.getAutoLearnPresetForAutonomyMode(this.settingsManager.getAutonomySettings().mode, settings);
+        const settings = this.session.settingsManager.getAutoLearnSettings();
+        const preset = this.getAutoLearnPresetForAutonomyMode(this.session.settingsManager.getAutonomySettings().mode, settings);
         return {
             enabled: settings.enabled ?? preset.enabled,
             model: settings.model?.trim() || preset.model,
@@ -489,10 +446,14 @@ export class AutoLearnController {
         return this.getEffectiveAutoLearnSettings();
     }
     getAutoLearnTenantKey() {
-        return `${this.sessionManager.getCwd()}::${this.session.sessionId}`;
+        return `${this.session.sessionManager.getCwd()}::${this.session.sessionId}`;
     }
     getAutoLearnTenantId() {
-        const cwdHash = crypto.createHash("sha256").update(this.sessionManager.getCwd()).digest("hex").slice(0, 8);
+        const cwdHash = crypto
+            .createHash("sha256")
+            .update(this.session.sessionManager.getCwd())
+            .digest("hex")
+            .slice(0, 8);
         const sessionPart = sanitizeAutoLearnPathPart(this.session.sessionId, "session");
         return `${sessionPart}-${cwdHash}`;
     }
@@ -500,7 +461,7 @@ export class AutoLearnController {
         return path.join(this.getAutoLearnDataDir(), "tenants", this.getAutoLearnTenantId());
     }
     getAutoLearnMessageCount() {
-        return this.sessionManager.getBranch().filter((entry) => entry.type === "message").length;
+        return this.session.sessionManager.getBranch().filter((entry) => entry.type === "message").length;
     }
     buildAutoLearnDecisionFromState(state, settings, force = false) {
         const now = Date.now();
@@ -618,8 +579,8 @@ export class AutoLearnController {
         });
     }
     buildAutonomyAuthorityPrompt() {
-        const autonomy = this.settingsManager.getAutonomySettings();
-        const selfModification = this.settingsManager.getSelfModificationSettings();
+        const autonomy = this.session.settingsManager.getAutonomySettings();
+        const selfModification = this.session.settingsManager.getSelfModificationSettings();
         if (autonomy.mode !== "full") {
             return [
                 "Authority mode: proposal-gated.",
@@ -676,14 +637,14 @@ export class AutoLearnController {
                 reason: params.reason,
                 startedAt: now,
                 expiresAt: now + AUTO_LEARN_RESERVATION_MS,
-                cwd: this.sessionManager.getCwd(),
+                cwd: this.session.sessionManager.getCwd(),
                 logPath: params.logPath,
                 sessionDir: params.sessionDir,
                 sessionId: params.sessionId,
                 promptPath: params.promptPath,
                 kind: params.kind,
-                autonomyMode: this.settingsManager.getAutonomySettings().mode,
-                authority: this.settingsManager.getAutonomySettings().mode === "full"
+                autonomyMode: this.session.settingsManager.getAutonomySettings().mode,
+                authority: this.session.settingsManager.getAutonomySettings().mode === "full"
                     ? "standing-full-autonomous"
                     : "proposal-gated",
                 status: "reserved",
@@ -843,9 +804,9 @@ export class AutoLearnController {
         let outFd;
         try {
             outFd = fs.openSync(logPath, "a");
-            const sourceSessionFile = this.sessionManager.getSessionFile();
+            const sourceSessionFile = this.session.sessionManager.getSessionFile();
             child = spawn(spawnTarget.command, args, {
-                cwd: this.sessionManager.getCwd(),
+                cwd: this.session.sessionManager.getCwd(),
                 detached: true,
                 stdio: ["ignore", outFd, outFd],
                 env: {
@@ -897,76 +858,11 @@ export class AutoLearnController {
         this.updateAutoLearnFooter();
         return `Auto Learn started. 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 complexTaskThreshold = Math.max(1, settings.complexTaskToolCalls ?? 12);
+        const turn = analyzeReflectionTurn(messages, complexTaskThreshold);
+        const digest = turn.recentTurnText || "[No textual turn digest available.]";
         const state = this.withAutoLearnStateLock((current) => {
             const pruned = this.pruneAutoLearnHistoryFromState(current);
             return { result: pruned, next: pruned };
@@ -979,15 +875,11 @@ export class AutoLearnController {
         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 toolCalls = turn.toolCallCount;
+        const userText = turn.userText;
+        const correctionSignal = turn.hadCorrection;
         const behavioralSelfImprovementSignal = /\b(harness|pi|agent|autonomy|autonomous|self[- ]?improv(?:e|ement|ing)?|steer(?:ing)?|trigger(?:s)?|skill(?:s)?|code[- ]?bak(?:e|ed)|bake(?:d)? into code|not (?:automata|memory)|reference agent|hermes)\b/i.test(userText) &&
             /\b(improve|automatic(?:ally)?|autonomous|trigger|fire|skill|steer|self[- ]?improv(?:e|ement|ing)?|code[- ]?bak(?:e|ed)|bake(?:d)?|too much|less)\b/i.test(userText);
-        const complexTaskThreshold = Math.max(1, settings.complexTaskToolCalls ?? 12);
         const complexTaskSignal = toolCalls >= complexTaskThreshold;
         const bypassCooldown = correctionSignal || behavioralSelfImprovementSignal || complexTaskSignal;
         const base = { messageCount, contextPercent, cooldownRemainingMs, runningCount, toolCalls };
@@ -1010,7 +902,7 @@ export class AutoLearnController {
                 ...base,
                 shouldRun: true,
                 reason: "reflection behavioral self-improvement signal",
-                digest: this.buildAutonomyReviewDigest(messages),
+                digest,
                 bypassCooldown: true,
             };
         }
@@ -1019,7 +911,7 @@ export class AutoLearnController {
                 ...base,
                 shouldRun: true,
                 reason: "reflection correction signal",
-                digest: this.buildAutonomyReviewDigest(messages),
+                digest,
                 bypassCooldown: true,
             };
         }
@@ -1028,7 +920,7 @@ export class AutoLearnController {
                 ...base,
                 shouldRun: true,
                 reason: `reflection complex task learning signal (${toolCalls}/${complexTaskThreshold} tool calls)`,
-                digest: this.buildAutonomyReviewDigest(messages),
+                digest,
                 bypassCooldown: true,
             };
         }
@@ -1038,7 +930,7 @@ export class AutoLearnController {
                 ...base,
                 shouldRun: true,
                 reason: `reflection tool trigger (${toolCalls}/${settings.reflectionMinToolCalls})`,
-                digest: this.buildAutonomyReviewDigest(messages),
+                digest,
             };
         }
         return { ...base, shouldRun: false, reason: "reflection thresholds not met" };
@@ -1054,52 +946,6 @@ export class AutoLearnController {
             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.
-     */
-    /**
-     * Resolve the model + thinking level the native reflection pass should use, from auto-learn
-     * settings (`model`, `thinkingLevel`). The configured model is honored only when its provider is
-     * AVAILABLE (api key / logged in) — otherwise we fall back to the session model (undefined). This
-     * lets the user pick a balanced/cheaper reflection model without risking an unusable one.
-     */
-    _resolveReflectionModel(settings) {
-        let model;
-        if (settings.model && settings.model !== "active") {
-            const resolved = resolveCliModel({ cliModel: settings.model, modelRegistry: this.session.modelRegistry });
-            if (resolved.model && this.session.modelRegistry.hasConfiguredAuth(resolved.model)) {
-                model = resolved.model;
-            }
-        }
-        const thinkingLevel = settings.thinkingLevel ?? "low";
-        return { model, thinkingLevel };
-    }
-    /** Buffer a debounce-skipped turn's text so its learning is folded into the next pass (bug #29). */
-    _bufferPendingReflection(text) {
-        const t = text.trim();
-        if (!t)
-            return;
-        this._pendingReflectionText.push(t);
-        // Bound the buffer so a long skipped streak can't grow unbounded; drop oldest past the budget
-        // (the most recent corrections matter most).
-        let total = this._pendingReflectionText.reduce((n, s) => n + s.length + 1, 0);
-        while (this._pendingReflectionText.length > 1 && total > AutoLearnController.PENDING_REFLECTION_MAX_CHARS) {
-            total -= (this._pendingReflectionText.shift()?.length ?? 0) + 1;
-        }
-    }
-    _drainPendingReflection() {
-        if (this._pendingReflectionText.length === 0)
-            return "";
-        const joined = this._pendingReflectionText.join("\n");
-        this._pendingReflectionText = [];
-        return joined;
-    }
     /**
      * Cheap turn-boundary task_steps contract check. Reads the current task_steps snapshot,
      * advances the pure `checkTaskStepsContract` streak, and — on the exact turn a sustained
@@ -1127,77 +973,10 @@ export class AutoLearnController {
     }
     maybeRunNativeReflection(messages) {
         this.checkTaskStepsContractNudge();
-        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");
-        // Debounce (cost guard): never run two background reflection passes at once, and never start one
-        // within the min interval of the last — a multi-turn correction session would otherwise spawn
-        // overlapping passes that re-reason the same task. A skipped turn is NOT dropped: its text is
-        // buffered and folded into the next pass, so the corrective feedback is still learned (bug #29).
-        const now = Date.now();
-        const debounced = this._nativeReflectionInFlight ||
-            now - this._lastNativeReflectionAt < AutoLearnController.NATIVE_REFLECTION_MIN_INTERVAL_MS;
-        if (debounced) {
-            this._bufferPendingReflection(recentTurnText);
-            return;
-        }
-        // Fold any buffered (previously debounced) turns into this pass so nothing learned is lost.
-        const pending = this._drainPendingReflection();
-        const reflectionText = pending ? `${pending}\n${recentTurnText}` : recentTurnText;
-        // Stable per-turn id so a duplicate scheduling/retry can't double-count the reflection cost.
-        // AgentMessage does not guarantee a top-level id on the real path, so derive a digest from fields
-        // that are present on persisted user/assistant messages and stable across duplicate agent_end calls.
-        const turnDigest = crypto
-            .createHash("sha256")
-            .update(messages
-            .map((message) => [
-            message.role,
-            "timestamp" in message ? String(message.timestamp ?? "") : "",
-            this.getAgentMessagePlainText(message),
-        ].join("\0"))
-            .join("\n"))
-            .digest("hex")
-            .slice(0, 24);
-        const reportId = `reflection:${turnDigest}`;
-        // User-configurable reflection model + thinking (auto-learn settings), restricted to AVAILABLE
-        // (authed) models — falls back to the session model when unset or unavailable.
-        const { model, thinkingLevel } = this._resolveReflectionModel(settings);
-        this._nativeReflectionInFlight = true;
-        this._lastNativeReflectionAt = now;
-        void this.session
-            .runReflectionPass({
-            signals: { trigger, toolCallCount, hadCorrection, contextHeadroomPct, usefulLately: 0 },
-            recentTurnText: reflectionText,
-            reportId,
-            model,
-            thinkingLevel,
-        })
-            .catch(() => {
-            // best-effort background learning; never disrupt the session
-        })
-            .finally(() => {
-            this._nativeReflectionInFlight = false;
-        });
+        // Reflection scheduling is session-owned in AgentSession/ReflectionController so print, RPC,
+        // and interactive modes share one deduplicated lifecycle. This interactive hook only owns the
+        // task-contract nudge; keeping the argument preserves the host interface without a parallel path.
+        void messages;
     }
     maybeStartAutoLearn() {
         // The other mutually exclusive `agent_end` branch (see `checkTaskStepsContractNudge`) — runs
@@ -1212,7 +991,7 @@ export class AutoLearnController {
         }
         const message = this.launchAutoLearn(decision.reason, false);
         if (!message.startsWith("Auto Learn started"))
-            this.ui.showStatus(message);
+            this.deps.ui.showStatus(message);
         return message.startsWith("Auto Learn started");
     }
     maybeStartAutonomyReview(messages) {
@@ -1228,21 +1007,21 @@ export class AutoLearnController {
             bypassReflectionCooldown: decision.bypassCooldown,
         });
         if (!message.startsWith("Auto Learn started"))
-            this.ui.showStatus(message);
+            this.deps.ui.showStatus(message);
         return message.startsWith("Auto Learn started");
     }
     updateAutoLearnFooter() {
         const settings = this.getEffectiveAutoLearnSettings();
         if (!settings.enabled) {
-            this.ui.footerDataProvider.setExtensionStatus("auto-learn", undefined);
+            this.deps.ui.footerDataProvider.setExtensionStatus("auto-learn", undefined);
             return;
         }
         const tenant = this.getAutoLearnTenantKey();
         const state = this.getPrunedAutoLearnState();
         const hasActiveRun = Object.values(state.runs ?? {}).some((run) => run.tenant === tenant && this.isAutoLearnPidAlive(run.pid));
-        this.ui.footerDataProvider.setExtensionStatus("auto-learn", hasActiveRun ? theme.fg("warning", "(learning)") : undefined);
-        this.ui.invalidateFooter();
-        this.ui.requestRender();
+        this.deps.ui.footerDataProvider.setExtensionStatus("auto-learn", hasActiveRun ? theme.fg("warning", "(learning)") : undefined);
+        this.deps.ui.invalidateFooter();
+        this.deps.ui.requestRender();
     }
     formatAutoLearnStatus() {
         const settings = this.getEffectiveAutoLearnSettings();
@@ -1269,8 +1048,8 @@ export class AutoLearnController {
             : "- none";
         const reloadBlockers = getPendingReloadBlockers({
             ownPid: process.pid,
-            ownSessionId: this.sessionManager.getSessionId(),
-            ownSessionFile: this.sessionManager.getSessionFile(),
+            ownSessionId: this.session.sessionManager.getSessionId(),
+            ownSessionFile: this.session.sessionManager.getSessionFile(),
         });
         const reloadBlockerLines = reloadBlockers.pending
             ? reloadBlockers.descriptions.map((description) => `- ${description}`).join("\n")