@caupulican/pi-adaptative 0.80.98 → 0.80.100

package/dist/core/agent-session.js

@@ -21,6 +21,7 @@ import { stripFrontmatter } from "../utils/frontmatter.js";
 import { resolvePath } from "../utils/paths.js";
 import { sleep } from "../utils/sleep.js";
 import { formatNoApiKeyFoundMessage, formatNoModelSelectedMessage } from "./auth-guidance.js";
+import { buildForegroundEnvelope, formatForegroundEnvelopeObservation } from "./autonomy/foreground-envelope.js";
 import { evaluateToolGate } from "./autonomy/gates.js";
 import { LaneTracker } from "./autonomy/lane-tracker.js";
 import { appendLaneRecordSnapshot, getLaneRecordSnapshots } from "./autonomy/session-lane-record.js";
@@ -45,6 +46,7 @@ import { aggregateDailyUsageFromSessionFiles, aggregateDailyUsageFromSessionRoot
 import { downgradeReasoning, estimateTurnCostUsd, evaluateCostGuard } from "./cost-guard.js";
 import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
 import { appendWorkerResultSnapshot, getWorkerResultSnapshots } from "./delegation/session-worker-result.js";
+import { applyWorkerActions } from "./delegation/worker-actions.js";
 import { runWorker } from "./delegation/worker-runner.js";
 import { exportSessionToHtml } from "./export-html/index.js";
 import { createToolHtmlRenderer } from "./export-html/tool-renderer.js";
@@ -68,7 +70,7 @@ import { FileStoreProvider } from "./memory/providers/file-store.js";
 import { TranscriptRecallProvider } from "./memory/providers/transcript-recall.js";
 import { compactToolResultDetailsForRetention } from "./message-retention.js";
 import { createCustomMessage } from "./messages.js";
-import { deriveModelCapabilityProfile, filterToolNamesForCapability, } from "./model-capability.js";
+import { deriveModelCapabilityProfile, filterToolNamesForCapability, scaleContinuationBudgetsForCapability, } from "./model-capability.js";
 import { resolveCliModel, resolveProfileModelSettings } from "./model-resolver.js";
 import { collectModelRouterConfigDiagnostics } from "./model-router/config-diagnostics.js";
 import { classifyExecutorTurn } from "./model-router/executor-route.js";
@@ -149,6 +151,8 @@ function persistModelRouterDecision(sessionManager, decision) {
 /** Custom-entry type for G3 autonomy telemetry. Distinct from the router/lane record types so a
  * telemetry consumer can filter on it without decoding operational snapshots. */
 const AUTONOMY_TELEMETRY_CUSTOM_TYPE = "autonomy-telemetry";
+/** G8: bound on the in-memory gate-outcome history. Oldest entries evict once the cap is reached. */
+const GATE_OUTCOME_HISTORY_LIMIT = 50;
 /** Read a packed grep/find tool result's `details.artifactId`, if present, without `any`. */
 function extractArtifactId(message) {
     if (!message || message.role !== "toolResult")
@@ -218,8 +222,6 @@ export class AgentSession {
     _laneTracker = new LaneTracker();
     /** Session-lifetime abort for in-flight research passes (same pattern as _reflectionAbort). */
     _researchLaneAbort = new AbortController();
-    /** Single-flight guard: at most one delegated worker runs at a time per session. */
-    _isWorkerDelegationRunning = false;
     /** Session-lifetime abort for in-flight delegated workers. */
     _workerDelegationAbort = new AbortController();
     /**
@@ -258,6 +260,8 @@ export class AgentSession {
     // Extension system
     _extensionRunner;
     _turnIndex = 0;
+    /** G7: per-turn foreground CapabilityEnvelope auto-built for visibility (observe-only; not enforced). */
+    _currentForegroundEnvelope;
     _resourceLoader;
     _customTools;
     _baseToolDefinitions = new Map();
@@ -292,6 +296,8 @@ export class AgentSession {
     _isModelRouterRetry = false;
     _lastModelRouterDecision;
     _lastAutonomyGateOutcome;
+    /** G8: bounded (cap {@link GATE_OUTCOME_HISTORY_LIMIT}) history of gate outcomes; tail is latest. */
+    _gateOutcomeHistory = [];
     _lastModelRouterSkipReason;
     _lastModelRouterIntent;
     /** Lazily-built skill curator (#32) over `<agentDir>/skills`. */
@@ -1014,6 +1020,9 @@ export class AgentSession {
                 ...this._resourceLoader.getAgentsDiagnostics().map((diagnostic) => diagnostic.message),
                 ...this._inertExtensionWarnings,
                 ...this._unboundToolGrantWarnings,
+                // G7: auto-built per-turn foreground envelope (observe-only; not enforced). Falls back to a
+                // live preview when no turn has run yet so /context always shows the current scope.
+                formatForegroundEnvelopeObservation(this._currentForegroundEnvelope ?? this._buildForegroundEnvelopeFromState()),
                 // G14 (ratified): a user disable always beats a profile grant — surface the conflict.
                 ...["tools", "skills", "prompts", "extensions"].flatMap((kind) => this.settingsManager
                     .getProfileGrantsOverriddenByUserDisable(kind)
@@ -1351,7 +1360,7 @@ export class AgentSession {
                 envelope: this.capabilityEnvelope,
             });
             if (this.capabilityEnvelope) {
-                this._lastAutonomyGateOutcome = gateResult;
+                this._recordGateOutcome(gateResult);
             }
             if (gateResult.outcome === "block" || gateResult.outcome === "ask-user") {
                 return {
@@ -1568,6 +1577,7 @@ export class AgentSession {
             await this._extensionRunner.emit({ type: "agent_end", messages: event.messages });
         }
         else if (event.type === "turn_start") {
+            this._refreshForegroundEnvelope();
             const extensionEvent = {
                 type: "turn_start",
                 turnIndex: this._turnIndex,
@@ -1789,6 +1799,31 @@ export class AgentSession {
     getActiveToolNames() {
         return this.agent.state.tools.map((t) => t.name);
     }
+    /** G7: build a foreground {@link CapabilityEnvelope} from the live session state (active tools, cwd, cost ceiling). */
+    _buildForegroundEnvelopeFromState() {
+        return buildForegroundEnvelope({
+            turnIndex: this._turnIndex,
+            activeToolNames: this.getActiveToolNames(),
+            cwd: this._cwd,
+            maxTurnUsd: this.settingsManager.getCostGuardSettings().maxTurnUsd,
+        });
+    }
+    /**
+     * G7: (re)build the foreground envelope for the current turn. Visibility only -- the foreground
+     * envelope is NOT enforced this round. Best-effort: never throws into the turn.
+     */
+    _refreshForegroundEnvelope() {
+        try {
+            this._currentForegroundEnvelope = this._buildForegroundEnvelopeFromState();
+        }
+        catch {
+            // Visibility only: a failure to build the envelope must never disturb the turn.
+        }
+    }
+    /** G7: the auto-constructed foreground envelope for the current/most-recent turn (visibility only). */
+    getForegroundEnvelope() {
+        return this._currentForegroundEnvelope;
+    }
     /**
      * Get all configured tools with name, description, parameter schema, prompt guidelines, and source metadata.
      */
@@ -2092,6 +2127,59 @@ export class AgentSession {
             return undefined;
         }
     }
+    /** True if a run_toolkit_script tool result since `fromIndex` actually EXECUTED (not error/ambiguous). */
+    _executorTurnExecutedScript(fromIndex) {
+        for (const message of this.agent.state.messages.slice(fromIndex)) {
+            if (message.role !== "toolResult")
+                continue;
+            if (message.toolName !== "run_toolkit_script")
+                continue;
+            if (message.isError === true)
+                continue;
+            const outcome = message.details?.outcome;
+            if (outcome === "executed")
+                return true;
+        }
+        return false;
+    }
+    /** Ask the reflex brain to refine the last user request into an explicit toolkit instruction. */
+    async _buildExecutorRefinedPrompt(messages) {
+        try {
+            const model = this._resolveCurationModelIfFit();
+            if (!model)
+                return undefined;
+            const list = Array.isArray(messages) ? messages : [messages];
+            const request = latestUserPromptText(list.filter((m) => true));
+            if (!request)
+                return undefined;
+            const scripts = this.settingsManager.getToolkitScripts();
+            const completion = await this.runIsolatedCompletion({
+                systemPrompt: REFLEX_INTERPRETER_SYSTEM_PROMPT,
+                messages: [
+                    {
+                        role: "user",
+                        content: [{ type: "text", text: buildReflexUserPrompt(request, scripts) }],
+                        timestamp: Date.now(),
+                    },
+                ],
+                model,
+                thinkingLevel: "off",
+                maxTokens: 256,
+                cacheRetention: "short",
+            });
+            if (completion.usage.cost.total > 0 || completion.usage.totalTokens > 0) {
+                this.addSpawnedUsage(completion.usage, { label: "executor-brain-warmup" });
+            }
+            const plan = parseReflexPlan(completion.text);
+            if (!plan || plan.script === "none")
+                return undefined;
+            const argHint = plan.args.length > 0 ? ` with args ${JSON.stringify(plan.args)}` : "";
+            return `Run the toolkit script "${plan.script}"${argHint} using run_toolkit_script, then report its result exactly.`;
+        }
+        catch {
+            return undefined;
+        }
+    }
     _resolveModelRouterTurnRoute(prompt) {
         const settings = this.settingsManager.getModelRouterSettings();
         if (!settings.enabled) {
@@ -2328,6 +2416,36 @@ export class AgentSession {
         }
         try {
             await this._runAgentPrompt(messages);
+            // Speculative muscle-retry (G16 refinement): an executor-routed turn is a bet that the
+            // small model can run the toolkit command directly. If it ends WITHOUT a successful
+            // run_toolkit_script execution, retry ONCE on the same executor with the brain's
+            // refined instruction injected — the brain warms while the muscle tries, so the retry
+            // pays only when the muscle actually missed.
+            if (routeDecision?.reasonCode === "executor_direct" &&
+                !this._isModelRouterRetry &&
+                !this._executorTurnExecutedScript(originalHistoryLength)) {
+                const refined = await this._buildExecutorRefinedPrompt(messages);
+                if (refined) {
+                    this.agent.state.messages.splice(originalHistoryLength);
+                    await this._runAgentPrompt([
+                        { role: "user", content: [{ type: "text", text: refined }], timestamp: Date.now() },
+                    ]);
+                    completedDecision = {
+                        route: {
+                            ...routeDecision,
+                            reasonCode: "executor_speculative_retry",
+                            reasons: [
+                                ...routeDecision.reasons,
+                                "Executor missed on first try; retried with brain-refined instruction",
+                            ],
+                        },
+                        routedModel: formatModelRouterModel(routedModel),
+                        outcome: "routed",
+                        intent: "research",
+                    };
+                    this._lastModelRouterDecision = completedDecision;
+                }
+            }
             if (bufferRoutedTurn && this._modelRouterEscalationRequested) {
                 this.agent.state.messages.splice(originalHistoryLength);
                 retryModel = this._resolveModelRouterModelForIntent("modify") ?? previousModel;
@@ -5101,6 +5219,40 @@ export class AgentSession {
             // Telemetry is best-effort: swallow so a sink failure cannot break the observed turn.
         }
     }
+    /**
+     * G8: single sink for a gate outcome. Keeps the latest-outcome getter behavior identical (the
+     * full {@link GateOutcome} still lands in `_lastAutonomyGateOutcome`), and additionally appends a
+     * bounded codes-only entry to {@link _gateOutcomeHistory} (oldest evicted at
+     * {@link GATE_OUTCOME_HISTORY_LIMIT}) and emits the `gate_outcome` telemetry event. The history
+     * tail therefore always mirrors the latest outcome. Only called with an active envelope.
+     */
+    _recordGateOutcome(outcome) {
+        this._lastAutonomyGateOutcome = outcome;
+        const at = new Date().toISOString();
+        this._gateOutcomeHistory.push({
+            outcome: outcome.outcome,
+            gate: outcome.gate,
+            reasonCode: outcome.reasonCode,
+            at,
+        });
+        while (this._gateOutcomeHistory.length > GATE_OUTCOME_HISTORY_LIMIT) {
+            this._gateOutcomeHistory.shift();
+        }
+        // G8: gate outcome event. Codes/ids only — never the gate's human-facing message.
+        this._emitAutonomyTelemetry({
+            type: AUTONOMY_TELEMETRY_EVENT_TYPES.gateOutcome,
+            timestamp: at,
+            payload: {
+                outcome: outcome.outcome,
+                gate: outcome.gate,
+                reasonCode: outcome.reasonCode,
+            },
+        });
+    }
+    /** G8: copies of the bounded gate-outcome history, oldest first, latest last. */
+    getGateOutcomeHistory() {
+        return this._gateOutcomeHistory.map((entry) => ({ ...entry }));
+    }
     saveWorkerResultSnapshot(result, request) {
         return appendWorkerResultSnapshot(this.sessionManager, result, request);
     }
@@ -5157,12 +5309,17 @@ export class AgentSession {
         const snapshot = this.getGoalRuntimeSnapshot({ maxStallTurns });
         if (snapshot.continuation.action !== "continue")
             return;
+        // Lean-window models (16-32k) keep autosteer but at a reduced budget; full passes through.
+        const scaled = scaleContinuationBudgetsForCapability(this.getModelCapabilityProfile(), {
+            maxTurns: goalContinueTurns,
+            maxWallClockMinutes: goalContinueMaxWallClockMinutes,
+        });
         this._isGoalAutoContinuing = true;
         try {
             await this.continueGoalLoop({
-                maxTurns: goalContinueTurns,
+                maxTurns: scaled.maxTurns,
                 maxStallTurns,
-                maxWallClockMinutes: goalContinueMaxWallClockMinutes,
+                maxWallClockMinutes: scaled.maxWallClockMinutes,
             });
         }
         catch (error) {
@@ -5500,7 +5657,8 @@ export class AgentSession {
      * usage (idempotent per-lane reportId). Consumed by the `delegate` tool.
      */
     async runWorkerDelegationOnce(request) {
-        if (this._isWorkerDelegationRunning) {
+        const delegationSettings = this.settingsManager.getWorkerDelegationSettings();
+        if (this._laneTracker.getActiveCount("worker") >= delegationSettings.maxConcurrent) {
             return { started: false, skipReason: "worker_delegation_already_running" };
         }
         if (this._disposed) {
@@ -5510,7 +5668,7 @@ export class AgentSession {
         if (instructions.length === 0) {
             return { started: false, skipReason: "missing_instructions" };
         }
-        const settings = this.settingsManager.getWorkerDelegationSettings();
+        const settings = delegationSettings;
         if (!settings.enabled) {
             return { started: false, skipReason: "worker_delegation_disabled" };
         }
@@ -5519,7 +5677,6 @@ export class AgentSession {
             return { started: false, skipReason: shipment.skipReason };
         }
         const { model, laneProfile } = shipment;
-        this._isWorkerDelegationRunning = true;
         this._laneTracker.ensureCounterAtLeast(getLaneRecordSnapshots(this.sessionManager.getEntries()).length + 1);
         const startedRecord = this._laneTracker.start({ type: "worker" });
         const maxUsd = Math.min(settings.maxUsd, this.capabilityEnvelope?.maxEstimatedUsd ?? Number.POSITIVE_INFINITY);
@@ -5536,7 +5693,12 @@ export class AgentSession {
             envelope: {
                 id: `worker-${this.sessionId}-${startedRecord.laneId}`,
                 profileId: laneProfile?.name,
-                capabilities: ["read_files"],
+                // write_files requires BOTH the opt-in AND an explicit non-empty path scope —
+                // an unscoped write grant is refused here, not discovered at validation time.
+                capabilities: settings.writeEnabled && settings.writePaths.length > 0 ? ["read_files", "write_files"] : ["read_files"],
+                ...(settings.writeEnabled && settings.writePaths.length > 0
+                    ? { allowedPaths: [...settings.writePaths] }
+                    : {}),
                 ...this._laneProfileToolGrants(laneProfile),
                 maxEstimatedUsd: maxUsd,
                 createdAt: new Date().toISOString(),
@@ -5544,6 +5706,17 @@ export class AgentSession {
             maxEstimatedUsd: maxUsd,
             createdAt: new Date().toISOString(),
         };
+        // G8: worker delegation START. Routing/scope codes + budget only — never the instructions text.
+        this._emitAutonomyTelemetry({
+            type: AUTONOMY_TELEMETRY_EVENT_TYPES.workerRequest,
+            timestamp: new Date().toISOString(),
+            payload: {
+                id: workerRequest.id,
+                tier: workerRequest.route.tier,
+                capabilities: [...workerRequest.envelope.capabilities],
+                maxEstimatedUsd: workerRequest.maxEstimatedUsd ?? null,
+            },
+        });
         const usageReportId = `worker:${this.sessionId}:${startedRecord.laneId}`;
         try {
             let spentUsage;
@@ -5553,6 +5726,10 @@ export class AgentSession {
                 maxWallClockMs: settings.maxWallClockMs,
                 usageReportId,
                 signal: this._workerDelegationAbort.signal,
+                // Write lane (G2): runner-side action application through the envelope path scope.
+                applyActions: workerRequest.envelope.capabilities.includes("write_files")
+                    ? (actions) => applyWorkerActions({ actions, envelope: workerRequest.envelope, cwd: this._cwd })
+                    : undefined,
                 complete: async ({ systemPrompt, userPrompt, signal }) => {
                     const completion = await this.runIsolatedCompletion({
                         // Level-0 core always survives. A model-provided prompt (delegate tool) is the most
@@ -5637,7 +5814,6 @@ export class AgentSession {
             return { started: true, record };
         }
         finally {
-            this._isWorkerDelegationRunning = false;
         }
     }
     /**
@@ -5958,6 +6134,19 @@ export class AgentSession {
                     requiresApproval: decision.requiresApproval,
                 },
             });
+            // G8: a proposal that needs human sign-off is an approval REQUEST. Codes/layer only —
+            // never the proposal summary/memory text (those live only in the audit snapshot).
+            if (decision.requiresApproval) {
+                this._emitAutonomyTelemetry({
+                    type: AUTONOMY_TELEMETRY_EVENT_TYPES.approvalRequest,
+                    timestamp: new Date().toISOString(),
+                    payload: {
+                        kind: decision.kind,
+                        reasonCode: decision.reasonCode,
+                        layer: proposal.layer,
+                    },
+                });
+            }
             if (decision.kind === "apply") {
                 await this._applyReflectionWrite(write, signal);
             }