@caupulican/pi-adaptative 0.81.39 → 0.81.40

package/dist/core/agent-session.js

@@ -1,13 +1,10 @@
 import { createHash, randomUUID } from "node:crypto";
-import { readFileSync, rmSync, writeFileSync } from "node:fs";
-import { basename, dirname, join } from "node:path";
-import { classifyFailure, compactToolResultDetailsForRetention, computeRetryDelayMs, createCustomMessage, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE, RetryController, sleepAbortable, withStreamIdleWatchdog, } from "@caupulican/pi-agent-core";
-import { calculateContextTokens, compact, createDeterministicCompaction, estimateContextTokens, getLatestCompactionEntry, prepareCompaction, runCompactionLoop, shouldCompact, } from "@caupulican/pi-agent-core/node";
-import { cleanupSessionResources, formatToolRepairStandingRule, formatVariantEnvelope, generateTextToolProtocolPrimer, getSupportedThinkingLevels, isContextOverflow, modelsAreEqual, parseTextToolCalls, streamSimple, } from "@caupulican/pi-ai";
-import { Type } from "typebox";
+import { readFileSync } from "node:fs";
+import { basename, dirname } from "node:path";
+import { compactToolResultDetailsForRetention, createCustomMessage, DEFAULT_STREAM_IDLE, withStreamIdleWatchdog, } from "@caupulican/pi-agent-core";
+import { cleanupSessionResources, getSupportedThinkingLevels, modelsAreEqual, streamSimple } from "@caupulican/pi-ai";
 import { getAgentDir } from "../config.js";
 import { stripFrontmatter } from "../utils/frontmatter.js";
-import { getProcessWorkRun } from "../utils/work-directory.js";
 import { resourceDir, stateFile } from "./agent-paths.js";
 import { formatNoApiKeyFoundMessage, formatNoModelSelectedMessage } from "./auth-guidance.js";
 import { buildForegroundEnvelope, formatForegroundEnvelopeObservation } from "./autonomy/foreground-envelope.js";
@@ -15,19 +12,21 @@ import { evaluateToolGate } from "./autonomy/gates.js";
 import { AutonomyTelemetry } from "./autonomy-telemetry.js";
 import { BackgroundLaneController } from "./background-lane-controller.js";
 import { BashExecutionController } from "./bash-execution-controller.js";
-import { BillingFailoverController, ExhaustedProviderRegistry } from "./billing-failover-controller.js";
+import { CompactionController } from "./compaction-controller.js";
 import { CompactionSupport } from "./compaction-support.js";
 import { buildContextCompositionReport, formatContextCompositionDashboard, } from "./context/context-composition.js";
 import { ContextPipeline } from "./context-pipeline.js";
 import { downgradeReasoning, estimateTurnCostUsd, evaluateCostGuard } from "./cost-guard.js";
-import { appendWorkerResultSnapshot, getWorkerResultSnapshots } from "./delegation/session-worker-result.js";
+import { appendWorkerClaimSnapshot, getWorkerClaimSnapshots } from "./delegation/session-worker-claim.js";
 import { FailureCorpusRecorder } from "./failure-corpus.js";
+import { ForegroundRecoveryController } from "./foreground-recovery-controller.js";
 import { GatewayRegistry } from "./gateways/channel-provider.js";
 import { GoalLoopController } from "./goal-loop-controller.js";
 import { buildGoalRuntimeSnapshot, } from "./goals/goal-runtime-snapshot.js";
 import { applyGoalEvent } from "./goals/goal-state.js";
 import { appendGoalStateSnapshot, getLatestGoalStateSnapshot } from "./goals/session-goal-state.js";
 import { constrainStreamIdleToHttpTimeout } from "./http-dispatcher.js";
+import { beginHumanInputRequest, createHumanInputRequest, formatHumanInputAnswerText, getLatestHumanInputSnapshots, getResumableHumanInputSnapshot, getWorkerHumanInputsRequiringDelivery, HUMAN_INPUT_WORKER_RESPONSE_CUSTOM_TYPE, resolveHumanInput, } from "./human-input.js";
 import { appendLearningDecisionSnapshot, getLearningDecisionSnapshots } from "./learning/session-learning-decision.js";
 import { isPromotedFrontmatter, SkillCurator } from "./learning/skill-curator.js";
 import { LocalRuntimeController } from "./local-runtime-controller.js";
