@caupulican/pi-adaptative 0.80.97 → 0.80.99

package/dist/core/agent-session.js

@@ -21,10 +21,12 @@ 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";
 import { composeSubagentSystemPrompt } from "./autonomy/subagent-prompt.js";
+import { AUTONOMY_TELEMETRY_EVENT_TYPES, redactTelemetryValue, } from "./autonomy/telemetry-events.js";
 import { executeBashWithOperations } from "./bash-executor.js";
 import { calculateContextTokens, collectEntriesForBranchSummary, compact, estimateContextTokens, generateBranchSummary, prepareCompaction, shouldCompact, } from "./compaction/index.js";
 // (module-scope helper for curation goal extraction defined below the imports)
@@ -44,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";
@@ -57,6 +60,7 @@ import { buildGoalRuntimeSnapshot, } from "./goals/goal-runtime-snapshot.js";
 import { appendGoalStateSnapshot, getLatestGoalStateSnapshot } from "./goals/session-goal-state.js";
 import { appendLearningAuditSnapshot, getLearningAuditSnapshots, proposalFromReflectionWrite, rollbackPlanForReflectionWrite, } from "./learning/learning-audit.js";
 import { evaluateLearningDecision } from "./learning/learning-gate.js";
+import { ObservationStore, observationKey } from "./learning/observation-store.js";
 import { decideDemand, ReflectionEngine, } from "./learning/reflection-engine.js";
 import { appendLearningDecisionSnapshot, getLearningDecisionSnapshots } from "./learning/session-learning-decision.js";
 import { isPromotedFrontmatter, SkillCurator } from "./learning/skill-curator.js";
@@ -66,9 +70,10 @@ 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";
 import { classifyModelRouterRoute } from "./model-router/intent-classifier.js";
 import { ROUTE_JUDGE_MAX_OUTPUT_TOKENS, runRouteJudge } from "./model-router/route-judge.js";
 import { bufferModelRouterSessionCustomMessage, bufferModelRouterSessionMessage, createModelRouterSessionBuffer, flushModelRouterSessionBuffer, } from "./model-router/session-buffer.js";
@@ -79,6 +84,7 @@ import { expandPromptTemplate } from "./prompt-templates.js";
 import { runModelFitnessProbe } from "./research/model-fitness.js";
 import { runResearch } from "./research/research-runner.js";
 import { appendEvidenceBundleSnapshot, getEvidenceBundleSnapshots, getLatestEvidenceBundleSnapshot, } from "./research/session-evidence-bundle.js";
+import { collectWorkspaceSources } from "./research/workspace-collector.js";
 import { stripResourceProfileBlocks } from "./resource-profile-blocks.js";
 import { classifyToolTrust, UNTRUSTED_BOUNDARY_SYSTEM_RULE, wrapUntrustedText } from "./security/untrusted-boundary.js";
 import { CURRENT_SESSION_VERSION, getLatestCompactionEntry } from "./session-manager.js";
