@caupulican/pi-adaptative 0.81.37 → 0.81.39

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

@@ -16,7 +16,8 @@ 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 { getPendingReloadBlockers } from "../../core/reload-blockers.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";
 import { theme } from "./theme/theme.js";
 const AUTO_LEARN_DEFAULTS = {
@@ -35,31 +36,31 @@ const AUTO_LEARN_DEFAULTS = {
     complexTaskToolCalls: 12,
 };
 const AUTONOMY_AUTO_LEARN_PRESETS = {
-    off: { ...AUTO_LEARN_DEFAULTS, enabled: false, reflectionReview: false },
+    off: { ...AUTO_LEARN_DEFAULTS, enabled: true, reflectionReview: true },
     safe: {
         ...AUTO_LEARN_DEFAULTS,
-        enabled: false,
+        enabled: true,
         longSessionMessages: 64,
         longSessionContextPercent: 85,
         cooldownMinutes: 24 * 60,
         leaseMinutes: 60,
         maxConcurrentLearners: 1,
         applyHighConfidence: false,
-        reflectionReview: false,
+        reflectionReview: true,
         reflectionMinToolCalls: 12,
         reflectionCooldownMinutes: 24 * 60,
         complexTaskToolCalls: 12,
     },
     balanced: {
         ...AUTO_LEARN_DEFAULTS,
-        enabled: false,
+        enabled: true,
         longSessionMessages: 64,
         longSessionContextPercent: 85,
         cooldownMinutes: 24 * 60,
         leaseMinutes: 90,
         maxConcurrentLearners: 1,
         applyHighConfidence: false,
-        reflectionReview: false,
+        reflectionReview: true,
         reflectionMinToolCalls: 12,
         reflectionCooldownMinutes: 24 * 60,
         complexTaskToolCalls: 12,
@@ -245,6 +246,12 @@ export class AutoLearnController {
     _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) {
         this.deps = deps;
@@ -1037,7 +1044,7 @@ export class AutoLearnController {
         return { ...base, shouldRun: false, reason: "reflection thresholds not met" };
     }
     /**
-     * Native reflection (R2) is the in-process replacement for the buggy `continuous-learning`
+     * Native reflection is the in-process replacement for the buggy `continuous-learning`
      * subprocess. It runs when auto-learn is enabled and is not killed via `PI_NATIVE_REFLECTION=0`.
      */
     isNativeReflectionEnabled() {
@@ -1093,7 +1100,33 @@ export class AutoLearnController {
         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
+     * violation first reaches the threshold — delivers a ONE-LINE advisory harness note through the
+     * session's existing next-turn message surface (`sendCustomMessage(..., {deliverAs:"nextTurn"})`,
+     * the same mechanism `_pendingNextTurnMessages` already injects `memory_context`/
+     * `task_steps_context` pages through). Zero model calls; a delivery failure is swallowed so this
+     * best-effort nudge can never disrupt the turn.
+     *
+     * Called from both `maybeRunNativeReflection` and `maybeStartAutoLearn` — the mutually exclusive
+     * `agent_end` branches in interactive-mode.ts — so it runs on every turn regardless of whether
+     * native reflection or legacy auto-learn is enabled, without adding a new turn-boundary hook.
+     */
+    checkTaskStepsContractNudge() {
+        const state = this.session.getTaskStepsStateSnapshot();
+        const outcome = checkTaskStepsContract(state, this._taskContractStreak);
+        this._taskContractStreak = outcome.streak;
+        if (!outcome.note)
+            return;
+        void this.session
+            .sendCustomMessage({ customType: "task_contract_nudge", content: outcome.note, display: false }, { deliverAs: "nextTurn" })
+            .catch(() => {
+            // Advisory-only harness note; delivery failure must never disrupt the session.
+        });
+    }
     maybeRunNativeReflection(messages) {
+        this.checkTaskStepsContractNudge();
         if (!this.isNativeReflectionEnabled())
             return;
         const settings = this.getEffectiveAutoLearnSettings();
@@ -1167,6 +1200,9 @@ export class AutoLearnController {
         });
     }
     maybeStartAutoLearn() {
+        // The other mutually exclusive `agent_end` branch (see `checkTaskStepsContractNudge`) — runs
+        // unconditionally here so the contract nudge fires every turn regardless of auto-learn settings.
+        this.checkTaskStepsContractNudge();
         if (process.env.PI_AUTO_LEARN_CHILD === "1")
             return false;
         const decision = this.evaluateAutoLearn(false);
@@ -1239,10 +1275,16 @@ export class AutoLearnController {
         const reloadBlockerLines = reloadBlockers.pending
             ? reloadBlockers.descriptions.map((description) => `- ${description}`).join("\n")
             : "- none";
+        // In-process quiesce registry (background lanes, scout runs, isolated completions) — the
+        // reload gate's OTHER source of blockers, distinct from the cross-process ones above.
+        const inFlightWork = getInFlightWorkUnits(getAgentDir());
+        const inFlightWorkLines = inFlightWork.length
+            ? inFlightWork.map((unit) => `- ${describeInFlightWorkUnit(unit)}`).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})\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}`;
+        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}\nIn-process reload-gate work: ${inFlightWork.length ? `${inFlightWork.length} unit(s)` : "none"}\n${inFlightWorkLines}\nRuns:\n${runLines}`;
     }
 }
 //# sourceMappingURL=auto-learn-controller.js.map