@@ -36,9 +35,11 @@ import { deriveModelCapabilityProfile, evaluateLaneWorkerRefusal, filterToolName
 import { isLocalOrManagedRouterModel } from "./model-router/tool-escalation.js";
 import { formatModelRouterModel, ModelRouterController } from "./model-router-controller.js";
 import { ModelSelectionController } from "./model-selection-controller.js";
-import { ModelAdaptationStore, } from "./models/adaptation-store.js";
+import { ModelAdaptationStore } from "./models/adaptation-store.js";
 import { HF_TRANSFORMERS_PROVIDER, OLLAMA_PROVIDER } from "./models/local-registration.js";
 import { DEFAULT_ADAPTIVE_STREAM_IDLE_CEILING_MS, estimateContextPromptTokens, resolveAdaptiveStreamIdleOptions, withModelPerfProfile, } from "./models/perf-profile.js";
+import { resolveConfiguredOrchestrationModel } from "./orchestration/model-binding.js";
+import { validateOrchestrationProfile } from "./orchestration/profile-registry.js";
 import { ProfileFilterController } from "./profile-filter-controller.js";
 import { expandPromptTemplate } from "./prompt-templates.js";
 import { ReflectionController } from "./reflection-controller.js";
@@ -47,15 +48,16 @@ import { collectWorkspaceSources } from "./research/workspace-collector.js";
 import { stripResourceProfileBlocks } from "./resource-profile-blocks.js";
 import { RuntimeBuilder } from "./runtime-builder.js";
 import { SessionAnalytics } from "./session-analytics.js";
+import { SessionImageStore } from "./session-image-store.js";
+import { getActiveSessionBranchEntries } from "./session-snapshot.js";
 import { SessionTreeNavigator } from "./session-tree-navigator.js";
 import { SystemPromptBuilder } from "./system-prompt-builder.js";
 import { appendTaskStepsStateSnapshot, getLatestTaskStepsStateSnapshot } from "./tasks/session-task-state.js";
 import { formatTaskStepsContext } from "./tasks/task-state.js";
 import { ToolGateController } from "./tool-gate-controller.js";
+import { ToolProtocolController } from "./tool-protocol-controller.js";
 import { TOOL_RECOVERY_EVENT_LOG_FILE } from "./tool-recovery-log-records.js";
 import { ToolRecoveryLogger } from "./tool-recovery-logger.js";
-import { formatToolRepairHealthReport } from "./tool-repair-health.js";
-import { resolveCurrentToolRepairSettings } from "./tool-repair-settings.js";
 import { ToolPerformanceStore } from "./tool-selection/tool-performance-store.js";
 import { formatToolSelectionReport, ToolSelectionController } from "./tool-selection/tool-selection-controller.js";
 import { disposePersistentShellSession } from "./tools/shell-session.js";
@@ -72,39 +74,6 @@ import { disposePersistentShellSession } from "./tools/shell-session.js";
  * key stable regardless of how many times this module is evaluated.
  */
 const RAW_STREAM_MARKER = Symbol.for("pi.rawStreamSimple");
-const MODEL_ADAPTATION_REPAIR_THRESHOLD = 3;
-const TEXT_TOOL_PROTOCOL_VERSION = 1;
-const TEXT_TOOL_PROTOCOL_TRIALS_PER_VARIANT = 2;
-const TEXT_TOOL_PROTOCOL_PARSE_FAILURE_THRESHOLD = 3;
-/** How often the one-line envelope-format corrective steer (see
- * {@link AgentSession._maybeInjectTextProtocolCorrectiveSteer}) re-fires after the first parse
- * failure this session — every Nth failure thereafter, not every single one, so a model that keeps
- * missing the envelope doesn't get the reminder spliced into every turn (the breaker's same-signature
- * counter is what actually demotes it, at {@link TEXT_TOOL_PROTOCOL_PARSE_FAILURE_THRESHOLD}). */
-const TEXT_TOOL_PROTOCOL_STEER_INTERVAL = 5;
-/** Anti-loop cooldown: the evidence-gated auto-probe (see {@link
- * AgentSession._maybeAutoProbeOnValidationEscalation}) skips a model whose persisted `toolProbe`
- * verdict was written within this window, so a burst of validation-escalation events for a still-
- * failing model — or a very recent explicit `/toolprobe` run, or a future circuit-breaker demote — does
- * not re-fire the (multi-completion) probe every time. Independent of, and complementary to, the
- * per-session `_autoProbedModels` latch. */
-const AUTO_TOOL_PROBE_FRESHNESS_MS = 15 * 60 * 1000;
-const TEXT_TOOL_PROTOCOL_VARIANTS = [
-    "tool-tag",
-    "tool-call",
-    "fenced-json",
-    "function-xml",
-];
-const TEXT_TOOL_PROTOCOL_ECHO_TOOL = {
-    name: "echo",
-    description: "Echo calibration data",
-    parameters: Type.Object({ data: Type.String() }),
-};
-const NATIVE_TOOL_PROBE_READ_TOOL = {
-    name: "read",
-    description: "Read file contents",
-    parameters: Type.Object({ path: Type.String() }),
-};
 /** Test-only override of the stream-idle bounds. Read per-request by the wiring's resolver. */
 let streamIdleOptionsOverride;
 /**
@@ -199,17 +168,16 @@ export class AgentSession {
     _queuedExtensionCommands = [];
     _pendingNextTurnMessages = [];
     _streamingPromptSubmissionTail = Promise.resolve();
+    /** Serializes owner-input overlays so concurrent worker terminals cannot replace each other. */
+    _humanInputTail = Promise.resolve();
+    _activeHumanInputRequestIds = new Set();
     /**
      * The last tool set requested via setActiveToolsByName BEFORE model-capability filtering, so
      * switching from a small-window model back to a large one restores the full requested set.
      */
     _requestedActiveToolNames;
-    _compactionAbortController = undefined;
-    _autoCompactionAbortController = undefined;
-    _overflowRecoveryAttempted = false;
     _unboundToolGrantWarnings = [];
     _branchSummaryAbortController = undefined;
-    _retryController;
     _modelSelection;
     _bash;
     _profileFilter;
@@ -226,31 +194,16 @@ export class AgentSession {
     _agentDir;
     _collectWorkspaceSources;
     _localRuntimeController;
-    _modelAdaptationStore;
+    _toolProtocol;
     _prefixWarmer;
     _completedPrefixWarms = new Set();
-    _repairModeSessionCounts = new Map();
-    _textProtocolParseFailures = new Map();
-    _textProtocolParseObservedThisTurn = false;
-    /** Total text-protocol parse-failure events observed this session, backing the
-     * {@link TEXT_TOOL_PROTOCOL_STEER_INTERVAL} throttle on {@link _maybeInjectTextProtocolCorrectiveSteer}. */
-    _textProtocolCorrectiveSteerCount = 0;
-    /** Monotonic counter backing tool-probe/text-protocol-calibration spawned-usage reportIds
-     * (see {@link _nextProbeUsageReportId}); guarantees each probe/calibration completion in the
-     * session lands in the cost ledger exactly once, even across repeated /toolprobe invocations. */
-    _toolProbeUsageReportSeq = 0;
-    /** Anti-loop: modelKeys the evidence-gated auto-probe has already fired for THIS session (see
-     * {@link _maybeAutoProbeOnValidationEscalation}), so a burst of validation-escalation events for
-     * the same still-failing model never re-fires the probe more than once per session. */
-    _autoProbedModels = new Set();
-    _textProtocolValidationOutcomeThisTurn;
     /** Assembles the session's base system prompt from live session state (see
      * system-prompt-builder.ts); owns the paired _baseSystemPromptOptions. */
     _systemPromptBuilder;
     /** Autonomy telemetry sink + status/diagnostic snapshots (see autonomy-telemetry.ts); owns
      * the latest gate outcome and the bounded gate-outcome history. */
     _autonomyTelemetry;
-    /** Goal auto-continue + research lane + scout-worker delegation + model-fitness probe (see
+    /** Goal auto-continue + research lane + profile-bound worker delegation + model-fitness probe (see
      * background-lane-controller.ts); owns the lane timers/guards, the last research-lane skip
      * reason, the live LaneTracker, and the in-flight research/worker abort controllers. */
     _backgroundLanes;
@@ -259,6 +212,7 @@ export class AgentSession {
      * effectiveness tracker, and the extension-contributed pending providers. */
     _memory;
     _compactionSupport;
+    _compaction;
     /** Per-turn context-shaping subsystem (see context-pipeline.ts); owns the latest
      * audit/policy/correlation/enforcement/gc reports, the brain-curation sidecar + its skip reasons,
      * and the tool-output artifact store. Invoked stage-by-stage from the context transform. */
@@ -288,12 +242,13 @@ export class AgentSession {
      * used by the status report. Its parallel routed drive path delegates every turn back to
      * {@link _runAgentPrompt} so the drive loop stays host-side. */
     _modelRouter;
-    _billingFailover;
+    _foregroundRecovery;
     _failureCorpus;
     _toolRecoveryLogger;
     _toolRecoveryEventLogPath;
     _skillCuratorInstance;
     _disposed = false;
+    _disposeCompletion;
     _reflectionAbort = new AbortController();
     /** Native reflection engine + learning-apply/rollback path (see reflection-controller.ts); owns no
      * session state, applies durable writes through the bundled memory tool and the session log. */
@@ -323,7 +278,7 @@ export class AgentSession {
         this.agent = config.agent;
         // Bound every provider stream this session starts against a silently dead connection: a
         // stall aborts the inner request and surfaces as a retryable "stream stalled" error, which
-        // _isRetryableError routes into the existing auto-retry path. Wrapped exactly once, here.
+        // ForegroundRecoveryController routes into the existing auto-retry path. Wrapped exactly once, here.
         // The wrapper reports the stall immediately and aborts the inner request; releasing the
         // inner pump relies on the provider ending its stream after abort (real providers do — see
         // withStreamIdleWatchdog's contract), so no extra drain is added at this wiring site.
@@ -367,31 +322,46 @@ export class AgentSession {
         }), baseStreamFn === streamSimple);
         this.sessionManager = config.sessionManager;
         this.settingsManager = config.settingsManager;
-        // Auto-retry rides the reliability kernel: the controller owns the attempt counter and the
-        // abortable backoff. This session maps its retry settings onto a RetryPolicy, bridges the
-        // controller's events onto the session event stream, and supplies the live context window so
-        // the overflow-aware classifier can route overflow to compaction instead of a pointless retry.
-        this._retryController = new RetryController(this.agent, () => {
-            const retry = this.settingsManager.getRetrySettings();
-            return {
-                enabled: retry.enabled,
-                maxAttempts: retry.maxRetries,
-                baseDelayMs: retry.baseDelayMs,
-                maxDelayMs: DEFAULT_RETRY_POLICY.maxDelayMs,
-                jitterRatio: 0,
-            };
-        }, {
-            onRetryStart: (info) => this._emit({ type: "auto_retry_start", ...info }),
-            onRetryEnd: (info) => this._emit({ type: "auto_retry_end", ...info }),
-        }, () => this.model?.contextWindow ?? 0);
-        this._scopedModels = config.scopedModels ?? [];
+        if (config.orchestrationProfile) {
+            validateOrchestrationProfile(config.orchestrationProfile);
+            const resolved = resolveConfiguredOrchestrationModel(config.orchestrationProfile, config.modelRegistry);
+            if (!resolved) {
+                throw new TypeError(`Orchestration profile '${config.orchestrationProfile.profileId}' has no configured, authenticated model that supports its exact thinking level.`);
+            }
+            if (!this.agent.state.model || !modelsAreEqual(this.agent.state.model, resolved.model)) {
+                this.sessionManager.appendModelChange(resolved.model.provider, resolved.model.id);
+            }
+            if (this.agent.state.thinkingLevel !== resolved.binding.thinkingLevel) {
+                this.sessionManager.appendThinkingLevelChange(resolved.binding.thinkingLevel);
+            }
+            this.agent.state.model = resolved.model;
+            this.agent.state.thinkingLevel = resolved.binding.thinkingLevel;
+            this.settingsManager.setRuntimeResourceProfiles([...config.orchestrationProfile.resourceProfileNames]);
+        }
+        this._scopedModels = config.orchestrationProfile
+            ? [{ model: this.agent.state.model, thinkingLevel: this.agent.state.thinkingLevel }]
+            : (config.scopedModels ?? []);
         this._resourceLoader = config.resourceLoader;
         this._customTools = config.customTools ?? [];
         this._cwd = config.cwd;
         this._agentDir = agentDir;
-        this._modelAdaptationStore = modelAdaptationStore;
-        this.agent.onTextToolProtocolParse = (event) => this._handleTextToolProtocolParse(event);
-        this._applyToolRepairLayerSettings();
+        this._toolProtocol = new ToolProtocolController({
+            agent: this.agent,
+            agentDir: this._agentDir,
+            settingsManager: this.settingsManager,
+            getModelRegistry: () => this._modelRegistry,
+            adaptationStore: modelAdaptationStore,
+            isRawStreamSimple: (fn) => this._isRawStreamSimple(fn),
+            getRequiredRequestAuth: (model) => this._getRequiredRequestAuth(model),
+            addSpawnedUsage: (usage, opts) => this.addSpawnedUsage(usage, opts),
+            emitWarning: (message) => this._emit({ type: "warning", message }),
+            sendCorrectiveSteer: (message) => this.sendCustomMessage({ customType: "text-protocol-corrective-steer", content: message, display: false }, { deliverAs: "nextTurn" }),
+            findLastAssistantMessage: () => this._findLastAssistantMessage(),
+            isDisposed: () => this._disposed,
+            probeForAuto: (model) => this._probeToolCallingForModel(model),
+        });
+        this.agent.onTextToolProtocolParse = (event) => this._toolProtocol.handleTextProtocolParse(event);
+        this._toolProtocol.applyRepairLayerSettings();
         this._collectWorkspaceSources = config.collectWorkspaceSources ?? collectWorkspaceSources;
         this._localRuntimeController = new LocalRuntimeController({
             agentDir: this._agentDir,
@@ -410,7 +380,7 @@ export class AgentSession {
             hasTool: (name) => this._runtimeBuilder.hasTool(name),
             getToolPromptSnippet: (name) => this._runtimeBuilder.getToolPromptSnippet(name),
             getToolPromptGuidelines: (name) => this._runtimeBuilder.getToolPromptGuidelines(name),
-            getModelAdaptationRules: () => this._getModelAdaptationRulesForPrompt(),
+            getModelAdaptationRules: () => this._toolProtocol.getAdaptationRulesForPrompt(),
             getActiveExtensions: () => this._extensionRunner.activeExtensions,
             getContextWindow: () => this.model?.contextWindow,
             getThinkingLevel: () => this.thinkingLevel,
@@ -425,9 +395,9 @@ export class AgentSession {
             getCostSummary: () => this.getCostSummary(),
             getGoalStateSnapshot: () => this.getGoalStateSnapshot(),
             getActiveLaneCount: () => this._backgroundLanes.getActiveLaneCount(),
-            getEvidenceBundleSnapshots: () => this.getEvidenceBundleSnapshots(),
-            getWorkerResultSnapshots: () => this.getWorkerResultSnapshots(),
-            getLearningDecisionSnapshots: () => this.getLearningDecisionSnapshots(),
+            getSessionEvidenceBundleHistory: () => getEvidenceBundleSnapshots(this.sessionManager.getEntries()),
+            getSessionWorkerClaimHistory: () => getWorkerClaimSnapshots(this.sessionManager.getEntries()),
+            getSessionLearningDecisionHistory: () => getLearningDecisionSnapshots(this.sessionManager.getEntries()),
             getLearningAuditRecords: () => this.getLearningAuditRecords(),
         });
         this._modelRegistry = config.modelRegistry;
@@ -439,8 +409,9 @@ export class AgentSession {
             getAgentDir: () => this._agentDir,
             getSessionManager: () => this.sessionManager,
             getSettingsManager: () => this.settingsManager,
+            getActiveOrchestrationProfile: () => config.orchestrationProfile,
             getModelRegistry: () => this._modelRegistry,
-            isModelExhausted: (model) => this._billingFailover.isExhausted(`${model.provider}/${model.id}`),
+            isModelExhausted: (model) => this._foregroundRecovery.isModelExhausted(`${model.provider}/${model.id}`),
             getModel: () => this.model ?? undefined,
             isDelegateToolActive: () => this.getActiveToolNames().includes("delegate"),
             isGoalToolActive: () => this.getActiveToolNames().includes("goal"),
@@ -453,7 +424,8 @@ export class AgentSession {
             getGoalRuntimeSnapshot: (settings) => this.getGoalRuntimeSnapshot(settings),
             getEvidenceBundleSnapshot: () => this.getEvidenceBundleSnapshot(),
             saveEvidenceBundleSnapshot: (bundle) => this.saveEvidenceBundleSnapshot(bundle),
-            saveWorkerResultSnapshot: (result, request) => this.saveWorkerResultSnapshot(result, request),
+            saveWorkerClaimSnapshot: (claim, request) => this.saveWorkerClaimSnapshot(claim, request),
+            queueWorkerHumanInput: (request) => this._queueWorkerHumanInput(request),
             readMemoryForLane: (query) => this._memory.readMemoryForLane(query),
             addSpawnedUsage: (usage, opts) => this.addSpawnedUsage(usage, opts),
             runIsolatedCompletion: (opts) => this.runIsolatedCompletion(opts),
@@ -480,7 +452,7 @@ export class AgentSession {
             getModelRegistry: () => this._modelRegistry,
             isRawStream: () => this._isRawStreamSimple(this.agent.streamFn),
             getRequiredRequestAuth: (model) => this._getRequiredRequestAuth(model),
-            isModelExhausted: (ref) => this._billingFailover.isExhausted(ref),
+            isModelExhausted: (ref) => this._foregroundRecovery.isModelExhausted(ref),
             getStoredFitnessReport: (ref) => this.getStoredFitnessReports().find((entry) => entry.model === ref)?.report,
             // Live context is an over-estimate of the span to summarize (includes the kept tail) —
             // conservative in the safe direction for the summarizer capacity check.
@@ -507,23 +479,51 @@ export class AgentSession {
         });
         const failureCorpusPath = stateFile(this._agentDir, "failure-corpus.jsonl");
         this._toolRecoveryEventLogPath = stateFile(this._agentDir, TOOL_RECOVERY_EVENT_LOG_FILE);
-        const toolRepairSettings = this._toolRepairSettings();
+        const toolRepairSettings = this._toolProtocol.getRepairSettings();
         this._failureCorpus = new FailureCorpusRecorder({
             filePath: failureCorpusPath,
         });
+        this._compaction = new CompactionController({
+            agent: this.agent,
+            sessionManager: this.sessionManager,
+            settingsManager: this.settingsManager,
+            getModel: () => this.model,
+            getAdaptedSettings: () => this._getAdaptedCompactionSettings(),
+            getRequestAuth: (model) => this._getCompactionRequestAuth(model),
+            resolveModelAndAuth: (compactionModel, sessionModel) => this._resolveCompactionModelAndAuth(compactionModel, sessionModel),
+            resolveModel: (sessionModel) => this._resolveCompactionModel(sessionModel),
+            getSelectionReason: () => this._getLastCompactionSelectionReason(),
+            resolveThinkingLevel: (compactionModel, sessionModel) => this._resolveCompactionThinkingLevel(compactionModel, sessionModel),
+            describeSummarizer: () => this._describeCompactionSummarizer(),
+            getExtensionRunner: () => this._extensionRunner,
+            isRawStream: () => this._isRawStreamSimple(this.agent.streamFn),
+            disconnectAgent: () => this._disconnectFromAgent(),
+            reconnectAgent: () => this._reconnectToAgent(),
+            abortForeground: () => this.abort(),
+            emit: (event) => this._emit(event),
+            estimateCurrentContextTokens: (messages) => this._pipeline.estimateCurrentContextTokens(messages),
+            buildPreDigest: () => this._buildCompactionPreDigest(),
+            refreshAfterCompaction: () => this._refreshAfterCompaction(),
+            getFailureCorpus: () => this._failureCorpus,
+            measureLiveContextTokens: () => this._measureLiveContextTokensForCompaction(),
+            runAutoCompaction: (reason, willRetry) => this._runAutoCompaction(reason, willRetry),
+            compactWithRetry: (run, signal, provider) => this._compactWithRetry(run, signal, provider),
+        });
         this._toolRecoveryLogger = new ToolRecoveryLogger({
             enabled: toolRepairSettings.logging,
             sessionId: this.sessionManager.getSessionId(),
             eventLogPath: this._toolRecoveryEventLogPath,
             failureCorpusPath,
         });
-        this._billingFailover = new BillingFailoverController({
+        this._foregroundRecovery = new ForegroundRecoveryController({
             agent: this.agent,
             modelRegistry: this._modelRegistry,
-            exhausted: new ExhaustedProviderRegistry(),
-            subscriptionHop: this.settingsManager.getFailoverSettings().subscriptionHop,
+            settingsManager: this.settingsManager,
+            failureCorpus: this._failureCorpus,
+            getContextWindow: () => this.model?.contextWindow ?? 0,
             emit: (event) => this._emit(event),
-            recordFailure: (args) => this._failureCorpus.record(args),
+            checkCompaction: (message) => this._checkCompaction(message),
+            onSuccessfulAssistant: () => this._compaction.resetOverflowRecovery(),
         });
         this._modelRouter = new ModelRouterController({
             getAgent: () => this.agent,
@@ -531,8 +531,11 @@ export class AgentSession {
             getSettingsManager: () => this.settingsManager,
             getSessionManager: () => this.sessionManager,
             getModelRegistry: () => this._modelRegistry,
-            isModelExhausted: (model) => this._billingFailover.isExhausted(`${model.provider}/${model.id}`),
-            getFailoverStatus: () => ({ ...this._billingFailover.getStatus(), failureStats: this._failureCorpus.stats() }),
+            isModelExhausted: (model) => this._foregroundRecovery.isModelExhausted(`${model.provider}/${model.id}`),
+            getFailoverStatus: () => ({
+                ...this._foregroundRecovery.getFailoverStatus(),
+                failureStats: this._failureCorpus.stats(),
+            }),
             getAgentDir: () => this._agentDir,
             getReflectionSignal: () => this._reflectionAbort.signal,
             getBaseSystemPrompt: () => this._baseSystemPrompt,
@@ -545,7 +548,7 @@ export class AgentSession {
             emitAutonomyTelemetry: (event) => this._emitAutonomyTelemetry(event),
             resolveLaneModel: (pattern) => this._backgroundLanes.resolveLaneModel(pattern),
             resolveCurationModelIfFit: () => this._resolveCurationModelIfFit(),
-            getToolProbeVerdict: (model) => this._toolProbeVerdict(model),
+            getToolProbeVerdict: (model) => this._toolProtocol.getToolProbeVerdict(model),
         });
         this._reflection = new ReflectionController({
             getModel: () => this.model,
@@ -559,7 +562,7 @@ export class AgentSession {
             isChildSession: () => this._isChildSession,
             isDisposed: () => this._disposed,
             getReflectionSignal: () => this._reflectionAbort.signal,
-            resolveTextToolCallProtocol: (model) => this._textProtocolFlag(model),
+            resolveTextToolCallProtocol: (model) => this._resolveModelToolProtocol(model).protocol,
             archivePromotedSkill: (name) => this.archivePromotedSkill(name),
             emitAutonomyTelemetry: (event) => this._emitAutonomyTelemetry(event),
             ensureModelReady: (model) => this._localRuntimeController.ensureIsolatedModelReady(model),
@@ -572,9 +575,19 @@ export class AgentSession {
             recordGoalContinuationPass: (pass) => this.recordGoalContinuationPass(pass),
         });
         this._extensionRunnerRef = config.extensionRunnerRef;
-        this._initialActiveToolNames = config.initialActiveToolNames;
-        this._allowedToolNames = config.allowedToolNames ? new Set(config.allowedToolNames) : undefined;
-        this._excludedToolNames = config.excludedToolNames ? new Set(config.excludedToolNames) : undefined;
+        this._initialActiveToolNames = config.orchestrationProfile
+            ? [...config.orchestrationProfile.toolNames]
+            : config.initialActiveToolNames;
+        this._allowedToolNames = config.orchestrationProfile
+            ? new Set(config.orchestrationProfile.toolNames)
+            : config.allowedToolNames
+                ? new Set(config.allowedToolNames)
+                : undefined;
+        this._excludedToolNames = config.orchestrationProfile
+            ? undefined
+            : config.excludedToolNames
+                ? new Set(config.excludedToolNames)
+                : undefined;
         this._toolProfileFilter = config.toolProfileFilter
             ? { allow: config.toolProfileFilter.allow ?? [], block: config.toolProfileFilter.block ?? [] }
             : undefined;
@@ -591,7 +604,7 @@ export class AgentSession {
             getSessionManager: () => this.sessionManager,
             getSettingsManager: () => this.settingsManager,
             getModelRegistry: () => this._modelRegistry,
-            isModelExhausted: (model) => this._billingFailover.isExhausted(`${model.provider}/${model.id}`),
+            isModelExhausted: (model) => this._foregroundRecovery.isModelExhausted(`${model.provider}/${model.id}`),
             getResourceLoader: () => this._resourceLoader,
             getExtensionRunner: () => this._extensionRunner,
             setExtensionRunner: (runner) => {
@@ -615,6 +628,7 @@ export class AgentSession {
                 this._toolProfileFilter = filter;
             },
             getAllowedToolNames: () => this._allowedToolNames,
+            getOrchestrationProfile: () => config.orchestrationProfile,
             getExcludedToolNames: () => this._excludedToolNames,
             deriveToolProfileFilter: () => this._profileFilter.deriveToolProfileFilter(),
             isToolOrCommandAllowedByProfile: (name) => this._profileFilter.isToolOrCommandAllowedByProfile(name),
@@ -635,6 +649,7 @@ export class AgentSession {
             reapplyActiveProfileModelSettings: () => this._profileFilter.reapplyActiveProfileModelSettings(),
             notifyExtensionsChanged: () => this._notifyExtensionsChanged(),
             getToolArtifactStore: () => this._getToolArtifactStore(),
+            getSessionImageStore: () => this._getSessionImageStore(),
             getMemoryManager: () => this._memory.getMemoryManager(),
             getMemoryAuditDiagnostics: () => this._memory.getMemoryAuditDiagnostics(),
             clearPendingMemoryProviders: () => this._memory.clearPendingProviders(),
@@ -647,8 +662,9 @@ export class AgentSession {
             saveTaskStepsStateSnapshot: (state) => this.saveTaskStepsStateSnapshot(state),
             getContextGcReport: (messages) => this.getContextGcReport(messages),
             startWorkerDelegation: (request) => this._backgroundLanes.startWorkerDelegation(request),
+            getOrchestrationProfileCatalog: () => this._backgroundLanes.getOrchestrationProfileCatalog(),
             getWorkerLaneRecords: () => this._backgroundLanes.getLaneRecords(),
-            getWorkerResultSnapshots: () => this.getWorkerResultSnapshots(),
+            getWorkerClaimSnapshots: () => this.getWorkerClaimSnapshots(),
             resolveManagedLaneId: (id) => this._backgroundLanes.resolveManagedLaneId(id),
             runWorkerDelegationOnce: (request) => this.runWorkerDelegationOnce(request),
             runModelFitness: (args) => this.runModelFitness(args),
@@ -680,7 +696,7 @@ export class AgentSession {
         });
         const previousToolArgumentValidation = this.agent.onToolArgumentValidation;
         this.agent.onToolArgumentValidation = (event) => {
-            const taggedEvent = this._tagModelAdaptationRuleTeaching(event);
+            const taggedEvent = this._toolProtocol.tagAdaptationRuleTeaching(event);
             if (taggedEvent.outcome === "repaired" || taggedEvent.outcome === "bounced") {
                 this._toolSelection.recordValidation(taggedEvent.tool, taggedEvent.outcome);
             }
@@ -689,8 +705,8 @@ export class AgentSession {
             if (!logRecord)
                 return;
             this._analytics.recordToolArgumentValidation(logRecord);
-            this._handleTextToolProtocolValidationOutcome(taggedEvent);
-            this._handleModelAdaptationTelemetry(taggedEvent);
+            this._toolProtocol.handleValidationOutcome(taggedEvent);
+            this._toolProtocol.handleAdaptationTelemetry(taggedEvent);
         };
         this._treeNavigator = new SessionTreeNavigator({
             getSessionManager: () => this.sessionManager,
@@ -940,35 +956,9 @@ export class AgentSession {
             const authoritativeMessages = this.agent.state.messages.length > 0 ? this.agent.state.messages : transformed;
             let currentMessages = authoritativeMessages;
             try {
-                const settings = this._getAdaptedCompactionSettings();
-                const contextWindow = this.model?.contextWindow ?? 0;
-                if (settings.enabled && contextWindow > 0 && !this.isCompacting) {
-                    const triggerTokens = this.model?.autoCompactionTriggerTokens;
-                    const contextTokens = this._estimateCurrentContextTokens(authoritativeMessages);
-                    if (shouldCompact(contextTokens, contextWindow, settings, triggerTokens)) {
-                        // This pre-check runs BEFORE context-gc (below, same transform pass), so the
-                        // raw estimate above can't see this turn's own GC packing. Since context-gc later
-                        // packs the SAME messages before they're ever sent, a raw-over-threshold turn that
-                        // GC alone would bring back under threshold doesn't actually need compaction.
-                        // Project this turn's GC pass read-only (writePayloads=false -- no digest/curation
-                        // enqueue, no disk write, no artifact-reference release; see
-                        // ContextPipeline.applyContextGc) to get the same packed output the real pass would
-                        // produce for these messages, then re-check against ITS estimate. Packing only ever
-                        // shrinks (never grows) a message, so the projected estimate is never higher than
-                        // the raw one: this can only SUPPRESS an unnecessary compaction, never skip a
-                        // genuinely needed one -- the hard near-full trigger inside shouldCompact still
-                        // fires whenever the projected estimate itself remains over threshold.
-                        const gcProjection = this._applyContextGc(authoritativeMessages, false);
-                        const projectedContextTokens = this._estimateCurrentContextTokens(gcProjection.messages);
-                        if (shouldCompact(projectedContextTokens, contextWindow, settings, triggerTokens)) {
-                            const latestBefore = getLatestCompactionEntry(this.sessionManager.getBranch())?.id;
-                            await this._runAutoCompaction("threshold", false);
-                            const latestAfter = getLatestCompactionEntry(this.sessionManager.getBranch())?.id;
-                            if (latestAfter && latestAfter !== latestBefore) {
-                                currentMessages = this.agent.state.messages.slice();
-                            }
-                        }
-                    }
+                if (!this.isCompacting &&
+                    (await this._compaction.maybeCompactBeforeContextTransform(authoritativeMessages, (messages) => this._applyContextGc(messages, false).messages))) {
+                    currentMessages = this.agent.state.messages.slice();
                 }
             }
             catch {
@@ -1005,7 +995,8 @@ export class AgentSession {
      * The ceiling is turn-cumulative: the next foreground call's projection is folded together with
      * background/research/worker/reflection spend recorded SINCE THIS TURN BEGAN — {@link getSpawnedUsage}'s
      * already-recorded rollup (the same read-side-deduped total the footer's SUBAGENTS line uses) minus the
-     * baseline snapshotted at the top of `_promptUnserialized` ({@link _costGuardTurnBaselineUsd}) — so a
+     * baseline snapshotted before a new turn enters routing in `_promptUnserialized`
+     * ({@link _costGuardTurnBaselineUsd}) — so a
      * turn that is cheap in the foreground but has spent heavily via background lanes THIS turn still trips
      * the warning, while a prior turn's background spend does not keep every later turn's guard stuck
      * "over". A background lane that finishes mid-turn is attributed to whichever turn it completes in.
@@ -1106,520 +1097,32 @@ export class AgentSession {
             tools: this.agent.state.tools.slice(),
         };
     }
-    _modelAdaptationKeyFor(model) {
-        return model ? formatModelRouterModel(model) : undefined;
-    }
-    _toolRepairSettings() {
-        return resolveCurrentToolRepairSettings(this.settingsManager.settings);
-    }
-    _applyToolRepairLayerSettings() {
-        const settings = this._toolRepairSettings();
-        this.agent.toolArgumentTeachEnabled = settings.teach;
-    }
-    _getModelAdaptationRulesForPrompt() {
-        if (!this._toolRepairSettings().teach)
-            return [];
-        const modelKey = this._modelAdaptationKeyFor(this.agent.state.model);
-        return modelKey ? this._modelAdaptationStore.get(modelKey).rules : [];
-    }
-    _textProtocolFlag(model) {
-        // Phase 7 gating hierarchy: PI_TEXT_TOOL_CALL_PROTOCOL_DISABLED is resolved
-        // in _toolRepairSettings() as the env kill switch, then settings.toolRepair.textProtocol
-        // force-enables/disables globally, then Model.textToolCallProtocol opts in per model,
-        // then a persisted /toolprobe text-protocol verdict opts in that exact model. The
-        // calibration store is consulted after this flag; native provider tool calls still
-        // win when emitted, and this only enables the text-protocol fallback lane.
-        const override = this._toolRepairSettings().textProtocol;
-        if (override !== undefined)
-            return override;
-        if (model?.textToolCallProtocol === true)
-            return true;
-        const modelKey = this._modelAdaptationKeyFor(model);
-        return !!modelKey && this._modelAdaptationStore.get(modelKey).toolProbe?.status === "text-protocol";
-    }
-    async _streamForToolProbe(model, context, options) {
-        let requestOptions = options;
-        if (this._isRawStreamSimple(this.agent.streamFn)) {
-            const auth = await this._getRequiredRequestAuth(model);
-            requestOptions = {
-                ...options,
-                apiKey: auth.apiKey,
-                headers: auth.headers || options.headers ? { ...auth.headers, ...options.headers } : undefined,
-            };
-        }
-        return this.agent.streamFn(model, context, requestOptions);
-    }
-    /** Builds a reportId that uniquely identifies one probe/calibration completion within the
-     * session: the model, a caller-supplied `kind` (e.g. "read-task", "echo", or
-     * "text-protocol:<variant>"), and a monotonic sequence number. The sequence number (not
-     * wall-clock time or randomness) is what guarantees no collision even when the same model+kind
-     * is probed again later in the session (e.g. a repeated /toolprobe run), so genuine repeat spend
-     * is never silently deduped away. */
-    _nextProbeUsageReportId(model, kind) {
-        return `tool-probe:${this._modelRef(model)}:${kind}:${this._toolProbeUsageReportSeq++}`;
-    }
-    /** Awaits a tool-probe/text-protocol-calibration stream's result and, if the resolved message
-     * carries reportable usage, rolls it into spawned usage under `reportId` so the turn-scoped cost
-     * guard and daily usage see it. These trial completions previously spent tokens with no
-     * addSpawnedUsage call, making them invisible to both. `addSpawnedUsage` dedups on `reportId`, so
-     * a re-report of the same id is a no-op. */
-    async _resolveProbeStreamCountingUsage(stream, label, reportId) {
-        const message = await stream.result();
-        const usage = message.usage;
-        if (usage && (usage.cost.total > 0 || usage.totalTokens > 0)) {
-            this.addSpawnedUsage(usage, { label, reportId });
-        }
-        return message;
-    }
-    _textProtocolCalibrationContext(variant, token) {
-        const primer = generateTextToolProtocolPrimer([TEXT_TOOL_PROTOCOL_ECHO_TOOL], { variant });
-        const instruction = `Text tool protocol calibration trial. Using the protocol above, call echo with data exactly "${token}". Output only the tool-call envelope.`;
-        return {
-            systemPrompt: `${primer}\n\n${instruction}`,
-            messages: [{ role: "user", content: [{ type: "text", text: instruction }], timestamp: Date.now() }],
-        };
-    }
-    _messageHasToolCallWithStringArgument(message, toolName, argName, argValue) {
-        return message.content.some((block) => {
-            if (block.type !== "toolCall" || block.name !== toolName)
-                return false;
-            const args = block.arguments;
-            return (typeof args === "object" &&
-                args !== null &&
-                !Array.isArray(args) &&
-                args[argName] === argValue);
-        });
-    }
-    _nativeToolProbeSystemPrompt(instruction) {
-        const base = (this.agent.state.systemPrompt ?? "").trim();
-        return base ? `${base}\n\n${instruction}` : instruction;
-    }
-    async _runNativeReadTaskProbeTrial(model, path) {
-        const instruction = `Native tool-call capability probe: task-scale read. Use provider-native tool calling, not prose. ` +
-            `Call read exactly once with path exactly "${path}".`;
-        const stream = await this._streamForToolProbe(model, {
-            systemPrompt: this._nativeToolProbeSystemPrompt(instruction),
-            messages: [{ role: "user", content: [{ type: "text", text: instruction }], timestamp: Date.now() }],
-            tools: [NATIVE_TOOL_PROBE_READ_TOOL],
-        }, { textToolCallProtocol: false, maxRetries: 0, temperature: 0, maxTokens: 768 });
-        const message = await this._resolveProbeStreamCountingUsage(stream, "tool-probe", this._nextProbeUsageReportId(model, "read-task"));
-        return this._messageHasToolCallWithStringArgument(message, "read", "path", path);
-    }
-    async _runNativeEchoToolProbeTrial(model, token) {
-        const instruction = `Native tool-call capability probe: echo-only. Use provider-native tool calling, not prose. ` +
-            `Call echo with data exactly "${token}".`;
-        const stream = await this._streamForToolProbe(model, {
-            systemPrompt: this._nativeToolProbeSystemPrompt(instruction),
-            messages: [{ role: "user", content: [{ type: "text", text: instruction }], timestamp: Date.now() }],
-            tools: [TEXT_TOOL_PROTOCOL_ECHO_TOOL],
-        }, { textToolCallProtocol: false, maxRetries: 0, temperature: 0, maxTokens: 256 });
-        const message = await this._resolveProbeStreamCountingUsage(stream, "tool-probe", this._nextProbeUsageReportId(model, "echo"));
-        return this._messageHasToolCallWithStringArgument(message, "echo", "data", token);
-    }
-    async _gradeNativeToolCallingForModel(model, token) {
-        const path = join(getProcessWorkRun(this._agentDir, "probes", "native-tools").path, `pi-native-probe-${process.pid}-${Date.now()}.txt`);
-        writeFileSync(path, token, "utf-8");
-        try {
-            const taskPassed = await this._runNativeReadTaskProbeTrial(model, path);
-            if (taskPassed)
-                return "task";
-            const echoPassed = await this._runNativeEchoToolProbeTrial(model, token);
-            if (echoPassed)
-                return "echo-only";
-            return "absent";
-        }
-        finally {
-            rmSync(path, { force: true });
-        }
-    }
-    async _runTextProtocolTrial(model, variant, token) {
-        const stream = await this._streamForToolProbe(model, this._textProtocolCalibrationContext(variant, token), {
-            textToolCallProtocol: false,
-            maxRetries: 0,
-            temperature: 0,
-            maxTokens: 256,
-        });
-        const message = await this._resolveProbeStreamCountingUsage(stream, "text-protocol-calibration", this._nextProbeUsageReportId(model, `text-protocol:${variant}`));
-        const text = message.content
-            .filter((block) => block.type === "text")
-            .map((block) => block.text)
-            .join("\n")
-            .trim();
-        if (!text)
-            return false;
-        const parsed = parseTextToolCalls(text, [TEXT_TOOL_PROTOCOL_ECHO_TOOL]);
-        return parsed.calls.some((call) => call.name === "echo" && call.arguments.data === token);
-    }
-    async _calibrateTextToolProtocolForModel(model, modelKey, options) {
-        const variantsTried = [];
-        for (const variant of TEXT_TOOL_PROTOCOL_VARIANTS) {
-            variantsTried.push(variant);
-            let passed = true;
-            for (let trial = 0; trial < TEXT_TOOL_PROTOCOL_TRIALS_PER_VARIANT; trial++) {
-                const ok = await this._runTextProtocolTrial(model, variant, `pi-calibration-${trial + 1}`);
-                if (!ok) {
-                    passed = false;
-                    break;
-                }
-            }
-            if (passed) {
-                const calibratedAt = new Date().toISOString();
-                if (modelKey) {
-                    this._modelAdaptationStore.setProtocol(modelKey, { version: TEXT_TOOL_PROTOCOL_VERSION, status: "calibrated", variant, calibratedAt }, calibratedAt);
-                }
-                return { status: "calibrated", variant, calibratedAt };
-            }
-        }
-        const attemptedAt = new Date().toISOString();
-        if (modelKey && options.persistFailure) {
-            this._modelAdaptationStore.setProtocol(modelKey, { version: TEXT_TOOL_PROTOCOL_VERSION, status: "failed", attemptedAt, variantsTried }, attemptedAt);
-        }
-        return { status: "failed", attemptedAt, variantsTried };
-    }
-    /**
-     * A PURE READER of the persisted calibration — never calibrates inline and
-     * never throws out of the prompt path. A model whose flag is on but has no valid current-version
-     * protocol on record falls back to native for this turn (with a warning pointing at /toolprobe)
-     * instead of blocking the user's message behind up to 8 inline calibration completions or
-     * aborting the turn entirely. Calibration now only ever happens off the hot path: explicit
-     * /toolprobe, or the capability-gate spine's evidence-gated auto-probe.
-     */
-    async _ensureTextToolProtocolForActiveModel() {
-        const model = this.agent.state.model;
-        if (!this._textProtocolFlag(model)) {
-            this.agent.textToolCallProtocol = undefined;
-            return;
-        }
-        // Force-enable (a global settings override or Model.textToolCallProtocol) wins regardless of
-        // whether this model has ever been graded-probed — that is the point of an explicit override.
-        // Preserve it exactly as before: default to the tool-tag variant, no inline calibration. Only
-        // the graded-evidence path below (flag on solely because of a persisted toolProbe verdict)
-        // needs a valid persisted protocol to proceed.
-        const forceEnabled = this._toolRepairSettings().textProtocol === true || model?.textToolCallProtocol === true;
-        const modelKey = this._modelAdaptationKeyFor(model);
-        if (!modelKey || forceEnabled) {
-            this.agent.textToolCallProtocol = true;
-            return;
-        }
-        const profile = this._modelAdaptationStore.get(modelKey);
-        if (profile.protocol?.version === TEXT_TOOL_PROTOCOL_VERSION && profile.protocol.status !== "failed") {
-            this.agent.textToolCallProtocol = { variant: profile.protocol.variant };
-            return;
-        }
-        this.agent.textToolCallProtocol = undefined;
-        this._emit({
-            type: "warning",
-            message: profile.protocol?.status === "failed"
-                ? `Text tool protocol calibration for ${modelKey} previously failed (variants tried: ${profile.protocol.variantsTried.join(", ")}); falling back to native tool calls this turn. Run /toolprobe ${modelKey} to recalibrate.`
-                : `Text tool protocol for ${modelKey} has no valid calibration on record; falling back to native tool calls this turn. Run /toolprobe ${modelKey} to calibrate.`,
-        });
+    /** Compatibility seam retained for focused auto-probe regressions. */
+    _probeToolCallingForModel(model) {
+        return this._toolProtocol.probeToolCallingForModel(model);
     }
-    _modelRef(model) {
-        return `${model.provider}/${model.id}`;
-    }
-    /** The persisted `/toolprobe` verdict on record for this model, if any (undefined = unprobed). */
-    _toolProbeVerdict(model) {
-        return this._modelAdaptationStore.get(this._modelRef(model)).toolProbe?.status;
-    }
-    _formatToolProbeReport(results) {
-        const lines = [
-            "Tool probe results:",
-            "Model | Verdict | Variant | Native grade | Diagnostic",
-            "--- | --- | --- | --- | ---",
-        ];
-        for (const result of results) {
-            lines.push([
-                result.model,
-                result.verdict,
-                result.variant ?? "-",
-                result.nativeGrade ?? "-",
-                result.diagnostic ? result.diagnostic.replace(/\s+/g, " ").slice(0, 160) : "-",
-            ].join(" | "));
-        }
-        return lines.join("\n");
-    }
-    _storeToolProbe(modelKey, probe) {
-        this._modelAdaptationStore.setToolProbe(modelKey, probe, probe.probedAt);
-    }
-    async _probeToolCallingForModel(model) {
-        const modelKey = this._modelRef(model);
-        const probedAt = new Date().toISOString();
-        let nativeGrade = "absent";
-        let diagnostic;
-        try {
-            nativeGrade = await this._gradeNativeToolCallingForModel(model, "pi-native-probe");
-            if (nativeGrade === "task") {
-                this._storeToolProbe(modelKey, {
-                    version: TEXT_TOOL_PROTOCOL_VERSION,
-                    status: "native",
-                    probedAt,
-                    nativeGrade,
-                });
-                return { model: modelKey, verdict: "native", nativeGrade };
-            }
-            diagnostic =
-                nativeGrade === "echo-only"
-                    ? "Native echo probe passed but task-scale read probe failed."
-                    : "Native task-scale read and echo probes did not produce provider-native tool calls.";
-        }
-        catch (error) {
-            diagnostic = error instanceof Error ? error.message : String(error);
-        }
-        try {
-            const calibrated = await this._calibrateTextToolProtocolForModel(model, modelKey, { persistFailure: false });
-            if (calibrated.status === "calibrated") {
-                this._storeToolProbe(modelKey, {
-                    version: TEXT_TOOL_PROTOCOL_VERSION,
-                    status: "text-protocol",
-                    probedAt: calibrated.calibratedAt,
-                    variant: calibrated.variant,
-                    nativeGrade,
-                    diagnostic,
-                });
-                return { model: modelKey, verdict: "text-protocol", variant: calibrated.variant, nativeGrade, diagnostic };
-            }
-            diagnostic = `${diagnostic ? `${diagnostic} ` : ""}Text protocol variants failed: ${calibrated.variantsTried.join(", ")}`;
-        }
-        catch (error) {
-            diagnostic = error instanceof Error ? error.message : String(error);
-        }
-        this._storeToolProbe(modelKey, {
-            version: TEXT_TOOL_PROTOCOL_VERSION,
-            status: "none",
-            probedAt,
-            nativeGrade,
-            diagnostic,
-        });
-        return { model: modelKey, verdict: "none", nativeGrade, diagnostic };
-    }
-    async _resolveToolProbeModels(target) {
-        const trimmed = target?.trim();
-        if (!trimmed)
-            return this._modelRegistry.getAvailable();
-        const [provider, ...modelParts] = trimmed.split("/");
-        const modelId = modelParts.join("/");
-        if (!provider || !modelId)
-            throw new Error("Usage: /toolprobe [provider/model]");
-        const exact = this._modelRegistry.find(provider, modelId);
-        if (exact)
-            return [exact];
-        const current = this.agent.state.model;
-        if (current?.provider === provider && current.id === modelId)
-            return [current];
-        throw new Error(`Model not found: ${trimmed}`);
+    /** Compatibility seam retained for focused protocol-selection doctrine regressions. */
+    _resolveModelToolProtocol(model) {
+        return this._toolProtocol.resolveModelToolProtocol(model);
     }
     async probeToolCalling(target) {
-        const models = await this._resolveToolProbeModels(target);
-        if (models.length === 0)
-            throw new Error("No available models to probe.");
-        const results = [];
-        for (const model of models) {
-            results.push(await this._probeToolCallingForModel(model));
-        }
-        return { results, table: this._formatToolProbeReport(results) };
-    }
-    /**
-     * The text-protocol circuit breaker. Every parse failure (from either the
-     * live per-completion {@link Agent.onTextToolProtocolParse} callback or the post-hoc detection in
-     * {@link _recordTextToolProtocolParseOutcomeFromLastAssistant}) gets a throttled one-line
-     * corrective steer for the next turn. On the 3rd consecutive SAME-SIGNATURE failure — graded
-     * evidence a model genuinely cannot speak this dialect, not a single bad turn — the breaker also
-     * demotes the persisted tool-probe verdict to "none" so {@link _textProtocolFlag} reads false next
-     * turn and native is attempted instead of thrashing on a protocol this model has proven it can't
-     * follow.
-     */
-    _handleTextToolProtocolParse(event) {
-        this._textProtocolParseObservedThisTurn = true;
-        const modelKey = `${event.provider}/${event.model}`;
-        if (event.status === "parsed")
-            return;
-        this._maybeInjectTextProtocolCorrectiveSteer(event.variant);
-        const signature = `${event.variant}:${event.reason ?? "failed"}`;
-        const previous = this._textProtocolParseFailures.get(modelKey);
-        const repeats = previous?.signature === signature ? previous.repeats + 1 : 1;
-        this._textProtocolParseFailures.set(modelKey, { signature, repeats });
-        if (repeats < TEXT_TOOL_PROTOCOL_PARSE_FAILURE_THRESHOLD)
-            return;
-        const profile = this._modelAdaptationStore.get(modelKey);
-        if (profile.protocol?.version === TEXT_TOOL_PROTOCOL_VERSION && profile.protocol.status !== "failed") {
-            this._modelAdaptationStore.removeProtocol(modelKey);
-            this.agent.textToolCallProtocol = undefined;
-        }
-        this._textProtocolParseFailures.delete(modelKey);
-        // Demote on graded evidence -- TEXT_TOOL_PROTOCOL_PARSE_FAILURE_THRESHOLD identical-signature
-        // parse failures in a row -- rather than thrashing every turn. The fresh probedAt doubles as
-        // the capability-gate spine's auto-probe freshness gate, so this demotion doesn't immediately
-        // trigger a re-probe/re-phone loop.
-        const probedAt = new Date().toISOString();
-        this._modelAdaptationStore.setToolProbe(modelKey, {
-            version: TEXT_TOOL_PROTOCOL_VERSION,
-            status: "none",
-            probedAt,
-            nativeGrade: profile.toolProbe?.nativeGrade,
-            diagnostic: `Text protocol parsing failed ${TEXT_TOOL_PROTOCOL_PARSE_FAILURE_THRESHOLD}x in a row with signature "${signature}".`,
-        }, probedAt);
-        this._emit({
-            type: "warning",
-            message: `Text tool protocol for ${modelKey} stopped parsing after ${TEXT_TOOL_PROTOCOL_PARSE_FAILURE_THRESHOLD} attempts; demoted to native fallback. Run /toolprobe ${modelKey} to recalibrate.`,
-        });
-    }
-    /**
-     * A phone model whose envelope fails to parse gets no corrective guidance today —
-     * the runaway-loop backstop only trips on repeated PARSED tool-call signatures (agent-loop.ts), so
-     * an every-turn unparseable-prose model never trips it. Inject a one-line reminder of the envelope
-     * shape as a nextTurn message, reusing {@link formatVariantEnvelope} so the reminder can never
-     * drift from the grammar the primer actually teaches. Throttled to the first failure this session
-     * and then every {@link TEXT_TOOL_PROTOCOL_STEER_INTERVAL}th after — the breaker above is what
-     * actually demotes a genuinely-failing model at the 3rd same-signature failure; this is guidance,
-     * not a second counter.
-     */
-    _maybeInjectTextProtocolCorrectiveSteer(variant) {
-        this._textProtocolCorrectiveSteerCount++;
-        if (this._textProtocolCorrectiveSteerCount !== 1 &&
-            this._textProtocolCorrectiveSteerCount % TEXT_TOOL_PROTOCOL_STEER_INTERVAL !== 0) {
-            return;
-        }
-        const reminder = `Reminder: to call a tool, emit exactly this envelope shape: ${formatVariantEnvelope(variant, "TOOL", '{"arg":"value"}')} — no other format is recognized. Reasoning may appear as prose before the envelope, never inside it.`;
-        this.sendCustomMessage({ customType: "text-protocol-corrective-steer", content: reminder, display: false }, { deliverAs: "nextTurn" }).catch(() => {
-            // Best-effort steer; a failure to queue it must not break parse-failure handling.
-        });
-    }
-    _handleTextToolProtocolValidationOutcome(event) {
-        if (event.source !== "text-protocol")
-            return;
-        const protocol = this.agent.textToolCallProtocol;
-        const variant = protocol === true ? "tool-tag" : protocol ? protocol.variant : undefined;
-        if (!variant)
-            return;
-        const status = event.outcome === "bounced" ? "failed" : "parsed";
-        if (this._textProtocolValidationOutcomeThisTurn?.status === "parsed" && status === "failed")
-            return;
-        this._textProtocolValidationOutcomeThisTurn = {
-            provider: event.provider ?? this.agent.state.model.provider,
-            model: event.model ?? this.agent.state.model.id,
-            variant,
-            status,
-            callCount: 1,
-            textLength: 0,
-            ...(status === "failed" && {
-                reason: event.errorKeywords?.includes("unknown_tool") ? "unknown-tool" : "validation-failed",
-            }),
-        };
-    }
-    _recordTextToolProtocolParseOutcomeFromLastAssistant() {
-        const validationOutcome = this._textProtocolValidationOutcomeThisTurn;
-        this._textProtocolValidationOutcomeThisTurn = undefined;
-        if (validationOutcome?.status === "parsed") {
-            this._textProtocolParseObservedThisTurn = true;
-            this._textProtocolParseFailures.delete(`${validationOutcome.provider}/${validationOutcome.model}`);
-            return;
-        }
-        if (validationOutcome) {
-            this._handleTextToolProtocolParse(validationOutcome);
-            return;
-        }
-        if (this._textProtocolParseObservedThisTurn)
-            return;
-        const protocol = this.agent.textToolCallProtocol;
-        if (protocol === false || protocol === true || !protocol?.variant)
-            return;
-        const response = this._findLastAssistantMessage();
-        if (!response)
-            return;
-        const responseText = response.content
-            .filter((content) => content.type === "text")
-            .map((content) => content.text)
-            .join("\n");
-        if (!responseText)
-            return;
-        const parsed = parseTextToolCalls(responseText, this.agent.state.tools);
-        const attempted = parsed.attempted || this._looksLikeTextToolProtocolAttempt(responseText);
-        if (!attempted)
-            return;
-        this._handleTextToolProtocolParse({
-            provider: this.agent.state.model.provider,
-            model: this.agent.state.model.id,
-            variant: protocol.variant,
-            status: parsed.calls.length > 0 ? "parsed" : "failed",
-            reason: parsed.failure,
-            callCount: parsed.calls.length,
-            textLength: responseText.length,
-        });
-    }
-    _looksLikeTextToolProtocolAttempt(text) {
-        return /<pi:call\b|<tool_call\b|```(?:tool|tool_call)[\s\S]*"name"\s*:/i.test(text);
-    }
-    _tagModelAdaptationRuleTeaching(event) {
-        if (!this._toolRepairSettings().teach || event.taught !== "none")
-            return event;
-        const modelKey = event.provider && event.model
-            ? `${event.provider}/${event.model}`
-            : this._modelAdaptationKeyFor(this.agent.state.model);
-        if (!modelKey)
-            return event;
-        try {
-            const rules = this._modelAdaptationStore.get(modelKey).rules;
-            const modes = new Set([...event.failureModes, ...event.repairsApplied]);
-            if (rules.some((rule) => modes.has(rule.mode))) {
-                return { ...event, taught: "rule" };
-            }
-        }
-        catch {
-            // Adaptation telemetry tagging is best-effort; leave the original event unchanged.
-        }
-        return event;
-    }
-    _repairSessionCount(modelKey, mode) {
-        const key = `${modelKey}\0${mode}`;
-        const count = (this._repairModeSessionCounts.get(key) ?? 0) + 1;
-        this._repairModeSessionCounts.set(key, count);
-        return count;
-    }
-    _handleModelAdaptationTelemetry(event) {
-        if (!this._toolRepairSettings().teach || event.outcome !== "repaired" || event.repairsApplied.length === 0)
-            return;
-        const modelKey = event.provider && event.model
-            ? `${event.provider}/${event.model}`
-            : this._modelAdaptationKeyFor(this.agent.state.model);
-        if (!modelKey)
-            return;
-        try {
-            for (const mode of [...new Set(event.repairsApplied)]) {
-                const profile = this._modelAdaptationStore.get(modelKey);
-                const stats = profile.teachStats[mode] ?? { taught: 0, recurrenceBefore: 0, recurrenceAfter: 0 };
-                if (profile.rules.some((rule) => rule.mode === mode)) {
-                    this._modelAdaptationStore.markRuleFired(modelKey, mode);
-                    this._modelAdaptationStore.setTeachStats(modelKey, mode, {
-                        ...stats,
-                        recurrenceAfter: stats.recurrenceAfter + 1,
-                    });
-                    continue;
-                }
-                const recurrenceBefore = stats.recurrenceBefore + 1;
-                this._modelAdaptationStore.setTeachStats(modelKey, mode, { ...stats, recurrenceBefore });
-                const sessionCount = this._repairSessionCount(modelKey, mode);
-                if (sessionCount >= MODEL_ADAPTATION_REPAIR_THRESHOLD ||
-                    recurrenceBefore >= MODEL_ADAPTATION_REPAIR_THRESHOLD) {
-                    this._modelAdaptationStore.addRule(modelKey, {
-                        mode,
-                        text: formatToolRepairStandingRule(mode),
-                    });
-                    this._modelAdaptationStore.setTeachStats(modelKey, mode, {
-                        ...stats,
-                        taught: stats.taught + 1,
-                        recurrenceBefore,
-                    });
-                }
-            }
-        }
-        catch {
-            // Model adaptation is best-effort; failed telemetry persistence must not affect the turn.
-        }
+        return this._toolProtocol.probeToolCalling(target);
     }
     /** Tool-build call-site delegation to {@link ContextPipeline.getToolArtifactStore}. */
     _getToolArtifactStore() {
         return this._pipeline.getToolArtifactStore();
     }
+    _getSessionImageStore() {
+        const directory = this.settingsManager.getClipboardImageDirectory();
+        if (!this.sessionManager.isPersisted() && !directory)
+            return undefined;
+        return new SessionImageStore({
+            agentDir: this._agentDir,
+            cwd: this._cwd,
+            sessionId: this.sessionId,
+            directory,
+        });
+    }
     /**
      * Context-transform hot-path delegation to {@link ContextPipeline.runContextAudit}. Kept as a
      * one-line method (not inlined) so the transform stays the single owner of the pass ordering.
@@ -1767,7 +1270,7 @@ export class AgentSession {
     }
     formatToolRepairHealthReport() {
         return [
-            formatToolRepairHealthReport(this._modelAdaptationStore, new Date(), this._toolRecoveryLogger.getStats()),
+            this._toolProtocol.formatRepairHealth(this._toolRecoveryLogger.getStats()),
             formatToolSelectionReport(this._toolSelection.getReport()),
         ].join("\n\n");
     }
@@ -1775,12 +1278,10 @@ export class AgentSession {
         await this._toolRecoveryLogger.flush(timeoutMs);
     }
     removeToolRepairRule(model, mode) {
-        return this._modelAdaptationStore.removeRule(model, mode);
+        return this._toolProtocol.removeRepairRule(model, mode);
     }
     resetToolProtocolCalibration(model) {
-        const removed = this._modelAdaptationStore.removeProtocol(model);
-        this._textProtocolParseFailures.delete(model);
-        return removed;
+        return this._toolProtocol.resetProtocolCalibration(model);
     }
     /** Curation status for diagnostics/dashboard: settings, live telemetry, last refusal reason. */
     /** Curation status for diagnostics/dashboard (delegates to {@link ContextPipeline.getContextCurationStatus}). */
@@ -1825,14 +1326,6 @@ export class AgentSession {
     getContextGcReport(messages) {
         return this._pipeline.getContextGcReport(messages);
     }
-    /**
-     * Context-transform hot-path delegation to {@link ContextPipeline.estimateCurrentContextTokens}. Kept
-     * as a one-line method (not inlined) so the transform stays the single owner of the pass ordering;
-     * also feeds the per-turn cost guard.
-     */
-    _estimateCurrentContextTokens(messages) {
-        return this._pipeline.estimateCurrentContextTokens(messages);
-    }
     _installAgentToolHooks() {
         this.agent.beforeToolCall = this._toolGate.beforeToolCall;
         this.agent.afterToolCall = this._toolGate.afterToolCall;
@@ -1859,17 +1352,6 @@ export class AgentSession {
             message: `Stopped: the model repeated the same tool call ${info.repeats} times in a row without making progress. Review the last tool result and steer or retry with a different approach.`,
         });
     }
-    /** Anti-loop: true when this model's persisted tool-probe verdict was written within the
-     * auto-probe freshness window ({@link AUTO_TOOL_PROBE_FRESHNESS_MS}) — covers a very recent
-     * explicit `/toolprobe` run or a fresh circuit-breaker demote from an EARLIER session, complementing
-     * the in-session {@link _autoProbedModels} latch. */
-    _hasFreshToolProbeVerdict(modelKey) {
-        const probedAt = this._modelAdaptationStore.get(modelKey).toolProbe?.probedAt;
-        if (!probedAt)
-            return false;
-        const age = Date.now() - new Date(probedAt).getTime();
-        return Number.isFinite(age) && age >= 0 && age < AUTO_TOOL_PROBE_FRESHNESS_MS;
-    }
     /**
      * Evidence-gated native→phone auto-probe for a LOCAL/MANAGED model (never cloud — see
      * {@link isLocalOrManagedRouterModel}) that just crossed the tool-argument-validation escalation
@@ -1880,36 +1362,11 @@ export class AgentSession {
      * "native" and is never phoned) entirely OFF the hot path — fired here but never awaited by the
      * caller, so a slow or failing probe can never block or throw the user's in-flight turn.
      * Anti-loop: skipped when this session already auto-probed this model, or a fresh persisted
-     * verdict already exists ({@link _hasFreshToolProbeVerdict}) — otherwise a model that keeps
+     * verdict already exists (enforced by {@link ToolProtocolController}) — otherwise a model that keeps
      * failing validation every turn would re-fire the (multi-completion) probe every single turn.
      */
     _maybeAutoProbeOnValidationEscalation(model) {
-        const modelKey = this._modelRef(model);
-        if (this._autoProbedModels.has(modelKey) || this._hasFreshToolProbeVerdict(modelKey))
-            return;
-        this._autoProbedModels.add(modelKey);
-        void this._probeToolCallingForModel(model)
-            .then((result) => {
-            if (this._disposed)
-                return;
-            const detail = result.verdict === "text-protocol"
-                ? ` (variant ${result.variant}); it will use the text tool protocol starting next turn`
-                : result.verdict === "none"
-                    ? " — no working tool-call path was found; run /toolprobe for details"
-                    : "; native tool calls stay in use";
-            this._emit({
-                type: "warning",
-                message: `Auto-probed ${modelKey} after repeated native tool-call validation failures: verdict "${result.verdict}"${detail}.`,
-            });
-        })
-            .catch((error) => {
-            if (this._disposed)
-                return;
-            this._emit({
-                type: "warning",
-                message: `Auto-probe for ${modelKey} (triggered by repeated tool-call validation failures) did not complete: ${error instanceof Error ? error.message : String(error)}.`,
-            });
-        });
+        this._toolProtocol.maybeAutoProbe(model);
     }
     /**
      * A repeated identical tool-argument-validation failure crossed the escalation threshold
@@ -1960,11 +1417,23 @@ export class AgentSession {
         }
     }
     async _notifyWorkerTerminalHandoff(records) {
-        if (this._disposed || records.length === 0)
+        if (records.length === 0)
             return;
+        if (this._disposed)
+            throw new Error("Session disposed before worker terminal handoff was persisted");
+        // sendCustomMessage only queues in process memory while the foreground is streaming. Wait for
+        // the owning run to settle so a successful return proves the handoff reached session storage
+        // before the durable notification outbox marks it delivered.
+        await this.agent.waitForIdle();
+        if (this._disposed)
+            throw new Error("Session disposed before worker terminal handoff was persisted");
         const included = records.slice(0, 8);
         const sanitize = (value) => value.replace(/[\r\n]+/g, " ").slice(0, 120);
         const omitted = records.length - included.length;
+        const workerRequestsAwaitingDelivery = new Set(getWorkerHumanInputsRequiringDelivery(this.sessionManager).flatMap((snapshot) => snapshot.request.workerRequestId ? [snapshot.request.workerRequestId] : []));
+        const ownerQuestionWillWakeParent = this._extensionUIContext !== undefined &&
+            this._extensionMode !== "print" &&
+            records.every((record) => workerRequestsAwaitingDelivery.has(record.laneId));
         const content = [
             "Background worker terminal handoff:",
             ...included.map((record) => {
@@ -1979,7 +1448,7 @@ export class AgentSession {
             content,
             display: true,
             details: { records: included },
-        }, { triggerTurn: true, deliverAs: "followUp" });
+        }, { triggerTurn: !ownerQuestionWillWakeParent, deliverAs: "followUp" });
     }
     _emitQueueUpdate() {
         this._emit({
@@ -1989,8 +1458,6 @@ export class AgentSession {
             commands: [...this._queuedExtensionCommands],
         });
     }
-    // Track last assistant message for auto-compaction check
-    _lastAssistantMessage = undefined;
     /**
      * User messages already painted to the UI by an early, synthetic `message_start` fired from
      * `_promptUnserialized` — before the model-router judge's bounded LLM call — so the prompt
@@ -2006,7 +1473,7 @@ export class AgentSession {
         // When a user message starts, check if it's from either queue and remove it BEFORE emitting
         // This ensures the UI sees the updated queue state
         if (event.type === "message_start" && event.message.role === "user") {
-            this._overflowRecoveryAttempted = false;
+            this._compaction.resetOverflowRecovery();
             const messageText = this._getUserMessageText(event.message);
             if (messageText) {
                 // Check steering queue first
@@ -2065,41 +1532,21 @@ export class AgentSession {
                 messagePersisted = true;
             }
             // Other message types (bashExecution, compactionSummary, branchSummary) are persisted elsewhere
-            // Track assistant message for auto-compaction (checked on agent_end)
+            // Track the response for ordered retry/failover/compaction handling after agent_end.
             if (event.message.role === "assistant") {
-                this._lastAssistantMessage = event.message;
                 const assistantMsg = event.message;
                 if (messagePersisted) {
                     this._pipeline.observeProviderUsage(this.agent.state.messages, assistantMsg);
                 }
-                if (assistantMsg.stopReason !== "error") {
-                    this._overflowRecoveryAttempted = false;
-                }
-                // Reset retry counter immediately on successful assistant response
-                // This prevents accumulation across multiple LLM calls within a turn
-                if (assistantMsg.stopReason !== "error" && this._retryController.attempt > 0) {
-                    this._emit({
-                        type: "auto_retry_end",
-                        success: true,
-                        attempt: this._retryController.attempt,
-                    });
-                    this._retryController.reset();
-                }
+                this._foregroundRecovery.observeAssistant(assistantMsg);
             }
         }
+        if (event.type === "agent_end" && !this._willRetryAfterAgentEnd(event)) {
+            this._schedulePendingWorkerHumanInputs();
+        }
     };
     _willRetryAfterAgentEnd(event) {
-        const settings = this.settingsManager.getRetrySettings();
-        if (!settings.enabled || this._retryController.attempt >= settings.maxRetries) {
-            return false;
-        }
-        for (let i = event.messages.length - 1; i >= 0; i--) {
-            const message = event.messages[i];
-            if (message.role === "assistant") {
-                return this._isRetryableError(message);
-            }
-        }
-        return false;
+        return this._foregroundRecovery.willRetryAfterAgentEnd(event);
     }
     /** Extract text content from a message */
     _getUserMessageText(message) {
@@ -2287,45 +1734,50 @@ export class AgentSession {
      * Call this when completely done with the session.
      */
     dispose() {
-        try {
-            this._backgroundLanes.clearGoalAutoContinueTimer();
-            this._backgroundLanes.clearResearchLaneTimer();
-            this.abortRetry();
-            this.abortCompaction();
-            this.abortBranchSummary();
-            this.abortBash();
-            disposePersistentShellSession(this._shellSessionKey);
-            this._cancelPrefixWarm();
-            this.agent.abort();
-            // Stop any deployment-registered gateway channels / schedulers.
-            void this._gatewayRegistry.stop().catch(() => { });
-            // Abort any in-flight background reflection so it cannot keep spending tokens or
-            // write memory/skills against this now-disposed session.
-            this._disposed = true;
-            this._reflectionAbort.abort();
-            // Abort any in-flight research pass or delegated worker for the same reason: a disposed
-            // session must not keep spending tokens or persist evidence against dead state.
-            this._backgroundLanes.abortInFlightLanes();
-            // Clear the hooks this session installed on the shared agent so their closures stop
-            // pinning this (deactivated) session — and all its history/maps — in memory if the agent
-            // instance outlives the session.
+        if (this._disposed)
+            return;
+        this._disposed = true;
+        const shutdowns = [];
+        const safely = (action) => {
+            try {
+                action();
+            }
+            catch {
+                // Every independent cleanup remains best-effort; one failure cannot skip the rest.
+            }
+        };
+        const track = (action) => {
+            try {
+                shutdowns.push(action());
+            }
+            catch {
+                // A synchronously throwing async-resource adapter cannot skip the remaining shutdowns.
+            }
+        };
+        safely(() => this._backgroundLanes.clearGoalAutoContinueTimer());
+        safely(() => this._backgroundLanes.clearResearchLaneTimer());
+        safely(() => this.abortRetry());
+        safely(() => this.abortCompaction());
+        safely(() => this.abortBranchSummary());
+        safely(() => this.abortBash());
+        safely(() => disposePersistentShellSession(this._shellSessionKey));
+        safely(() => this._cancelPrefixWarm());
+        safely(() => this.agent.abort());
+        track(() => this._gatewayRegistry.stop());
+        safely(() => this._reflectionAbort.abort());
+        safely(() => this._backgroundLanes.abortInFlightLanes());
+        safely(() => {
             this.agent.afterToolCall = undefined;
             this.agent.transformContext = undefined;
-        }
-        catch {
-            // Dispose must succeed even if an abort hook throws.
-        }
-        this._extensionRunner.invalidate("This extension ctx is stale after session replacement or reload. Do not use a captured pi or command ctx after ctx.newSession(), ctx.fork(), ctx.switchSession(), or ctx.reload(). For newSession, fork, and switchSession, move post-replacement work into withSession and use the ctx passed to withSession. For reload, do not use the old ctx after await ctx.reload().");
-        this._disconnectFromAgent();
+        });
+        safely(() => this._extensionRunner.invalidate("This extension ctx is stale after session replacement or reload. Do not use a captured pi or command ctx after ctx.newSession(), ctx.fork(), ctx.switchSession(), or ctx.reload(). For newSession, fork, and switchSession, move post-replacement work into withSession and use the ctx passed to withSession. For reload, do not use the old ctx after await ctx.reload()."));
+        safely(() => this._disconnectFromAgent());
         this._eventListeners = [];
         // Best-effort memory cleanup (release locks/handles). Write-side onSessionEnd is wired on a
         // true session-end hook; file-store shutdown is a no-op.
-        void this._memory
-            .getMemoryManager()
-            .shutdownAll()
-            .catch(() => { });
-        void this._toolRecoveryLogger.shutdown().catch(() => { });
-        cleanupSessionResources(this.sessionId);
+        track(() => this._memory.getMemoryManager().shutdownAll());
+        track(() => this._toolRecoveryLogger.shutdown());
+        safely(() => cleanupSessionResources(this.sessionId));
         // Best-effort final sweep for any grep/find artifact already released (reference
         // count zero) but not yet reclaimed -- e.g. a release whose cleanup() call failed
         // transiently. This is conservative: it never releases a still-referenced
@@ -2333,12 +1785,13 @@ export class AgentSession {
         // short to cross preserveRecentMessages) correctly leaves that artifact in place,
         // resolvable if the same session is resumed later. It does not sweep OTHER
         // sessions' artifact directories.
-        try {
-            this._pipeline.cleanupToolArtifactStoreOnDispose();
-        }
-        catch {
-            // Best-effort; dispose must succeed regardless.
-        }
+        safely(() => this._pipeline.cleanupToolArtifactStoreOnDispose());
+        this._disposeCompletion = Promise.allSettled(shutdowns).then(() => undefined);
+    }
+    /** Dispose synchronously-visible state, then await all session-owned asynchronous shutdowns. */
+    async disposeAndWait() {
+        this.dispose();
+        await this._disposeCompletion;
     }
     // =========================================================================
     // Read-only State Access
@@ -2365,7 +1818,7 @@ export class AgentSession {
     }
     /** Current retry attempt (0 if not retrying) */
     get retryAttempt() {
-        return this._retryController.attempt;
+        return this._foregroundRecovery.attempt;
     }
     /**
      * Get the names of currently active tools.
@@ -2415,7 +1868,7 @@ export class AgentSession {
      * Changes take effect on the next agent turn.
      *
      * artifact_retrieve is auto-activated as a companion whenever an artifact-producing tool
-     * (grep, find, or run_toolkit_script) ends up in the resulting active set and artifact_retrieve
+     * (grep, find, run_toolkit_script, or ask_question) ends up in the resulting active set and artifact_retrieve
      * is registered (i.e. not excluded/
      * blocked/outside an allowlist -- the registry itself is built with that same filter,
      * so registry presence already tracks "allowed"). This is enforced here, not just in
@@ -2449,7 +1902,8 @@ export class AgentSession {
         }
         if (validToolNames.includes("grep") ||
             validToolNames.includes("find") ||
-            validToolNames.includes("run_toolkit_script")) {
+            validToolNames.includes("run_toolkit_script") ||
+            validToolNames.includes("ask_question")) {
             addIfRegistered("artifact_retrieve");
         }
         if (validToolNames.includes("delegate")) {
@@ -2463,9 +1917,7 @@ export class AgentSession {
     }
     /** Whether compaction or branch summarization is currently running */
     get isCompacting() {
-        return (this._autoCompactionAbortController !== undefined ||
-            this._compactionAbortController !== undefined ||
-            this._branchSummaryAbortController !== undefined);
+        return this._compaction.isRunning() || this._branchSummaryAbortController !== undefined;
     }
     /** All messages including custom types like BashExecutionMessage */
     get messages() {
@@ -2536,7 +1988,7 @@ export class AgentSession {
         try {
             const maxGoalLoopRounds = this.settingsManager.getAutonomySettings().maxStallTurns;
             this.agent.maxStallTurns = maxGoalLoopRounds;
-            await this._ensureTextToolProtocolForActiveModel();
+            await this._toolProtocol.ensureActiveModelProtocol();
             let goalLoopRounds = 1;
             await this.agent.prompt(messages);
             while ((maxGoalLoopRounds === 0 || goalLoopRounds < maxGoalLoopRounds) && (await this._handlePostAgentRun())) {
@@ -2549,6 +2001,187 @@ export class AgentSession {
             await this._drainQueuedExtensionCommands();
         }
     }
+    _queueWorkerHumanInput(request) {
+        const existing = getLatestHumanInputSnapshots(this.sessionManager).find((snapshot) => snapshot.request.workerRequestId === request.workerRequestId);
+        if (existing)
+            return;
+        const blockerText = request.blockers
+            .slice(0, 4)
+            .map((blocker) => blocker.slice(0, 500))
+            .join("; ");
+        const question = createHumanInputRequest({
+            source: "worker",
+            workerRequestId: request.workerRequestId,
+            questions: [
+                {
+                    id: "worker_review",
+                    header: "Worker review",
+                    question: `${request.message.slice(0, 1_500)}${blockerText ? ` Blockers: ${blockerText}` : ""}`,
+                    options: [
+                        {
+                            label: "Review now",
+                            description: "Have the parent inspect the worker claim and evidence before reconciling it.",
+                        },
+                        {
+                            label: "Keep blocked",
+                            description: "Leave the worker result blocked and continue without accepting its output.",
+                        },
+                    ],
+                },
+            ],
+            acceptsImages: false,
+        });
+        beginHumanInputRequest(this.sessionManager, question);
+        if (!this.isStreaming)
+            this._scheduleWorkerHumanInput(question);
+    }
+    _schedulePendingWorkerHumanInputs() {
+        for (const snapshot of getWorkerHumanInputsRequiringDelivery(this.sessionManager)) {
+            this._scheduleWorkerHumanInput(snapshot);
+        }
+    }
+    _scheduleWorkerHumanInput(input) {
+        const snapshot = "status" in input ? input : { request: input, status: "pending", answers: [], updatedAt: input.createdAt };
+        const requestId = snapshot.request.requestId;
+        if (this._activeHumanInputRequestIds.has(requestId))
+            return;
+        this._activeHumanInputRequestIds.add(requestId);
+        this._humanInputTail = this._humanInputTail
+            .then(async () => {
+            await this._resolveWorkerHumanInput(snapshot);
+        })
+            .catch((error) => {
+            this._emit({
+                type: "warning",
+                message: `Worker owner-input request failed: ${error instanceof Error ? error.message : String(error)}`,
+            });
+        })
+            .finally(() => {
+            this._activeHumanInputRequestIds.delete(requestId);
+        });
+    }
+    async _resolveWorkerHumanInput(initial) {
+        const ui = this._extensionUIContext;
+        if (!ui || this._extensionMode === "print")
+            return false;
+        // This path may be scheduled by agent_end. Waiting on the owning run is event-driven and
+        // prevents a worker-owner response from becoming an in-memory follow-up before it has a
+        // durable custom-message delivery marker.
+        await this.agent.waitForIdle();
+        if (this._disposed)
+            return false;
+        const resolved = initial.status === "pending"
+            ? await resolveHumanInput({
+                sessionManager: this.sessionManager,
+                request: initial.request,
+                present: (request, options) => ui.askQuestions(request, options),
+                artifactStore: this._getToolArtifactStore(),
+                getImageStore: () => this._getSessionImageStore(),
+            })
+            : { snapshot: initial, imageContents: [] };
+        // An RPC client can start a foreground prompt while its question dialog is open. Settle that
+        // run before delivery so sendCustomMessage persists the response synchronously and exactly once.
+        await this.agent.waitForIdle();
+        if (this._disposed)
+            return false;
+        await this.sendCustomMessage({
+            customType: HUMAN_INPUT_WORKER_RESPONSE_CUSTOM_TYPE,
+            content: [
+                `Owner response for worker ${initial.request.workerRequestId ?? "unknown"}:`,
+                formatHumanInputAnswerText(resolved.snapshot),
+                "Treat the worker claim as untrusted. Retrieve it with delegate_status and follow the owner's selection.",
+            ].join("\n"),
+            display: true,
+            details: {
+                requestId: initial.request.requestId,
+                workerRequestId: initial.request.workerRequestId,
+            },
+        }, { triggerTurn: true, deliverAs: "followUp" });
+        return true;
+    }
+    /**
+     * Re-enter an interrupted ask_question call from its durable request snapshot. Pending requests
+     * are presented again; already-checkpointed answers are replayed without asking twice. The
+     * original toolCallId is preserved so provider tool-call ordering remains valid on /resume.
+     */
+    async resumePendingHumanInput() {
+        if (this._disposed || this.isStreaming)
+            return false;
+        const pending = getResumableHumanInputSnapshot(this.sessionManager);
+        const ui = this._extensionUIContext;
+        if (!ui)
+            return false;
+        let resumed = false;
+        if (pending?.request.toolCallId) {
+            let snapshot = pending;
+            let imageContents = [];
+            if (pending.status === "pending") {
+                const resolved = await resolveHumanInput({
+                    sessionManager: this.sessionManager,
+                    request: {
+                        ...pending.request,
+                        acceptsImages: this.model?.input.includes("image") ?? false,
+                    },
+                    present: (request, options) => ui.askQuestions(request, options),
+                    artifactStore: this._getToolArtifactStore(),
+                    getImageStore: () => this._getSessionImageStore(),
+                });
+                snapshot = resolved.snapshot;
+                imageContents = resolved.imageContents;
+            }
+            else if (pending.status === "answered") {
+                const imageStore = this._getSessionImageStore();
+                if (imageStore) {
+                    const referencedText = snapshot.answers
+                        .flatMap((answer) => [answer.custom ?? "", ...(answer.images?.map((image) => image.label) ?? [])])
+                        .join(" ");
+                    imageContents = imageStore.resolveReferences(referencedText);
+                }
+            }
+            const answerImageCount = snapshot.answers.reduce((total, answer) => total + (answer.images?.length ?? 0), 0);
+            const modelAcceptsImages = this.model?.input.includes("image") ?? false;
+            const missingImageNotice = answerImageCount > imageContents.length
+                ? `\n\n[${answerImageCount - imageContents.length} attached image(s) could not be restored from durable storage.]`
+                : "";
+            const unsupportedImageNotice = imageContents.length > 0 && !modelAcceptsImages
+                ? "\n\n[Attached images were retained but not sent because the selected model does not accept image input.]"
+                : "";
+            const toolResult = {
+                role: "toolResult",
+                toolCallId: pending.request.toolCallId,
+                toolName: pending.request.toolName ?? "ask_question",
+                content: [
+                    {
+                        type: "text",
+                        text: `${formatHumanInputAnswerText(snapshot)}${missingImageNotice}${unsupportedImageNotice}`,
+                    },
+                    ...(modelAcceptsImages ? imageContents : []),
+                ],
+                details: {
+                    questions: snapshot.request.questions,
+                    answers: snapshot.answers,
+                    cancelled: snapshot.status === "cancelled",
+                    ...(snapshot.reason ? { reason: snapshot.reason } : {}),
+                },
+                isError: false,
+                timestamp: Date.now(),
+            };
+            await this._runAgentPrompt(toolResult);
+            resumed = true;
+        }
+        for (const workerInput of getWorkerHumanInputsRequiringDelivery(this.sessionManager)) {
+            if (this._activeHumanInputRequestIds.has(workerInput.request.requestId))
+                continue;
+            this._activeHumanInputRequestIds.add(workerInput.request.requestId);
+            try {
+                resumed = (await this._resolveWorkerHumanInput(workerInput)) || resumed;
+            }
+            finally {
+                this._activeHumanInputRequestIds.delete(workerInput.request.requestId);
+            }
+        }
+        return resumed;
+    }
     /**
      * Shared {@link OllamaRuntime} for a given server, lazily created and cached by baseUrl so every
      * caller — the router's readiness gate and any host UI's own model-lifecycle commands (e.g.
@@ -2606,40 +2239,7 @@ export class AgentSession {
         return this._modelRouter.getStatus(formatLabel);
     }
     async _handlePostAgentRun() {
-        const msg = this._lastAssistantMessage;
-        this._lastAssistantMessage = undefined;
-        if (!msg) {
-            return false;
-        }
-        const classified = this._classifyAssistantError(msg);
-        if (classified) {
-            this._failureCorpus.record({
-                provider: msg.provider,
-                modelId: msg.model,
-                message: msg.errorMessage ?? "",
-                classified,
-            });
-        }
-        if (classified?.retryable && (await this._prepareRetry(msg))) {
-            return true;
-        }
-        if (await this._billingFailover.handleAssistantError(msg, classified))
-            return false;
-        if (msg.stopReason === "error" && this._retryController.attempt > 0) {
-            this._emit({
-                type: "auto_retry_end",
-                success: false,
-                attempt: this._retryController.attempt,
-                finalError: msg.errorMessage,
-            });
-            this._retryController.reset();
-        }
-        if (await this._checkCompaction(msg)) {
-            return true;
-        }
-        // The agent loop drains both queues before emitting agent_end. Any messages
-        // here were queued by agent_end extension handlers and need a continuation.
-        return this.agent.hasQueuedMessages();
+        return this._foregroundRecovery.handlePostAgentRun();
     }
     /**
      * Send a prompt to the agent.
@@ -2662,11 +2262,7 @@ export class AgentSession {
         return this._promptUnserialized(text, options);
     }
     async _promptUnserialized(text, options) {
-        // Start of a new foreground prompt cycle -- rebaseline the cost guard's background-spend
-        // window so a PRIOR turn's background/spawned spend doesn't keep this turn's guard permanently
-        // tripped. Every round trip within this same turn (tool-call iterations) shares this baseline.
-        this._costGuardTurnBaselineUsd = this.getSpawnedUsage().cost;
-        this._applyToolRepairLayerSettings();
+        this._toolProtocol.applyRepairLayerSettings();
         this._cancelPrefixWarm();
         const expandPromptTemplates = options?.expandPromptTemplates ?? true;
         const processSlashCommands = options?.processSlashCommands ?? expandPromptTemplates;
@@ -2678,6 +2274,8 @@ export class AgentSession {
         // selected/authenticated — can un-register it from _earlyDisplayedUserMessages instead of
         // leaking the reference forever.
         let userMessage;
+        let routingStarted = false;
+        let pendingNextTurnCount = 0;
         // Effectiveness feedback: remember the recall page + the query so we can score, after the
         // response, whether the agent actually used the recalled context.
         let injectedRecall = "";
@@ -2738,6 +2336,9 @@ export class AgentSession {
                 preflightResult?.(true);
                 return;
             }
+            // This submission is starting a new foreground turn. Queued steer/follow-up messages above
+            // remain part of the already-active turn and must not erase its spawned-cost baseline.
+            this._costGuardTurnBaselineUsd = this.getSpawnedUsage().cost;
             // Flush any pending bash messages before the new prompt
             this._flushPendingBashMessages();
             // Build the user message now — before the router judge — and paint it to the UI
@@ -2761,6 +2362,7 @@ export class AgentSession {
             // prompt with nothing happening for however long the judge takes. routing_end is emitted
             // exactly once below: either in the catch block (this phase failed) or right after the try
             // block (this phase succeeded, whether or not it produced a turn to run).
+            routingStarted = true;
             this._emit({ type: "routing_start" });
             const resolvedRouteInfo = await this._modelRouter.resolveTurnRouteJudged(expandedText, {
                 // Internally generated turns (goal continuation, lane follow-ups) never consult the judge:
@@ -2777,6 +2379,9 @@ export class AgentSession {
             if (!requestModel) {
                 throw new Error(formatNoModelSelectedMessage());
             }
+            if (currentImages && currentImages.length > 0 && !requestModel.input.includes("image")) {
+                throw new Error(`Model "${requestModel.provider}/${requestModel.id}" does not accept image input. Select an image-capable model or route the inspection to a vision worker.`);
+            }
             // A manual/default local model has no RouteDecision, so the router readiness gate above is
             // intentionally a no-op. It still needs the same managed-runtime boot/residency guarantee.
             if (!resolvedRouteInfo) {
@@ -2826,10 +2431,10 @@ export class AgentSession {
             // immediately — see the early message_start emit above).
             messages.push(userMessage);
             // Inject any pending "nextTurn" messages as context alongside the user message
-            for (const msg of this._pendingNextTurnMessages) {
+            pendingNextTurnCount = this._pendingNextTurnMessages.length;
+            for (const msg of this._pendingNextTurnMessages.slice(0, pendingNextTurnCount)) {
                 messages.push(msg);
             }
-            this._pendingNextTurnMessages = [];
             const taskStepsState = this.getTaskStepsStateSnapshot();
             const taskStepsContext = taskStepsState ? formatTaskStepsContext(taskStepsState) : undefined;
             if (taskStepsState && taskStepsContext) {
@@ -2858,6 +2463,9 @@ export class AgentSession {
                 // Ensure we're using the base prompt (in case previous turn had modifications)
                 this.agent.state.systemPrompt = this._baseSystemPrompt;
             }
+            // Commit consumption only after all fallible preflight hooks have succeeded. Messages added
+            // while the hook was running remain queued for the following turn.
+            this._pendingNextTurnMessages.splice(0, pendingNextTurnCount);
         }
         catch (error) {
             // The turn never reached _runAgentPrompt, so the authoritative message_start that would
@@ -2868,22 +2476,31 @@ export class AgentSession {
             }
             // The routing/prep phase (routing_start above) failed before ever reaching the turn — end
             // it here, or the UI's "working" indicator for it spins forever with nothing behind it.
-            this._emit({ type: "routing_end" });
+            if (routingStarted)
+                this._emit({ type: "routing_end" });
             preflightResult?.(false);
             throw error;
         }
         // The routing/prep phase is over — either we're about to hand off into the turn (which emits
         // its own agent_start/streaming events right after), or messages is unexpectedly unset and we
         // bail below. Either way nothing is left "routing" past this point.
-        this._emit({ type: "routing_end" });
+        if (routingStarted)
+            this._emit({ type: "routing_end" });
         if (!messages) {
             return;
         }
         preflightResult?.(true);
-        this._textProtocolParseObservedThisTurn = false;
-        this._textProtocolValidationOutcomeThisTurn = undefined;
-        await this._modelRouter.runRoutedTurn(messages, routedTurnModel, routedTurnRouteDecision);
-        this._recordTextToolProtocolParseOutcomeFromLastAssistant();
+        try {
+            this._toolProtocol.resetTurnState();
+            await this._modelRouter.runRoutedTurn(messages, routedTurnModel, routedTurnRouteDecision);
+            this._toolProtocol.recordParseOutcomeFromLastAssistant();
+        }
+        finally {
+            // Normally consumed by the authoritative message_start. If execution failed before that
+            // event, do not retain the early-painted message identity indefinitely.
+            if (userMessage)
+                this._earlyDisplayedUserMessages.delete(userMessage);
+        }
         // Score whether the agent actually used the recalled context, so the recall gate can adapt.
         if (injectedRecall) {
             const response = this._findLastAssistantMessage();
@@ -3251,166 +2868,13 @@ export class AgentSession {
      * @param customInstructions Optional instructions for the compaction summary
      */
     async compact(customInstructions) {
-        this._disconnectFromAgent();
-        await this.abort();
-        this._compactionAbortController = new AbortController();
-        this._emit({ type: "compaction_start", reason: "manual" });
-        try {
-            if (!this.model) {
-                throw new Error(formatNoModelSelectedMessage());
-            }
-            const sessionModel = this.model;
-            const selectedCompactionModel = this._resolveCompactionModel(sessionModel);
-            if (this._isRawStreamSimple(this.agent.streamFn)) {
-                await this._getCompactionRequestAuth(selectedCompactionModel);
-            }
-            const selectionReason = this._getLastCompactionSelectionReason() ?? "unknown";
-            const settings = this._getAdaptedCompactionSettings();
-            const initialBranch = this.sessionManager.getBranch();
-            const initialPreparation = prepareCompaction(initialBranch, settings);
-            if (!initialPreparation) {
-                const lastEntry = initialBranch[initialBranch.length - 1];
-                if (lastEntry?.type === "compaction") {
-                    throw new Error("Already compacted");
-                }
-                throw new Error("Nothing to compact (session too small)");
-            }
-            let extensionCompaction;
-            let fromExtension = false;
-            if (this._extensionRunner.hasHandlers("session_before_compact")) {
-                const result = (await this._extensionRunner.emit({
-                    type: "session_before_compact",
-                    preparation: initialPreparation,
-                    branchEntries: initialBranch,
-                    customInstructions,
-                    signal: this._compactionAbortController.signal,
-                }));
-                if (result?.cancel)
-                    throw new Error("Compaction cancelled");
-                if (result?.compaction) {
-                    extensionCompaction = result.compaction;
-                    fromExtension = true;
-                }
-            }
-            if (extensionCompaction) {
-                this.sessionManager.appendCompaction(extensionCompaction.summary, extensionCompaction.firstKeptEntryId, extensionCompaction.tokensBefore, extensionCompaction.details, true);
-                this._refreshAfterCompaction();
-                const savedCompactionEntry = this.sessionManager
-                    .getEntries()
-                    .find((entry) => entry.type === "compaction" && entry.summary === extensionCompaction.summary);
-                if (this._extensionRunner && savedCompactionEntry) {
-                    await this._extensionRunner.emit({
-                        type: "session_compact",
-                        compactionEntry: savedCompactionEntry,
-                        fromExtension: true,
-                    });
-                }
-                this._emit({
-                    type: "compaction_end",
-                    reason: "manual",
-                    result: extensionCompaction,
-                    aborted: false,
-                    willRetry: false,
-                });
-                return extensionCompaction;
-            }
-            let appliedResult;
-            const signal = this._compactionAbortController.signal;
-            const outcome = await runCompactionLoop({
-                measureLiveTokens: () => Math.max(this._estimateCurrentContextTokens(this.agent.state.messages), 1),
-                shouldCompact: () => true,
-                getPostApplyMargin: () => 0,
-                getBranch: () => this.sessionManager.getBranch(),
-                getBaseKeepRecentTokens: () => settings.keepRecentTokens,
-                resolveModelAndAuth: async (modelTier) => {
-                    const model = modelTier === "cheap" ? selectedCompactionModel : sessionModel;
-                    // Return the resolution result AS-IS: it may have fallen back to a different model
-                    // (e.g. session model, when the tier's model failed auth or the readiness gate),
-                    // and `failure` must reach the retry loop's auth-failed escalation rather than be
-                    // dropped — dropping it would pair the wrong model with the fallback's credentials
-                    // and silently skip the loop's visible failure/escalation handling.
-                    return this._resolveCompactionModelAndAuth(model, sessionModel);
-                },
-                summarizeAndVerify: async (params, model, apiKey, headers, branch) => {
-                    const preparation = prepareCompaction(branch, {
-                        ...settings,
-                        keepRecentTokens: params.keepRecentTokens,
-                    }, { allowTrailingCompactionAsPrevious: true });
-                    if (!preparation)
-                        throw new Error("Nothing to compact (session too small)");
-                    if (extensionCompaction)
-                        return { result: extensionCompaction };
-                    const compactionThinkingLevel = this._resolveCompactionThinkingLevel(model, sessionModel);
-                    const result = await this._compactWithRetry(() => compact(preparation, model, apiKey, headers, customInstructions, signal, compactionThinkingLevel, this.agent.streamFn, this._buildCompactionPreDigest(), { chunked: params.chunked }), signal, model.provider);
-                    return { result };
-                },
-                buildDeterministicCheckpoint: () => ({ result: createDeterministicCompaction(initialPreparation) }),
-                apply: async (result) => {
-                    if (signal.aborted)
-                        throw new Error("Compaction cancelled");
-                    this.sessionManager.appendCompaction(result.summary, result.firstKeptEntryId, result.tokensBefore, result.details, fromExtension);
-                    this._refreshAfterCompaction();
-                    const savedCompactionEntry = this.sessionManager
-                        .getEntries()
-                        .find((entry) => entry.type === "compaction" && entry.summary === result.summary);
-                    if (this._extensionRunner && savedCompactionEntry) {
-                        await this._extensionRunner.emit({
-                            type: "session_compact",
-                            compactionEntry: savedCompactionEntry,
-                            fromExtension,
-                        });
-                    }
-                    appliedResult = result;
-                },
-                verifyPostApplyEffect: () => false,
-                onTransition: ({ cycle, cause, detail }) => {
-                    this._emit({
-                        type: "warning",
-                        message: `manual compaction cycle ${cycle}: ${cause}${detail ? ` (${detail})` : ""} — retrying from step 0 (${this._describeCompactionSummarizer()})`,
-                    });
-                },
-                signal,
-            });
-            if (outcome.kind === "failed") {
-                if (outcome.reason === "aborted")
-                    throw new Error("Compaction cancelled");
-                throw new Error(`manual compaction failed after retry ladder using ${selectedCompactionModel.provider}/${selectedCompactionModel.id} (${selectionReason}); first failure: ${outcome.reason}`);
-            }
-            if (outcome.kind === "skip" || !appliedResult)
-                throw new Error(outcome.kind === "skip" ? outcome.reason : "Compaction failed");
-            this._emit({
-                type: "compaction_end",
-                reason: "manual",
-                result: appliedResult,
-                aborted: false,
-                willRetry: false,
-            });
-            return appliedResult;
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            const aborted = message === "Compaction cancelled" || (error instanceof Error && error.name === "AbortError");
-            this._emit({
-                type: "compaction_end",
-                reason: "manual",
-                result: undefined,
-                aborted,
-                willRetry: false,
-                errorMessage: aborted ? undefined : `Compaction failed: ${message}`,
-            });
-            throw error;
-        }
-        finally {
-            this._compactionAbortController = undefined;
-            this._reconnectToAgent();
-        }
+        return this._compaction.compact(customInstructions);
     }
     /**
      * Cancel in-progress compaction (manual or auto).
      */
     abortCompaction() {
-        this._compactionAbortController?.abort();
-        this._autoCompactionAbortController?.abort();
+        this._compaction.abort();
     }
     /**
      * Cancel in-progress branch summarization.
@@ -3433,280 +2897,19 @@ export class AgentSession {
         return this._compactionSupport.getAdaptedSettings();
     }
     _checkContextWindowUsageWarning() {
-        if (!this.model)
-            return;
-        const contextWindow = this.model.contextWindow ?? 0;
-        if (contextWindow <= 0)
-            return;
-        const systemPromptTokens = Math.ceil((this.agent.state.systemPrompt ?? "").length / 4);
-        let toolsChars = 0;
-        for (const tool of this.agent.state.tools || []) {
-            toolsChars += tool.name.length;
-            toolsChars += tool.description?.length ?? 0;
-            if (tool.parameters) {
-                toolsChars += JSON.stringify(tool.parameters).length;
-            }
-        }
-        const toolsTokens = Math.ceil(toolsChars / 4);
-        const baseTokens = systemPromptTokens + toolsTokens;
-        if (baseTokens >= contextWindow) {
-            this._emit({
-                type: "warning",
-                message: `Base configuration (system prompt and active tools) consumes ${baseTokens} tokens, which exceeds the model's context window of ${contextWindow} tokens. The model cannot process any prompts in this state.`,
-            });
-        }
-        else if (baseTokens >= contextWindow * 0.7) {
-            this._emit({
-                type: "warning",
-                message: `Base configuration (system prompt and active tools) consumes ${baseTokens} tokens (${Math.round((baseTokens / contextWindow) * 100)}% of the ${contextWindow} context window). This leaves very little room for conversation history and may cause immediate compaction or context overflow.`,
-            });
-        }
+        this._compaction.checkContextWindowUsageWarning();
     }
-    async _checkCompaction(assistantMessage, skipAbortedCheck = true) {
-        const settings = this._getAdaptedCompactionSettings();
-        if (!settings.enabled)
-            return false;
-        // Skip if message was aborted (user cancelled) - unless skipAbortedCheck is false
-        if (skipAbortedCheck && assistantMessage.stopReason === "aborted")
-            return false;
-        const contextWindow = this.model?.contextWindow ?? 0;
-        // Skip overflow check if the message came from a different model.
-        // This handles the case where user switched from a smaller-context model (e.g. opus)
-        // to a larger-context model (e.g. codex) - the overflow error from the old model
-        // shouldn't trigger compaction for the new model.
-        const sameModel = this.model && assistantMessage.provider === this.model.provider && assistantMessage.model === this.model.id;
-        // Skip compaction checks if this assistant message is older than the latest
-        // compaction boundary. This prevents a stale pre-compaction usage/error
-        // from retriggering compaction on the first prompt after compaction.
-        const compactionEntry = getLatestCompactionEntry(this.sessionManager.getBranch());
-        const assistantIsFromBeforeCompaction = compactionEntry !== null && assistantMessage.timestamp <= new Date(compactionEntry.timestamp).getTime();
-        if (assistantIsFromBeforeCompaction) {
-            return false;
-        }
-        // Case 1: Overflow - LLM returned context overflow error
-        if (sameModel && isContextOverflow(assistantMessage, contextWindow)) {
-            if (this._overflowRecoveryAttempted) {
-                this._emit({
-                    type: "compaction_end",
-                    reason: "overflow",
-                    result: undefined,
-                    aborted: false,
-                    willRetry: false,
-                    errorMessage: "Context overflow recovery failed after one compact-and-retry attempt. Try reducing context or switching to a larger-context model.",
-                });
-                return false;
-            }
-            this._overflowRecoveryAttempted = true;
-            // Remove the error message from agent state (it IS saved to session for history,
-            // but we don't want it in context for the retry)
-            const messages = this.agent.state.messages;
-            if (messages.length > 0 && messages[messages.length - 1].role === "assistant") {
-                this.agent.state.messages = messages.slice(0, -1);
-            }
-            return await this._runAutoCompaction("overflow", true);
-        }
-        // Case 2: Threshold - context is getting large
-        // For error messages (no usage data), estimate from last successful response.
-        // This ensures sessions that hit persistent API errors (e.g. 529) can still compact.
-        let contextTokens;
-        if (assistantMessage.stopReason === "error") {
-            const messages = this.agent.state.messages;
-            const estimate = estimateContextTokens(messages);
-            if (estimate.lastUsageIndex === null)
-                return false; // No usage data at all
-            // Verify the usage source is post-compaction. Kept pre-compaction messages
-            // have stale usage reflecting the old (larger) context and would falsely
-            // trigger compaction right after one just finished.
-            const usageMsg = messages[estimate.lastUsageIndex];
-            if (compactionEntry &&
-                usageMsg.role === "assistant" &&
-                usageMsg.timestamp <= new Date(compactionEntry.timestamp).getTime()) {
-                return false;
-            }
-            contextTokens = estimate.tokens;
-        }
-        else {
-            contextTokens = calculateContextTokens(assistantMessage.usage);
-            const estimate = estimateContextTokens(this.agent.state.messages);
-            if (estimate.lastUsageIndex !== null) {
-                const usageMsg = this.agent.state.messages[estimate.lastUsageIndex];
-                const usageIsPostCompaction = !(compactionEntry &&
-                    usageMsg.role === "assistant" &&
-                    usageMsg.timestamp <= new Date(compactionEntry.timestamp).getTime());
-                if (usageIsPostCompaction) {
-                    contextTokens = Math.max(contextTokens, estimate.tokens);
-                }
-            }
-        }
-        if (shouldCompact(contextTokens, contextWindow, settings, this.model?.autoCompactionTriggerTokens)) {
-            return await this._runAutoCompaction("threshold", false);
-        }
-        return false;
+    _checkCompaction(assistantMessage, skipAbortedCheck = true) {
+        return this._compaction.check(assistantMessage, skipAbortedCheck);
     }
     _measureLiveContextTokensForCompaction() {
-        const estimatedTokens = this._pipeline.estimateCurrentContextTokens(this.agent.state.messages);
-        const assistantMessage = findLastAssistantMessage(this.agent.state.messages);
-        if (!assistantMessage || assistantMessage.stopReason === "error" || assistantMessage.stopReason === "aborted") {
-            return estimatedTokens;
-        }
-        const compactionEntry = getLatestCompactionEntry(this.sessionManager.getBranch());
-        if (compactionEntry && assistantMessage.timestamp <= new Date(compactionEntry.timestamp).getTime()) {
-            return estimatedTokens;
-        }
-        return Math.max(calculateContextTokens(assistantMessage.usage), estimatedTokens);
+        return this._compaction.measureLiveContextTokens();
     }
     /**
      * Internal: Run auto-compaction with events.
      */
-    async _runAutoCompaction(reason, willRetry) {
-        const settings = this._getAdaptedCompactionSettings();
-        const model = this.model;
-        this._emit({ type: "compaction_start", reason });
-        const hadQueuedMessages = this.agent.hasQueuedMessages();
-        this._autoCompactionAbortController = new AbortController();
-        const signal = this._autoCompactionAbortController.signal;
-        let fromExtension = false;
-        let lastCompaction;
-        let extensionCancelled = false;
-        try {
-            if (!model) {
-                this._emit({
-                    type: "compaction_end",
-                    reason,
-                    result: undefined,
-                    aborted: false,
-                    willRetry: false,
-                    skipReason: "no model selected",
-                });
-                return hadQueuedMessages || this.agent.hasQueuedMessages();
-            }
-            const contextWindow = model.contextWindow;
-            const margin = Math.max(0, Math.floor(0.01 * contextWindow));
-            const outcome = await runCompactionLoop({
-                getBranch: () => this.sessionManager.getBranch(),
-                measureLiveTokens: () => this._measureLiveContextTokensForCompaction(),
-                shouldCompact: reason === "overflow"
-                    ? () => true
-                    : (tokens) => shouldCompact(tokens, contextWindow, settings, model.autoCompactionTriggerTokens),
-                getPostApplyMargin: () => margin,
-                getBaseKeepRecentTokens: () => settings.keepRecentTokens,
-                resolveModelAndAuth: async (modelTier) => this._resolveCompactionModelAndAuth(modelTier === "session" ? model : this._resolveCompactionModel(model), model),
-                summarizeAndVerify: async (params, compactModel, apiKey, headers, branchEntries) => {
-                    fromExtension = false;
-                    const adaptedSettings = { ...settings, keepRecentTokens: params.keepRecentTokens };
-                    const preparation = prepareCompaction(branchEntries, adaptedSettings);
-                    if (!preparation) {
-                        throw new Error("already compacted");
-                    }
-                    const compactionThinkingLevel = this._resolveCompactionThinkingLevel(compactModel, model);
-                    if (this._extensionRunner.hasHandlers("session_before_compact")) {
-                        const extensionResult = (await this._extensionRunner.emit({
-                            type: "session_before_compact",
-                            preparation,
-                            branchEntries,
-                            customInstructions: undefined,
-                            signal,
-                        }));
-                        if (extensionResult?.cancel) {
-                            extensionCancelled = true;
-                            throw new Error("auto-compaction-cancelled");
-                        }
-                        if (extensionResult?.compaction) {
-                            fromExtension = true;
-                            return { result: extensionResult.compaction };
-                        }
-                    }
-                    const compactResult = await this._compactWithRetry(() => compact(preparation, compactModel, apiKey, headers, undefined, signal, compactionThinkingLevel, this.agent.streamFn, this._buildCompactionPreDigest(), { chunked: params.chunked }), signal, compactModel.provider);
-                    return { result: compactResult };
-                },
-                buildDeterministicCheckpoint: async () => {
-                    const branch = this.sessionManager.getBranch();
-                    const preparation = prepareCompaction(branch, {
-                        ...settings,
-                    });
-                    if (!preparation) {
-                        throw new Error("already compacted");
-                    }
-                    fromExtension = false;
-                    return { result: createDeterministicCompaction(preparation) };
-                },
-                apply: async (result) => {
-                    lastCompaction = result;
-                    this.sessionManager.appendCompaction(result.summary, result.firstKeptEntryId, result.tokensBefore, result.details, fromExtension);
-                    this._refreshAfterCompaction();
-                    const newEntries = this.sessionManager.getEntries();
-                    const savedCompactionEntry = newEntries.find((entry) => entry.type === "compaction" && entry.summary === result.summary);
-                    if (this._extensionRunner && savedCompactionEntry) {
-                        await this._extensionRunner.emit({
-                            type: "session_compact",
-                            compactionEntry: savedCompactionEntry,
-                            fromExtension,
-                        });
-                    }
-                },
-                verifyPostApplyEffect: reason === "overflow" ? () => false : undefined,
-                onTransition: ({ cycle, cause, detail }) => {
-                    this._emit({
-                        type: "warning",
-                        message: `auto-compaction cycle ${cycle}: ${cause}${detail ? ` (${detail})` : ""} — retrying from step 0 (${this._describeCompactionSummarizer()})`,
-                    });
-                },
-                signal,
-            });
-            if (outcome.kind === "skip") {
-                this._emit({
-                    type: "compaction_end",
-                    reason,
-                    result: undefined,
-                    aborted: false,
-                    willRetry: false,
-                    skipReason: outcome.reason,
-                });
-                return hadQueuedMessages || this.agent.hasQueuedMessages();
-            }
-            if (outcome.kind === "failed") {
-                if (outcome.reason === "aborted") {
-                    this._emit({ type: "compaction_end", reason, result: undefined, aborted: true, willRetry: false });
-                    return hadQueuedMessages || this.agent.hasQueuedMessages();
-                }
-                throw new Error(outcome.reason);
-            }
-            if (extensionCancelled || signal.aborted) {
-                this._emit({ type: "compaction_end", reason, result: undefined, aborted: true, willRetry: false });
-                return hadQueuedMessages || this.agent.hasQueuedMessages();
-            }
-            const result = outcome.kind === "success" ? outcome.result : lastCompaction;
-            if (!result) {
-                throw new Error("Auto-compaction succeeded without a result");
-            }
-            this._emit({ type: "compaction_end", reason, result, aborted: false, willRetry });
-            if (willRetry) {
-                const messages = this.agent.state.messages;
-                const lastMsg = messages[messages.length - 1];
-                if (lastMsg?.role === "assistant" && lastMsg.stopReason === "error") {
-                    this.agent.state.messages = messages.slice(0, -1);
-                }
-                return true;
-            }
-            return hadQueuedMessages || this.agent.hasQueuedMessages();
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : "compaction failed";
-            this._emit({
-                type: "compaction_end",
-                reason,
-                result: undefined,
-                aborted: false,
-                willRetry: false,
-                errorMessage: reason === "overflow"
-                    ? `Context overflow recovery failed: ${errorMessage}`
-                    : `Auto-compaction failed: ${errorMessage}`,
-            });
-            return hadQueuedMessages || this.agent.hasQueuedMessages();
-        }
-        finally {
-            this._autoCompactionAbortController = undefined;
-        }
+    _runAutoCompaction(reason, willRetry) {
+        return this._compaction.runAuto(reason, willRetry);
     }
     /**
      * Run one compaction attempt, retrying retryable provider failures (stream stalls,
@@ -3716,30 +2919,8 @@ export class AgentSession {
      * same failure via auto-retry. Caller aborts are never retried; sleepAbortable rejects
      * with the abort reason if the signal fires mid-backoff.
      */
-    async _compactWithRetry(run, signal, provider) {
-        const retrySettings = this.settingsManager.getRetrySettings();
-        const maxAttempts = retrySettings.enabled ? Math.max(1, retrySettings.maxRetries + 1) : 1;
-        const policy = {
-            maxAttempts,
-            baseDelayMs: retrySettings.baseDelayMs,
-            maxDelayMs: DEFAULT_RETRY_POLICY.maxDelayMs,
-            jitterRatio: 0,
-        };
-        for (let attempt = 1;; attempt++) {
-            try {
-                return await run();
-            }
-            catch (error) {
-                if (signal.aborted || attempt >= maxAttempts)
-                    throw error;
-                const message = error instanceof Error ? error.message : String(error);
-                const classified = classifyFailure({ message, provider });
-                this._failureCorpus.record({ provider, message, classified });
-                if (!classified.retryable)
-                    throw error;
-                await sleepAbortable(computeRetryDelayMs(policy, attempt, { retryAfterMs: classified.retryAfterMs }), signal);
-            }
-        }
+    _compactWithRetry(run, signal, provider) {
+        return this._compaction.compactWithRetry(run, signal, provider);
     }
     /**
      * Toggle auto-compaction setting.
@@ -4018,40 +3199,15 @@ export class AgentSession {
     // =========================================================================
     // Auto-Retry
     // =========================================================================
-    /**
-     * Check if an error is retryable (transient provider/network failures). Billing/quota and auth
-     * are terminal; context overflow is handled by compaction, not retry. The verdict comes from the
-     * reliability kernel's classifier, fed the host-computed context-overflow flag.
-     */
-    _classifyAssistantError(message) {
-        if (message.stopReason !== "error" || !message.errorMessage)
-            return undefined;
-        const contextWindow = this.model?.contextWindow ?? 0;
-        return classifyFailure({
-            message: message.errorMessage,
-            contextOverflow: isContextOverflow(message, contextWindow),
-            provider: message.provider,
-        });
-    }
-    _isRetryableError(message) {
-        return this._classifyAssistantError(message)?.retryable ?? false;
-    }
-    /**
-     * Prepare a retryable error for continuation with exponential backoff.
-     * @returns true if the caller should continue the agent, false otherwise
-     */
-    async _prepareRetry(message) {
-        return this._retryController.prepareRetry(message);
-    }
     /**
      * Cancel in-progress retry.
      */
     abortRetry() {
-        this._retryController.abort();
+        this._foregroundRecovery.abortRetry();
     }
     /** Whether auto-retry is currently in progress */
     get isRetrying() {
-        return this._retryController.isRetrying;
+        return this._foregroundRecovery.isRetrying;
     }
     /** Whether auto-retry is enabled */
     get autoRetryEnabled() {
@@ -4132,7 +3288,17 @@ export class AgentSession {
      * @returns the id of the appended custom entry
      */
     saveGoalStateSnapshot(state) {
-        return appendGoalStateSnapshot(this.sessionManager, state);
+        const entryId = appendGoalStateSnapshot(this.sessionManager, state);
+        try {
+            this._backgroundLanes.synchronizeGoalState(state);
+        }
+        catch (error) {
+            this._emit({
+                type: "warning",
+                message: `Goal state persisted but durable worker reconciliation failed: ${error instanceof Error ? error.message : String(error)}`,
+            });
+        }
+        return entryId;
     }
     /**
      * Retrieve the latest valid goal state snapshot from the session log.
@@ -4182,13 +3348,14 @@ export class AgentSession {
         return appendEvidenceBundleSnapshot(this.sessionManager, bundle);
     }
     /**
-     * Retrieve the latest valid evidence bundle snapshot from the session log.
+     * Retrieve the latest valid evidence bundle snapshot from the active branch.
      */
     getEvidenceBundleSnapshot() {
-        return getLatestEvidenceBundleSnapshot(this.sessionManager.getEntries());
+        return getLatestEvidenceBundleSnapshot(getActiveSessionBranchEntries(this.sessionManager));
     }
+    /** Retrieve all valid evidence bundle snapshots from the active branch. */
     getEvidenceBundleSnapshots() {
-        return getEvidenceBundleSnapshots(this.sessionManager.getEntries());
+        return getEvidenceBundleSnapshots(getActiveSessionBranchEntries(this.sessionManager));
     }
     /** Live lane records tracked by this process (running and terminal). */
     getLaneRecords() {
@@ -4207,17 +3374,17 @@ export class AgentSession {
     getGateOutcomeHistory() {
         return this._autonomyTelemetry.getGateOutcomeHistory();
     }
-    saveWorkerResultSnapshot(result, request) {
-        return appendWorkerResultSnapshot(this.sessionManager, result, request);
+    saveWorkerClaimSnapshot(claim, request) {
+        return appendWorkerClaimSnapshot(this.sessionManager, claim, request);
     }
-    getWorkerResultSnapshots() {
-        return getWorkerResultSnapshots(this.sessionManager.getEntries());
+    getWorkerClaimSnapshots() {
+        return getWorkerClaimSnapshots(getActiveSessionBranchEntries(this.sessionManager));
     }
     saveLearningDecisionSnapshot(decision) {
         return appendLearningDecisionSnapshot(this.sessionManager, decision);
     }
     getLearningDecisionSnapshots() {
-        return getLearningDecisionSnapshots(this.sessionManager.getEntries());
+        return getLearningDecisionSnapshots(getActiveSessionBranchEntries(this.sessionManager));
     }
     /**
      * The single injection point that makes the goal-continuation snapshot lane-aware:
@@ -4231,6 +3398,7 @@ export class AgentSession {
             sessionManager: this.sessionManager,
             settings,
             laneRecords: this._backgroundLanes.getLaneRecords(),
+            taskRuntime: this._backgroundLanes.getTaskRuntimeSnapshot(),
         });
     }
     /**
@@ -4254,7 +3422,7 @@ export class AgentSession {
     getLaneWorkerRefusal() {
         const profile = this.getModelCapabilityProfile();
         const model = this.model;
-        const verdict = model ? this._toolProbeVerdict(model) : undefined;
+        const verdict = model ? this._toolProtocol.getToolProbeVerdict(model) : undefined;
         return evaluateLaneWorkerRefusal({
             capabilityClass: profile.class,
             contextWindow: profile.contextWindow,
@@ -4270,7 +3438,7 @@ export class AgentSession {
         return this._backgroundLanes.runResearchLaneOnce(request);
     }
     /**
-     * Run one bounded scout-worker delegation. Delegates to {@link BackgroundLaneController};
+     * Run one bounded profile-bound worker delegation. Delegates to {@link BackgroundLaneController};
      * consumed by the `delegate` tool.
      */
     async runWorkerDelegationOnce(request) {
@@ -4370,13 +3538,4 @@ export class AgentSession {
         return this._extensionRunner;
     }
 }
-function findLastAssistantMessage(messages) {
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const message = messages[i];
-        if (message.role === "assistant") {
-            return message;
-        }
-    }
-    return undefined;
-}
 //# sourceMappingURL=agent-session.js.map