@@ -142,6 +148,11 @@ function formatModelRouterModel(model) {
 function persistModelRouterDecision(sessionManager, decision) {
     sessionManager.appendCustomEntry(MODEL_ROUTER_DECISION_CUSTOM_TYPE, 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")
@@ -211,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();
     /**
@@ -251,11 +260,14 @@ 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();
     _cwd;
     _agentDir;
+    _collectWorkspaceSources;
     _extensionRunnerRef;
     _initialActiveToolNames;
     _allowedToolNames;
@@ -284,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`. */
@@ -323,6 +337,7 @@ export class AgentSession {
         this._customTools = config.customTools ?? [];
         this._cwd = config.cwd;
         this._agentDir = config.agentDir ?? getAgentDir();
+        this._collectWorkspaceSources = config.collectWorkspaceSources ?? collectWorkspaceSources;
         this._modelRegistry = config.modelRegistry;
         this._extensionRunnerRef = config.extensionRunnerRef;
         this._initialActiveToolNames = config.initialActiveToolNames;
@@ -1005,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)
@@ -1213,7 +1231,13 @@ export class AgentSession {
                 writePayloads,
                 curation: curationSettings.enabled
                     ? {
-                        resolveDigest: (digestKey) => this._brainCurator.getDigest(digestKey),
+                        resolveDigest: (digestKey) => {
+                            const digest = this._brainCurator.getDigest(digestKey);
+                            // Count serves on the REAL per-turn pass only, never the report path.
+                            if (digest !== undefined && writePayloads)
+                                this._brainCurator.noteDigestServed();
+                            return digest;
+                        },
                         // Only the real per-turn pass enqueues work; the read-only report path
                         // (writePayloads=false) stays side-effect free.
                         onPacked: writePayloads
@@ -1315,7 +1339,12 @@ export class AgentSession {
     _installAgentToolHooks() {
         this.agent.beforeToolCall = async ({ toolCall, args }) => {
             if (this._activeModelRouterRoute &&
-                shouldEscalateModelRouterTool({ tier: this._activeModelRouterRoute.tier, toolName: toolCall.name, args })) {
+                shouldEscalateModelRouterTool({
+                    tier: this._activeModelRouterRoute.tier,
+                    toolName: toolCall.name,
+                    args,
+                    reasonCode: this._activeModelRouterRoute.reasonCode,
+                })) {
                 this._modelRouterEscalationRequested = true;
                 this.agent.abort();
                 return {
@@ -1331,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 {
@@ -1548,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,
@@ -1769,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.
      */
@@ -2037,12 +2092,107 @@ export class AgentSession {
             return false;
         return this._modelRegistry.hasConfiguredAuth(resolved.model);
     }
+    _resolveExecutorRoute(prompt, executorPattern) {
+        if (!executorPattern)
+            return undefined;
+        try {
+            const verdict = classifyExecutorTurn(prompt, this.settingsManager.getToolkitScripts());
+            if (!verdict.execute)
+                return undefined;
+            const resolved = resolveCliModel({ cliModel: executorPattern, modelRegistry: this._modelRegistry });
+            if (!resolved.model || !this._modelRegistry.hasConfiguredAuth(resolved.model))
+                return undefined;
+            // Fitness gate: the executor must have PROVEN tool-calling on this host (same
+            // canonical-ref discipline as the curation gate).
+            const canonicalRef = `${resolved.model.provider}/${resolved.model.id}`;
+            const fitness = FitnessStore.forAgentDir(this._agentDir)
+                .getForHost()
+                .find((entry) => entry.model === canonicalRef);
+            const toolCall = fitness?.report.toolCall;
+            if (!toolCall || toolCall.succeeded < Math.ceil(toolCall.total * (2 / 3)))
+                return undefined;
+            this._lastModelRouterIntent = "research";
+            return {
+                decision: {
+                    tier: "cheap",
+                    risk: "scoped-write",
+                    confidence: 1,
+                    reasonCode: "executor_direct",
+                    reasons: [`Executor lane: Level-0 direct hit on toolkit script "${verdict.scriptName}"`],
+                },
+                model: resolved.model,
+            };
+        }
+        catch {
+            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) {
             this._lastModelRouterSkipReason = "disabled";
             return undefined;
         }
+        // G16 executor lane: a Level-0 DIRECT toolkit hit on a command-shaped prompt routes the
+        // whole turn to the configured local executor (tool-call-fitness-gated) instead of
+        // spending the frontier model on a one-tool reflex. Ambiguity never routes here — it
+        // stays with the big model and the reflex brain. Deterministic, so the judge is skipped.
+        const executorRoute = this._resolveExecutorRoute(prompt, settings.executorModel);
+        if (executorRoute)
+            return executorRoute;
         const decision = classifyModelRouterRoute(prompt);
         this._lastModelRouterIntent = decision.tier === "cheap" ? "research" : "modify";
         // Learning tier must not be selected for normal user prompts
@@ -2128,6 +2278,9 @@ export class AgentSession {
             return undefined;
         if (options?.skipJudge)
             return baseline;
+        // Deterministic executor routes need no judge (Level-0 already decided).
+        if (baseline.decision.reasonCode === "executor_direct")
+            return baseline;
         const settings = this.settingsManager.getModelRouterSettings();
         if (!settings.judgeEnabled)
             return baseline;
@@ -2263,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;
@@ -2336,6 +2519,19 @@ export class AgentSession {
         }
         if (persistDecision && completedDecision) {
             persistModelRouterDecision(this.sessionManager, completedDecision);
+            // G3: one route event per user-facing routed turn (the escalation retry runs with
+            // persistDecision=false, so it does not double-emit). Codes/numbers only — no prompt text.
+            this._emitAutonomyTelemetry({
+                type: AUTONOMY_TELEMETRY_EVENT_TYPES.routeDecision,
+                timestamp: new Date().toISOString(),
+                payload: {
+                    tier: completedDecision.route.tier,
+                    risk: completedDecision.route.risk,
+                    reasonCode: completedDecision.route.reasonCode,
+                    confidence: completedDecision.route.confidence,
+                    outcome: completedDecision.outcome,
+                },
+            });
         }
         if (thrownError) {
             throw thrownError;
@@ -5007,8 +5203,58 @@ export class AgentSession {
     getLaneRecords() {
         return this._laneTracker.getRecords();
     }
-    saveWorkerResultSnapshot(result) {
-        return appendWorkerResultSnapshot(this.sessionManager, result);
+    /**
+     * G3: bounded autonomy-telemetry sink. Passes the whole event through {@link redactTelemetryValue}
+     * (the taxonomy's redaction contract) before storing it, so a secret that leaked into a payload
+     * field never lands in the session log. Observe-only: a failure here can never surface into the
+     * turn it is measuring, so the whole body is swallowed. Payloads MUST stay small (ids, codes,
+     * numbers) — never prompt/summary text; callers own that discipline.
+     */
+    _emitAutonomyTelemetry(event) {
+        try {
+            const redacted = redactTelemetryValue(event);
+            this.sessionManager.appendCustomEntry(AUTONOMY_TELEMETRY_CUSTOM_TYPE, { version: 1, ...redacted });
+        }
+        catch {
+            // 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);
     }
     getWorkerResultSnapshots() {
         return getWorkerResultSnapshots(this.sessionManager.getEntries());
@@ -5063,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) {
@@ -5285,9 +5536,17 @@ export class AgentSession {
         const startedRecord = this._laneTracker.start({ type: "research", goalId: demand.goalId });
         try {
             let spentUsage;
+            // Best-effort, pointer-first workspace evidence. Derives search terms from the goal/requirement
+            // text (not the identity-key query) and is bounded + silent-on-failure: [] == today's behavior.
+            const workspaceSources = await this._collectWorkspaceSources({
+                query: `${demand.context}\n${demand.query}`,
+                cwd: this._cwd,
+                maxSources: settings.maxSources,
+            });
             const result = await runResearch({
                 query: demand.query,
                 context: demand.context,
+                sources: workspaceSources,
                 envelope: this._buildResearchLaneEnvelope(settings.maxUsd, laneProfile),
                 maxUsd: settings.maxUsd,
                 maxSources: settings.maxSources,
@@ -5346,6 +5605,20 @@ export class AgentSession {
             });
             if (record) {
                 appendLaneRecordSnapshot(this.sessionManager, record);
+                // G3: a research lane's product is an evidence bundle, so its terminal record maps to
+                // the evidence_bundle event. Lane outcome only (status/reasonCode/cost) — no findings text.
+                this._emitAutonomyTelemetry({
+                    type: AUTONOMY_TELEMETRY_EVENT_TYPES.evidenceBundle,
+                    timestamp: new Date().toISOString(),
+                    payload: {
+                        laneId: record.laneId,
+                        laneType: record.type,
+                        status: record.status,
+                        reasonCode: record.reasonCode ?? null,
+                        costUsd: record.costUsd ?? null,
+                        hasEvidence: record.evidenceEntryId !== undefined,
+                    },
+                });
             }
             return { started: true, record, result };
         }
@@ -5356,6 +5629,18 @@ export class AgentSession {
             });
             if (record && !this._disposed) {
                 appendLaneRecordSnapshot(this.sessionManager, record);
+                this._emitAutonomyTelemetry({
+                    type: AUTONOMY_TELEMETRY_EVENT_TYPES.evidenceBundle,
+                    timestamp: new Date().toISOString(),
+                    payload: {
+                        laneId: record.laneId,
+                        laneType: record.type,
+                        status: record.status,
+                        reasonCode: record.reasonCode ?? null,
+                        costUsd: record.costUsd ?? null,
+                        hasEvidence: record.evidenceEntryId !== undefined,
+                    },
+                });
             }
             const message = error instanceof Error ? error.message : String(error);
             this._emit({ type: "warning", message: `Research lane failed: ${message}` });
@@ -5372,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) {
@@ -5382,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" };
         }
@@ -5391,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);
@@ -5408,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(),
@@ -5416,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;
@@ -5425,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
@@ -5458,7 +5763,7 @@ export class AgentSession {
                 });
                 return { started: true, record, outcome };
             }
-            this.saveWorkerResultSnapshot(outcome.result);
+            this.saveWorkerResultSnapshot(outcome.result, workerRequest);
             if (spentUsage && (spentUsage.cost.total > 0 || spentUsage.totalTokens > 0)) {
                 this.addSpawnedUsage(spentUsage, { label: "worker-delegation", reportId: usageReportId });
             }
@@ -5469,6 +5774,19 @@ export class AgentSession {
             });
             if (record) {
                 appendLaneRecordSnapshot(this.sessionManager, record);
+                // G3: worker lane terminal record -> worker_result event. Lane outcome only
+                // (status/reasonCode/cost) — never the worker's summary/changed-file text.
+                this._emitAutonomyTelemetry({
+                    type: AUTONOMY_TELEMETRY_EVENT_TYPES.workerResult,
+                    timestamp: new Date().toISOString(),
+                    payload: {
+                        laneId: record.laneId,
+                        laneType: record.type,
+                        status: record.status,
+                        reasonCode: record.reasonCode ?? null,
+                        costUsd: record.costUsd ?? null,
+                    },
+                });
             }
             return { started: true, record, outcome };
         }
@@ -5479,13 +5797,23 @@ export class AgentSession {
             });
             if (record && !this._disposed) {
                 appendLaneRecordSnapshot(this.sessionManager, record);
+                this._emitAutonomyTelemetry({
+                    type: AUTONOMY_TELEMETRY_EVENT_TYPES.workerResult,
+                    timestamp: new Date().toISOString(),
+                    payload: {
+                        laneId: record.laneId,
+                        laneType: record.type,
+                        status: record.status,
+                        reasonCode: record.reasonCode ?? null,
+                        costUsd: record.costUsd ?? null,
+                    },
+                });
             }
             const message = error instanceof Error ? error.message : String(error);
             this._emit({ type: "warning", message: `Worker delegation failed: ${message}` });
             return { started: true, record };
         }
         finally {
-            this._isWorkerDelegationRunning = false;
         }
     }
     /**
@@ -5750,17 +6078,32 @@ export class AgentSession {
         // every pass, so advancing it for a no-op (which stores nothing) would make later passes
         // reuse ids — and rollback keys on the id, so a collision blocks or misdirects rollback.
         let auditSequence = getLearningAuditSnapshots(this.sessionManager.getEntries()).length;
+        // G6 evidence strength: durable proposals accumulate observation counts across passes/sessions
+        // so the gate can distinguish a one-off cue from a repeatedly-confirmed lesson. Built once per
+        // pass; every increment is best-effort (store IO must never break reflection).
+        const observationStore = ObservationStore.forAgentDir(this._agentDir);
         let writeIndex = 0;
         for (const write of result.writes) {
             writeIndex += 1;
             const proposalId = `${input.reportId ?? "reflection"}-w${writeIndex}`;
             const proposal = proposalFromReflectionWrite(write, proposalId);
             const rollback = rollbackPlanForReflectionWrite(write);
+            let observations = 1;
+            if (policy.enabled) {
+                try {
+                    observations = observationStore.increment(observationKey(proposal.layer, proposal.summary));
+                }
+                catch {
+                    // A store read/write failure falls back to a fresh count of 1, which keeps the gate
+                    // proposal-first (never spuriously auto-applies) rather than crashing the pass.
+                    observations = 1;
+                }
+            }
             const decision = policy.enabled
                 ? evaluateLearningDecision({
                     proposal,
                     confidence: policy.reflectionSourceConfidence,
-                    observations: 1,
+                    observations,
                     contradictions: 0,
                     settings: {
                         enabled: true,
@@ -5779,6 +6122,31 @@ export class AgentSession {
                     requiresApproval: false,
                 };
             this.saveLearningDecisionSnapshot(decision);
+            // G3: learning-gate outcome. Codes/numbers only — never the proposal summary/memory text.
+            this._emitAutonomyTelemetry({
+                type: AUTONOMY_TELEMETRY_EVENT_TYPES.learningDecision,
+                timestamp: new Date().toISOString(),
+                payload: {
+                    kind: decision.kind,
+                    reasonCode: decision.reasonCode,
+                    layer: proposal.layer,
+                    confidence: decision.confidence,
+                    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);
             }