@caupulican/pi-adaptative 0.80.103 → 0.81.1

package/dist/core/agent-session.d.ts

@@ -1,43 +1,49 @@
-import type { Agent, AgentEvent, AgentMessage, AgentState, AgentTool, ThinkingLevel } from "@caupulican/pi-agent-core";
+import type { Agent, AgentEvent, AgentMessage, AgentState, AgentTool, StreamIdleOptions, ThinkingLevel } from "@caupulican/pi-agent-core";
+import { type CustomMessage } from "@caupulican/pi-agent-core";
+import { type BranchSummaryEntry, type CompactionResult, type SessionManager } from "@caupulican/pi-agent-core/node";
 import type { CacheRetention, ImageContent, Message, Model, StopReason, TextContent, Usage } from "@caupulican/pi-ai";
 import type { CapabilityEnvelope, EvidenceBundle, LearningDecision, WorkerRequest, WorkerResult } from "./autonomy/contracts.ts";
-import { type LaneRecord } from "./autonomy/lane-tracker.ts";
+import type { LaneRecord } from "./autonomy/lane-tracker.ts";
 import type { AutonomyDiagnosticSnapshot, AutonomyStatusSnapshot, GateOutcomeHistoryEntry } from "./autonomy/status.ts";
-import { type BashResult } from "./bash-executor.ts";
-import { type CompactionResult } from "./compaction/index.ts";
-import { type CurationTelemetrySnapshot } from "./context/brain-curator.ts";
-import { type ContextAuditReport } from "./context/context-audit.ts";
+import type { BashResult } from "./bash-executor.ts";
+import type { CurationTelemetrySnapshot } from "./context/brain-curator.ts";
+import type { ContextAuditReport } from "./context/context-audit.ts";
 import { type ContextCompositionReport } from "./context/context-composition.ts";
-import { type PromptEnforcementReport } from "./context/context-prompt-enforcement.ts";
-import { type PromptPolicyGcCorrelationReport, type PromptPolicyShadowReport } from "./context/context-prompt-policy.ts";
-import { type MemoryPromptInclusionReport } from "./context/memory-diagnostics.ts";
-import { type MemoryRetrievalReport } from "./context/memory-retrieval.ts";
-import { type ContextGcReport } from "./context-gc.ts";
-import { type DailyUsageTotals } from "./cost/daily-usage.ts";
+import type { PromptEnforcementReport } from "./context/context-prompt-enforcement.ts";
+import type { PromptPolicyGcCorrelationReport, PromptPolicyShadowReport } from "./context/context-prompt-policy.ts";
+import type { MemoryPromptInclusionReport } from "./context/memory-diagnostics.ts";
+import type { MemoryRetrievalReport } from "./context/memory-retrieval.ts";
+import type { ContextGcReport } from "./context-gc.ts";
+import type { DailyUsageTotals } from "./cost/daily-usage.ts";
 import { type CostGuardDecision } from "./cost-guard.ts";
-import { type WorkerRunOutcome } from "./delegation/worker-runner.ts";
-import { type ContextUsage, type ExtensionCommandContextActions, type ExtensionContext, type ExtensionErrorListener, ExtensionRunner, type ExtensionUIContext, type InputSource, type ReplacedSessionContext, type SessionStartEvent, type ShutdownHandler, type ToolDefinition, type ToolInfo } from "./extensions/index.ts";
+import type { WorkerRunOutcome } from "./delegation/worker-runner.ts";
+import type { ContextUsage, ExtensionCommandContextActions, ExtensionContext, ExtensionErrorListener, ExtensionRunner, ExtensionUIContext, InputSource, ReplacedSessionContext, SessionStartEvent, ShutdownHandler, ToolDefinition, ToolInfo } from "./extensions/index.ts";
 import { type ChannelProvider, GatewayRegistry, type JobSchedulerProvider } from "./gateways/channel-provider.ts";
-import { type GoalContinuationPrompt, type GoalContinuationPromptLimits } from "./goals/goal-continuation-prompt.ts";
+import type { GoalContinuationPrompt, GoalContinuationPromptLimits } from "./goals/goal-continuation-prompt.ts";
 import { type GoalRuntimeSnapshot, type GoalRuntimeSnapshotSettings } from "./goals/goal-runtime-snapshot.ts";
 import type { GoalState } from "./goals/goal-state.ts";
-import { type LearningAuditRecord } from "./learning/learning-audit.ts";
-import { type DemandSignals, type ReflectionResult } from "./learning/reflection-engine.ts";
+import type { LearningAuditRecord } from "./learning/learning-audit.ts";
+import type { DemandSignals, ReflectionResult } from "./learning/reflection-engine.ts";
 import { type CurationProposals } from "./learning/skill-curator.ts";
 import type { MemoryProvider } from "./memory/memory-provider.ts";
-import { type CustomMessage } from "./messages.ts";
 import { type ModelCapabilityProfile } from "./model-capability.ts";
 import type { ModelRegistry } from "./model-registry.ts";
-import { type StoredFitnessReport } from "./models/fitness-store.ts";
-import { type LocalRuntimeDeps, OllamaRuntime } from "./models/local-runtime.ts";
+import type { StoredFitnessReport } from "./models/fitness-store.ts";
+import type { LocalRuntimeDeps, OllamaRuntime } from "./models/local-runtime.ts";
 import { type PromptTemplate } from "./prompt-templates.ts";
-import { type ModelFitnessReport } from "./research/model-fitness.ts";
-import { type ResearchRunResult } from "./research/research-runner.ts";
+import type { ModelFitnessReport } from "./research/model-fitness.ts";
+import type { ResearchRunResult } from "./research/research-runner.ts";
 import { collectWorkspaceSources } from "./research/workspace-collector.ts";
 import type { ResourceLoader } from "./resource-loader.ts";
-import type { BranchSummaryEntry, SessionManager } from "./session-manager.ts";
-import { type ResourceProfileFilterSettings, type SettingsManager } from "./settings-manager.ts";
-import { type BashOperations } from "./tools/bash.ts";
+import type { ResourceProfileFilterSettings, SettingsManager } from "./settings-manager.ts";
+import type { BashOperations } from "./tools/bash.ts";
+/**
+ * Test hook: override the stream-idle bounds so a stall can be provoked in-suite without a
+ * multi-minute wait. Pass `undefined` to restore the user-locked defaults (connect 120s /
+ * active 180s / quiet 600s, or the user's retry.stall settings). Applies per request — it
+ * may be set or changed at any time before the request that should observe it.
+ */
+export declare function setStreamIdleOptionsForTests(opts: Partial<StreamIdleOptions> | undefined): void;
 /** Parsed skill block from a user message */
 export interface ParsedSkillBlock {
     name: string;
@@ -81,6 +87,12 @@ export type AgentSessionEvent = Exclude<AgentEvent, {
     aborted: boolean;
     willRetry: boolean;
     errorMessage?: string;
+    /**
+     * Benign no-op explanation for auto-compaction (e.g. "nothing to compact yet"). Auto
+     * bails must never be silent: without a result, either errorMessage (real failure) or
+     * skipReason (harmless skip) is set so the UI can show why nothing changed.
+     */
+    skipReason?: string;
 } | {
     type: "auto_retry_start";
     attempt: number;
@@ -155,8 +167,8 @@ export interface AgentSessionConfig {
     collectWorkspaceSources?: typeof collectWorkspaceSources;
     /**
      * Injected fetch/spawn/exists for the local (Ollama) runtime health-check + boot used by the
-     * model router before a turn routed to a local model (see _ensureLocalModelReady). Unit tests
-     * inject fakes so they never hit a real network/process; production defaults to the real ones.
+     * model router before a turn routed to a local model (see LocalRuntimeController.ensureLocalModelReady).
+     * Unit tests inject fakes so they never hit a real network/process; production defaults to the real ones.
      */
     localRuntimeDeps?: LocalRuntimeDeps;
 }
@@ -326,22 +338,6 @@ export declare class AgentSession {
     private _pendingNextTurnMessages;
     /** Serializes prompt() submissions made while streaming so queued steering/follow-ups keep user-typed FIFO order. */
     private _streamingPromptSubmissionTail;
-    /** Pending idle timer that starts bounded goal continuation after the session becomes idle. */
-    private _goalAutoContinueTimer;
-    /** Guards bounded idle autosteer so continuation prompts do not recursively trigger themselves. */
-    private _isGoalAutoContinuing;
-    /** Pending idle timer that starts an autonomous research pass after the session becomes idle. */
-    private _researchLaneTimer;
-    /** Single-flight guard: at most one research pass runs at a time per session. */
-    private _isResearchLaneRunning;
-    /** Why the last idle research-lane evaluation skipped, for /autonomy diagnostics. */
-    private _lastResearchLaneSkipReason;
-    /** Live lane registry — the real source for AutonomyStatusSnapshot.activeLaneCount. */
-    private readonly _laneTracker;
-    /** Session-lifetime abort for in-flight research passes (same pattern as _reflectionAbort). */
-    private readonly _researchLaneAbort;
-    /** Session-lifetime abort for in-flight delegated workers. */
-    private readonly _workerDelegationAbort;
     /**
      * 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.
@@ -350,45 +346,50 @@ export declare class AgentSession {
     private _compactionAbortController;
     private _autoCompactionAbortController;
     private _overflowRecoveryAttempted;
-    private _latestContextGcReport;
-    /** Brain-curation sidecar (design: brain-context-curation-design.md). Inert unless the
-     * contextPolicy.curation setting is enabled AND the model passes the digest fitness gate. */
-    private readonly _brainCurator;
-    private _lastCurationSkipReason;
-    private _inertExtensionWarnings;
-    /** Extensions the active resource profile removed from the runtime set (surfaced in /context). */
-    private _profileDeniedExtensionCount;
-    private _lastPreDigestSkipReason;
     private _unboundToolGrantWarnings;
-    private _toolArtifactStore;
-    private _latestContextAuditReport;
-    private _latestPromptPolicyReport;
-    private _latestPromptPolicyGcCorrelation;
-    private _latestPromptEnforcementReport;
-    private _memoryOkfProvider;
-    private _latestMemoryRetrievalReport;
-    private _latestMemoryPromptInclusionReport;
     private _branchSummaryAbortController;
-    private _retryAbortController;
-    private _retryAttempt;
-    private _bashAbortController;
-    private _pendingBashMessages;
+    private _retryController;
+    /** User-facing model + thinking-level selection (see model-selection-controller.ts). */
+    private readonly _modelSelection;
+    /** Standalone bash-command execution (see bash-execution-controller.ts); owns the bash abort
+     * controller and the streaming-deferred pending-message queue. */
+    private readonly _bash;
+    /** Resource-profile tool/extension gating + reload-time profile model re-apply (see profile-filter-controller.ts). */
+    private readonly _profileFilter;
+    /** Agent tool-call gate: escalation, autonomy gating, extension hooks, untrusted boundary (see tool-gate-controller.ts). */
+    private readonly _toolGate;
     private _extensionRunner;
     private _turnIndex;
     /** G7: per-turn foreground CapabilityEnvelope auto-built for visibility (observe-only; not enforced). */
     private _currentForegroundEnvelope?;
     private _resourceLoader;
     private _customTools;
-    private _baseToolDefinitions;
     private _cwd;
     private _agentDir;
     private _collectWorkspaceSources;
-    private _localRuntimeDeps?;
-    /** Lazy, cached by baseUrl so the router path and any other caller share one instance per server. */
-    private _localRuntimes;
-    /** Server URLs confirmed reachable THIS session — skips the health-check round trip on every
-     * local-routed turn once warm. Keyed the same way as _localRuntimes. */
-    private _localRuntimeConfirmedUp;
+    /** Owns the cached per-server OllamaRuntime instances and the local-model router readiness gate
+     * (see local-runtime-controller.ts). */
+    private readonly _localRuntimeController;
+    /** Assembles the session's base system prompt from live session state (see
+     * system-prompt-builder.ts); owns the paired _baseSystemPromptOptions. */
+    private readonly _systemPromptBuilder;
+    /** G3/G8 autonomy telemetry sink + status/diagnostic snapshots (see autonomy-telemetry.ts); owns
+     * the latest gate outcome and the bounded gate-outcome history. */
+    private readonly _autonomyTelemetry;
+    /** Goal auto-continue + research lane + scout-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. */
+    private readonly _backgroundLanes;
+    /** Plug-and-play memory subsystem (see memory-controller.ts); owns the OKF retrieval provider, the
+     * latest retrieval/prompt-inclusion reports, the reload-safe MemoryManager, the recall
+     * effectiveness tracker, and the extension-contributed pending providers. */
+    private readonly _memory;
+    /** Summarizer model/auth/settings resolution (see compaction-support.ts). */
+    private readonly _compactionSupport;
+    /** 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. */
+    private readonly _pipeline;
     private _extensionRunnerRef?;
     private _initialActiveToolNames?;
     private _allowedToolNames?;
@@ -396,40 +397,36 @@ export declare class AgentSession {
     private _toolProfileFilter?;
     private readonly _isExplicitModel;
     private readonly _isExplicitThinking;
-    /** Plug-and-play memory subsystem. Recreated on each (re)initialize so reload is safe. */
-    private _memoryManager;
-    /** R4: tracks whether injected recall is actually used, to adapt the recall gate. */
-    private readonly _effectivenessTracker;
     /** R8: registry for deployment-supplied gateway channels + schedulers (lifecycle driven by the host runner). */
     private readonly _gatewayRegistry;
     /** Cache for getSpawnedUsage(), keyed by session entry count (Bug #22 — avoid O(N) per render frame). */
-    private _spawnedUsageCache?;
-    private _dailyUsageCache?;
+    /** Usage/cost/stats accounting, /context estimate, and session export (see session-analytics.ts);
+     * owns the spawned-usage and daily-usage memo caches. */
+    private readonly _analytics;
+    /** In-file session-tree branch switching + fork-selector reads (see session-tree-navigator.ts). */
+    private readonly _treeNavigator;
     /** Latest proactive cost-guard decision (#34), for the host UI to surface. Undefined when disabled. */
     private _lastCostGuardDecision?;
     /** One-shot latch so the cost guard downgrades reasoning once per over-threshold episode, not every call. */
     private _costGuardDowngraded;
-    /** Active model-router intent for the current transient routed turn, if any. */
-    private _activeModelRouterIntent?;
-    private _activeModelRouterRoute?;
-    private _modelRouterSessionBuffer?;
-    private _modelRouterEscalationRequested;
-    private _isModelRouterRetry;
-    private _lastModelRouterDecision?;
-    private _lastAutonomyGateOutcome?;
-    /** G8: bounded (cap {@link GATE_OUTCOME_HISTORY_LIMIT}) history of gate outcomes; tail is latest. */
-    private readonly _gateOutcomeHistory;
-    private _lastModelRouterSkipReason?;
-    private _lastModelRouterIntent?;
+    /** Per-turn model-router subsystem (see model-router-controller.ts); owns the transient route/intent,
+     * the cheap-turn session buffer, the escalation/retry flags, and the sticky last-decision/skip-reason
+     * used by the status report. Its parallel routed drive path delegates every turn back to
+     * {@link _runAgentPrompt} so the drive loop stays host-side. */
+    private readonly _modelRouter;
     /** Lazily-built skill curator (#32) over `<agentDir>/skills`. */
     private _skillCuratorInstance?;
     /** Set on dispose so in-flight background reflection bails instead of writing to a dead session (Bug #21). */
     private _disposed;
     /** Aborts in-flight background reflection completions on dispose (Bug #21). */
     private readonly _reflectionAbort;
+    /** 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. */
+    private readonly _reflection;
+    /** Bounded goal auto-continuation loop (see goal-loop-controller.ts); reads goal state fresh
+     * each pass and re-enters the session's own prompt path. */
+    private readonly _goalContinuation;
     private readonly _isChildSession;
-    /** Memory providers registered by extensions via pi.registerMemoryProvider, applied on (re)init. */
-    private _pendingMemoryProviders;
     private _baseToolsOverride?;
     private _sessionStartEvent;
     private _extensionUIContext?;
@@ -440,26 +437,23 @@ export declare class AgentSession {
     private _extensionErrorListener?;
     private _extensionErrorUnsubscriber?;
     private _modelRegistry;
-    private _toolRegistry;
-    private _toolDefinitions;
-    private _toolPromptSnippets;
-    private _toolPromptGuidelines;
+    /** Tool-registry assembly + the self-modification-safe extension reload (see runtime-builder.ts);
+     * owns the base/wrapped tool definitions, the live tool registry, and the per-tool prompt
+     * snippet/guideline maps. The reload snapshot spans host/agent state reached through its deps. */
+    private readonly _runtimeBuilder;
     private _baseSystemPrompt;
-    private _baseSystemPromptOptions;
     constructor(config: AgentSessionConfig);
     /** Model registry for API key resolution and model discovery */
     get modelRegistry(): ModelRegistry;
-    private _getRequiredRequestAuth;
-    private _getCompactionRequestAuth;
     /**
-     * Resolve the model used to SUMMARIZE during compaction (cost guard, #30). A compaction summary is an
-     * extraction task — it does not need the main (expensive) model. Selection:
-     *   - an explicit `compaction.model` setting wins, but only if its provider is authed (else fall back);
-     *   - `"auto"` (default) picks the CHEAPEST authed model whose context window can hold a compaction
-     *     (capability floor), and ONLY if it is strictly cheaper than the session model — so we never
-     *     downgrade to an equally-priced but weaker summarizer (agy's floor: don't degrade the checkpoint);
-     *   - otherwise the session model is used (safe default).
+     * True when the session's stream fn is the raw `streamSimple` provider entry (directly, or as the
+     * base wrapped by the idle watchdog at construction). Callers use this to decide whether request
+     * auth must be injected explicitly — see {@link RAW_STREAM_MARKER}.
      */
+    private _isRawStreamSimple;
+    private _getRequiredRequestAuth;
+    private _getCompactionRequestAuth;
+    private _resolveCompactionModelAndAuth;
     private _resolveCompactionModel;
     /**
      * Install tool hooks once on the Agent instance.
@@ -501,121 +495,48 @@ export declare class AgentSession {
     restorePromotedSkill(name: string): boolean;
     private _installAgentTurnRefresh;
     private _createAgentContextSnapshot;
-    private _contextGcStorageDir;
-    private _toolArtifactsDir;
-    /**
-     * Session-scoped, filesystem-backed artifact store for first-capture-then-bound tool
-     * output (grep/find only, for now -- see tool-output-artifacts.md). Lazily created and
-     * cached so every tool construction in this session shares one store instance.
-     *
-     * `packToolOutput()` registers a reference (the packing tool call's id) at pack time
-     * and fails closed, so packed artifacts are never prematurely collected.
-     * `_releaseGcPackedArtifactReferences()` (called from `_applyContextGc()`) releases
-     * that reference once context-gc packs the result out of live context, and
-     * opportunistically reclaims now-unreferenced artifacts via `cleanup()`.
-     * Remaining carry-forward gap: cleanup() now also runs at dispose(), but only reclaims
-     * already-released (zero-reference) artifacts. A session that ends before context-gc
-     * ever evicts a result never releases that reference, so its artifact stays on disk by
-     * design (resolvable on resume). Reclaiming those requires an explicit cross-session
-     * expiry/liveness policy, not just a sweep.
-     */
+    /** Tool-build call-site delegation to {@link ContextPipeline.getToolArtifactStore}. */
     private _getToolArtifactStore;
     /**
-     * Fixed path for this slice's local Pi OKF memory documents, shared across sessions
-     * under this agentDir (not session-scoped, unlike tool-artifacts/context-gc, since OKF
-     * memory represents durable cross-session knowledge, not a per-session capture). Not
-     * yet user-configurable -- see the memory-retrieval settings doc comment.
-     */
-    private _memoryOkfDir;
-    /**
-     * Session-scoped, read-only local OKF memory provider. Lazily created ONLY when memory
-     * retrieval is enabled (see `_runMemoryRetrieval`) -- never force-created, so a session
-     * with the setting off never touches `_memoryOkfDir()` at all (no directory access, no
-     * creation; `createOkfMemoryProvider` itself never writes/mkdirs either way).
-     */
-    private _getMemoryOkfProvider;
-    /**
-     * One pass over the current branch, mapping each toolResult's toolCallId to its
-     * persisted session-entry id. Rebuilt every audit pass (O(branch) per turn), so this is
-     * O(n^2) over a long session. Fine at current scale; after the artifact-read fix this is
-     * the next per-turn audit cost to optimize if it ever matters (e.g. cache/incrementally
-     * update instead of a full rebuild).
-     */
-    private _buildSessionEntryIdLookup;
-    /**
-     * Phase 1 observe-only audit pass (see context/context-audit.ts): converts live
-     * toolResult messages into ContextItems and runs the existing retention/hard-constraint
-     * evaluators over them, storing the latest deterministic report for tests/debugging.
-     * Read-only with respect to messages, the transcript, and artifact references -- uses
-     * `_toolArtifactStore` (the field), not `_getToolArtifactStore()` (the getter), so a
-     * session that never packed anything doesn't force-create a store/dir just to audit.
-     * Never throws into a live turn: any failure degrades to an empty report.
+     * 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.
      */
     private _runContextAudit;
-    /**
-     * Read-only inspection of the context audit. With `messages`, recomputes fresh against
-     * the given array (still no mutation of messages/transcript/artifact refs); without,
-     * returns the last report computed during a real transform pass.
-     */
+    /** Read-only inspection of the context audit (delegates to {@link ContextPipeline.getContextAuditReport}). */
     getContextAuditReport(messages?: AgentMessage[]): ContextAuditReport;
     /**
-     * Observe-first shadow/planning pass (see context/context-prompt-policy.ts): re-shapes
-     * the audit report into a per-item policy plan whose `appliedAction` is always
-     * "keep_raw" -- this never enforces anything, it only records what the policy engine
-     * would say. Never throws into a live turn: any failure degrades to an empty report.
+     * Context-transform hot-path delegation to {@link ContextPipeline.runPromptPolicyPlanning}. Kept as
+     * a one-line method (not inlined) so the transform stays the single owner of the pass ordering.
      */
     private _runPromptPolicyPlanning;
-    /**
-     * Read-only inspection of the shadow policy plan. With `messages`, recomputes fresh
-     * (audit + plan) against the given array; without, returns the last plan computed
-     * during a real transform pass. Never mutates messages/transcript/artifact refs.
-     */
+    /** Read-only inspection of the shadow policy plan (delegates to {@link ContextPipeline.getPromptPolicyReport}). */
     getPromptPolicyReport(messages?: AgentMessage[]): PromptPolicyShadowReport;
     /**
-     * Report-only correlation between the shadow plan just computed this turn and what the
-     * legacy context-gc pass actually packed. Runs after `_applyContextGc()` has already
-     * produced its report; never influences context-gc itself. Never throws into a live
-     * turn: any failure degrades to an empty correlation.
+     * Context-transform hot-path delegation to {@link ContextPipeline.correlatePromptPolicyWithContextGc}.
+     * Kept as a one-line method (not inlined) so the transform stays the single owner of the pass ordering.
      */
     private _correlatePromptPolicyWithContextGc;
     /** Read-only inspection of the latest shadow-plan/legacy-gc correlation, for tests/debugging. */
     getPromptPolicyGcCorrelation(): PromptPolicyGcCorrelationReport;
     /**
-     * First enforcement pilot (see context/context-prompt-enforcement.ts): opt-in,
-     * default-disabled stub-in-place of stale artifact-backed tool_output results in the
-     * provider-visible message array only. Runs on `messages` AFTER context-gc has already
-     * produced its own result, so legacy context-gc's own packing/reporting is completely
-     * unaffected by this pass -- it only ever acts on messages gc left untouched this turn.
-     * Never throws into a live turn: any failure degrades to returning `messages` unchanged.
+     * Context-transform hot-path delegation to {@link ContextPipeline.runPromptEnforcement}. Kept as a
+     * one-line method (not inlined) so the transform stays the single owner of the pass ordering.
      */
     private _runPromptEnforcement;
     /**
-     * Enqueue relevance-scoring jobs for stale, artifact-backed tool outputs the enforcement
-     * pilot could act on. Pure queueing — the verdicts only ever take effect through the
-     * asymmetric advisory lever inside enforcePromptPolicy. Never throws into a turn.
+     * Context-transform hot-path delegation to {@link ContextPipeline.enqueueRelevanceCuration}. Kept as
+     * a one-line method (not inlined) so the transform stays the single owner of the pass ordering.
      */
     private _enqueueRelevanceCuration;
-    /**
-     * Drain gate: settings on, model configured+authed, and the model has PASSED the digest
-     * fitness probe on THIS host (design: unfit or unprobed models are refused with a visible
-     * reason, never silently degraded). Fire-and-forget; never throws into a turn.
-     */
-    /**
-     * Resolve the curation model IFF every gate passes: setting enabled, model configured,
-     * resolvable+authed, and digest-fitness-proven on THIS host (canonical "provider/id" ref —
-     * runModelFitness stores reports under it, while settings.model may be a bare id or pattern).
-     * Sets _lastCurationSkipReason on refusal; never throws.
-     */
+    /** Reflex/curation call-site delegation to {@link ContextPipeline.resolveCurationModelIfFit}. */
     private _resolveCurationModelIfFit;
-    private _maybeDrainBrainCuration;
     /**
-     * Compaction pre-digest gate (design surface 3): everything the drain gate requires PLUS a
-     * RUNTIME reliability proof — the curator must have run >=5 jobs on this session with a parse
-     * failure rate <=5% before it is trusted to pre-digest compaction input. Returns undefined
-     * (verbatim compaction, byte-for-byte today's behavior) whenever any gate refuses.
+     * Context-transform hot-path delegation to {@link ContextPipeline.maybeDrainBrainCuration}. Kept as a
+     * one-line method (not inlined) so the transform stays the single owner of the pass ordering.
      */
+    private _maybeDrainBrainCuration;
+    /** Compaction call-site delegation to {@link ContextPipeline.buildCompactionPreDigest}. */
     private _buildCompactionPreDigest;
-    private _drainBrainCuration;
     /**
      * Context composition dashboard data: decomposes the per-request payload (system prompt, tool
      * schemas, extension contributions, message classes incl. GC/policy stubs and recall pages)
@@ -626,6 +547,7 @@ export declare class AgentSession {
     /** Bounded plain-text rendering of {@link getContextCompositionReport} for the /context command. */
     formatContextCompositionDashboard(): string;
     /** Curation status for diagnostics/dashboard: settings, live telemetry, last refusal reason. */
+    /** Curation status for diagnostics/dashboard (delegates to {@link ContextPipeline.getContextCurationStatus}). */
     getContextCurationStatus(): {
         enabled: boolean;
         model?: string;
@@ -635,57 +557,33 @@ export declare class AgentSession {
     };
     /** Read-only inspection of the latest prompt-enforcement report, for tests/debugging. */
     getPromptEnforcementReport(): PromptEnforcementReport;
+    /**
+     * Context-transform hot-path delegation to {@link MemoryController.runMemoryRetrieval}. Kept as a
+     * one-line method (not inlined) so the transform stays the single owner of the pass ordering.
+     */
     private _runMemoryRetrieval;
     /** Read-only inspection of the latest memory-retrieval report, for tests/debugging. */
     getMemoryRetrievalReport(): MemoryRetrievalReport;
     /**
-     * Bounded prompt-surfacing pilot for local memory evidence (see
-     * context/memory-prompt-block.ts): opt-in, default disabled, and gated on TWO settings
-     * (`enabled` AND `includeInPrompt`) plus a non-empty `report.contextItems` -- the first
-     * two are belt-and-suspenders on top of the fact that `_runMemoryRetrieval` already
-     * leaves `contextItems` empty whenever `enabled` is false, regardless of
-     * `includeInPrompt`. Reuses the `report` this pass's `_runMemoryRetrieval` call already
-     * computed -- never re-queries the provider here.
-     *
-     * Appends exactly one ephemeral `custom`/"memory_evidence" message wrapped by
-     * `wrapUntrustedText` (the same nonce-fenced boundary + always-on system-prompt rule
-     * used for other untrusted content) to the END of `messages`. This is purely additive
-     * (never mutates an existing message) and purely transient: `messages` here is the
-     * array about to be sent to the provider, not `this.agent.state.messages` or anything
-     * persisted via `sessionManager` -- so the injected message can never reach the
-     * transcript, regardless of how many times this pass runs.
-     *
-     * Also records a `MemoryPromptInclusionReport` (context/memory-diagnostics.ts) at each
-     * branch below, for context_audit's diagnostic surface only -- this is pure bookkeeping
-     * alongside the existing branches, not a new branch/condition: the messages returned
-     * are unchanged by this recording.
+     * Context-transform hot-path delegation to {@link MemoryController.maybeAppendMemoryEvidenceBlock}.
+     * Kept as a one-line method (not inlined) so the transform stays the single owner of the pass ordering.
      */
     private _maybeAppendMemoryEvidenceBlock;
     /** Read-only inspection of the latest memory-prompt-inclusion decision, for tests/debugging and context_audit. */
     getMemoryPromptInclusionReport(): MemoryPromptInclusionReport;
     /**
-     * Combines the already-stored, no-arg latest reports (never re-queries the provider or
-     * touches the OKF directory) into the safe, allow-list-projected shape context_audit
-     * exposes. See context/memory-diagnostics.ts for why this projection is allow-list
-     * based rather than a spread-then-delete of the raw report.
+     * Context-transform hot-path delegation to {@link ContextPipeline.applyContextGc}. Kept as a
+     * one-line method (not inlined) so the transform stays the single owner of the pass ordering;
+     * also serves the composition dashboard and {@link getContextGcReport} read-only paths.
      */
-    private _getMemoryAuditDiagnostics;
     private _applyContextGc;
+    /** Read-only inspection of the latest context-gc report (delegates to {@link ContextPipeline.getContextGcReport}). */
+    getContextGcReport(messages?: AgentMessage[]): ContextGcReport;
     /**
-     * Reference-release + cleanup lifecycle: once context-gc has packed a grep/find tool
-     * result out of the live prompt (the message is no longer current/active working
-     * context -- see contracts-and-retention.md's "ephemeral"/"expired" retention
-     * classes), release the pack-time reference `packToolOutput()` registered for it, and
-     * opportunistically reclaim now-unreferenced artifacts. This is the other half of the
-     * D2b-1 gate: artifacts were being registered but never released, so they accumulated
-     * for the life of the session.
-     *
-     * `record.toolCallId` (from context-gc's packed record) is exactly the holder id
-     * `packToolOutput()` used when it called `addReference()` -- both trace back to the
-     * same tool call's id -- so no separate bookkeeping is needed to find it.
+     * 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.
      */
-    private _releaseGcPackedArtifactReferences;
-    getContextGcReport(messages?: AgentMessage[]): ContextGcReport;
     private _estimateCurrentContextTokens;
     private _installAgentToolHooks;
     /** Emit an event to all listeners */
@@ -819,55 +717,27 @@ export declare class AgentSession {
     get promptTemplates(): ReadonlyArray<PromptTemplate>;
     private _normalizePromptSnippet;
     private _normalizePromptGuidelines;
-    /**
-     * R6: the active profile's situational soul, wrapped so the model reads it as its identity for this
-     * situation. Empty when no active profile defines a soul.
-     */
-    private _buildSituationSoulPrompt;
-    private _buildSelfModificationPrompt;
-    private _buildAutonomyPrompt;
-    private _buildSystemPromptOptionsForToolNames;
     private _rebuildSystemPrompt;
     /**
      * Build a system prompt for a specific tool surface WITHOUT touching the session's base prompt
-     * state. Used for a router-swapped turn (G4): the routed model runs against a filtered tool set,
-     * so it must also receive a system prompt whose tool guidelines/snippets match that filtered
-     * surface — but the change is per-turn, so it must not mutate `_baseSystemPromptOptions` (which
-     * later turns and extension events read).
+     * state (G4 router-swap; see {@link SystemPromptBuilder.buildSystemPromptForToolNames}).
      */
     private _buildSystemPromptForToolNames;
     private _runAgentPrompt;
-    private _isModelAvailableAndAuthed;
-    private _resolveExecutorRoute;
-    /** True if a run_toolkit_script tool result since `fromIndex` actually EXECUTED (not error/ambiguous). */
-    private _executorTurnExecutedScript;
-    private _buildExecutorRefinedPrompt;
     /**
      * Shared {@link OllamaRuntime} for a given server, lazily created and cached by baseUrl so every
-     * caller — the router's readiness gate below and any host UI's own model-lifecycle commands
-     * (e.g. `/models`) — sees and can stop the SAME pi-managed process instead of each tracking its
-     * own untracked child.
+     * caller — the router's readiness gate and any host UI's own model-lifecycle commands (e.g.
+     * `/models`) — sees and can stop the SAME pi-managed process instead of each tracking its own
+     * untracked child. Delegates to {@link LocalRuntimeController}.
      */
     getLocalRuntime(baseUrl?: string): OllamaRuntime;
     /** models.json registers a local model's baseUrl as `<server>/v1` (OpenAI-compat); the runtime's
-     * own health/boot endpoints are on the Ollama-native server root. */
+     * own health/boot endpoints are on the Ollama-native server root. Delegates to
+     * {@link LocalRuntimeController}; kept here for `_warnIfManualModelChoiceIsRisky`'s own use. */
     private _deriveOllamaServerUrl;
-    /**
-     * If the last assistant message in this session was an error from THIS exact local server, a
-     * cached "confirmed up" flag would be stale (the server may have died mid-session) — drop it so
-     * the next ensure-check is a real one instead of trusting stale state.
-     */
-    private _invalidateLocalRuntimeIfLastCallFailed;
-    private _ensureLocalModelReady;
-    private _maybeInstallOllamaOnConsent;
     private _ensureRouteModelReady;
-    private _resolveModelRouterTurnRoute;
-    private _resolveModelRouterModelForIntent;
-    private _resolveConfiguredTierModel;
-    private _resolveModelRouterTurnRouteJudged;
-    private _resolveModelRouterTurnModel;
+    /** Model-router status + config diagnostics report. Delegates to {@link ModelRouterController}. */
     getModelRouterStatus(formatLabel?: (label: string) => string): string;
-    private _runAgentPromptWithModelRouter;
     private _handlePostAgentRun;
     /**
      * Send a prompt to the agent.
@@ -879,12 +749,6 @@ export declare class AgentSession {
      * @throws Error if no model selected or no API key available (when not streaming)
      */
     prompt(text: string, options?: PromptOptions): Promise<void>;
-    /**
-     * Zero-I/O gate for cross-session recall (R3): skip trivial turns (short acks, slash commands) so
-     * recall only runs when it could plausibly help. The provider's similarity cutoff is the real
-     * filter — this just avoids the index query on turns that obviously don't warrant it.
-     */
-    private _shouldAttemptRecall;
     private _promptUnserialized;
     /**
      * Try to execute an extension command. Returns true if command was found and executed.
@@ -975,48 +839,16 @@ export declare class AgentSession {
      * Abort current operation and wait for agent to become idle.
      */
     abort(): Promise<void>;
-    private _emitModelSelect;
-    /**
-     * Set model directly.
-     * Validates that auth is configured, saves to session and settings.
-     * @throws Error if no auth is configured for the model
-     */
     setModel(model: Model<any>, options?: {
         persistSettings?: boolean;
     }): Promise<void>;
-    /**
-     * Cycle to next/previous model.
-     * Uses scoped models (from --models flag) if available, otherwise all available models.
-     * @param direction - "forward" (default) or "backward"
-     * @returns The new model info, or undefined if only one model available
-     */
     cycleModel(direction?: "forward" | "backward"): Promise<ModelCycleResult | undefined>;
-    private _cycleScopedModel;
-    private _cycleAvailableModel;
-    /**
-     * Set thinking level.
-     * Clamps to model capabilities based on available thinking levels.
-     * Saves to session and settings only if the level actually changes.
-     */
     setThinkingLevel(level: ThinkingLevel, options?: {
         persistSettings?: boolean;
     }): void;
-    /**
-     * Cycle to next thinking level.
-     * @returns New level, or undefined if model doesn't support thinking
-     */
     cycleThinkingLevel(): ThinkingLevel | undefined;
-    /**
-     * Get available thinking levels for current model.
-     * The provider will clamp to what the specific model supports internally.
-     */
     getAvailableThinkingLevels(): ThinkingLevel[];
-    /**
-     * Check if current model supports thinking/reasoning.
-     */
     supportsThinking(): boolean;
-    private _getThinkingLevelForModelSwitch;
-    private _clampThinkingLevel;
     /**
      * Set steering message mode.
      * Saves to settings.
@@ -1056,6 +888,7 @@ export declare class AgentSession {
     private _checkContextWindowUsageWarning;
     private _checkCompaction;
     private _runAutoCompaction;
+    private _compactWithRetry;
     /**
      * Toggle auto-compaction setting.
      */
@@ -1069,32 +902,6 @@ export declare class AgentSession {
     private _applyExtensionBindings;
     private _refreshCurrentModelFromRegistry;
     private _bindExtensionCore;
-    /**
-     * Resolve the active resource-profile tool allow/block filter from current settings.
-     * Mirrors the construction-time derivation (settingsManager.getResourceProfileFilter("tools"))
-     * so reload() can re-apply it after a live settings/profile edit.
-     */
-    private _deriveToolProfileFilter;
-    private _isToolOrCommandAllowedByProfile;
-    private _hasToolOrCommandProfileGate;
-    private _filterExtensionsForRuntime;
-    /**
-     * /context observations for skills/prompts/extensions the active resource profile removed from
-     * listings — the analog of the withheld-AGENTS.md warning. Strict UAC makes these silently absent,
-     * so a lean profile's effect on the resource surface stays visible. Counts are profile-scoped
-     * (skills/prompts via the profile-independent discovery universe filtered by the live profile
-     * filter; extensions via the runtime filter's denied tally). Empty when nothing is withheld.
-     *
-     * Uses `isResourceDeniedByActiveProfile` (profile-only), not `isResourceAllowedByProfile` (which
-     * also folds in the user's own legacy `disabledResources` list): a plain user-disabled resource
-     * must never be misattributed to "the active resource profile" — that case is already surfaced by
-     * the G14 disable-wins warning. With no active profile at all, the helper always reports nothing
-     * denied, so this naturally stays silent (extensions keep their own runtime-filter-derived count,
-     * which is already correctly zero absent a profile).
-     */
-    private _profileDeniedResourceObservations;
-    private _reapplyActiveProfileModelSettings;
-    private _initializeMemory;
     /** Register a memory provider contributed by an extension; applied on the next memory (re)init. */
     registerMemoryProvider(provider: MemoryProvider): void;
     /** R8: the gateway/scheduler registry. A deployment runner registers providers and drives start/stop. */
@@ -1104,10 +911,6 @@ export declare class AgentSession {
     /** R8: register a deployment-supplied job scheduler (cron). */
     registerJobScheduler(provider: JobSchedulerProvider): void;
     private _refreshToolRegistry;
-    private _createReloadRuntimeSnapshot;
-    private _restoreReloadRuntimeSnapshot;
-    private _doctorReloadRuntime;
-    private _buildRuntime;
     reload(): Promise<void>;
     /**
      * Unload a single extension without full reload.
@@ -1129,10 +932,10 @@ export declare class AgentSession {
      * Falls back to full reload if any individual load/unload fails.
      */
     reconcileLoadedExtensions(): Promise<void>;
-    private _isNonRetryableProviderLimitError;
     /**
-     * Check if an error is retryable (overloaded, rate limit, server errors).
-     * Context overflow errors are NOT retryable (handled by compaction instead).
+     * 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.
      */
     private _isRetryableError;
     private _prepareRetry;
@@ -1148,53 +951,23 @@ export declare class AgentSession {
      * Toggle auto-retry setting.
      */
     setAutoRetryEnabled(enabled: boolean): void;
-    /**
-     * Execute a bash command.
-     * Adds result to agent context and session.
-     * @param command The bash command to execute
-     * @param onChunk Optional streaming callback for output
-     * @param options.excludeFromContext If true, command output won't be sent to LLM (!! prefix)
-     * @param options.operations Custom BashOperations for remote execution
-     */
     executeBash(command: string, onChunk?: (chunk: string) => void, options?: {
         excludeFromContext?: boolean;
         operations?: BashOperations;
     }): Promise<BashResult>;
-    /**
-     * Record a bash execution result in session history.
-     * Used by executeBash and by extensions that handle bash execution themselves.
-     */
     recordBashResult(command: string, result: BashResult, options?: {
         excludeFromContext?: boolean;
     }): void;
-    /**
-     * Cancel running bash command.
-     */
     abortBash(): void;
     /** Whether a bash command is currently running */
     get isBashRunning(): boolean;
     /** Whether there are pending bash messages waiting to be flushed */
     get hasPendingBashMessages(): boolean;
-    /**
-     * Flush pending bash messages to agent state and session.
-     * Called after agent turn completes to maintain proper message ordering.
-     */
     private _flushPendingBashMessages;
     /**
      * Set a display name for the current session.
      */
     setSessionName(name: string): void;
-    /**
-     * Navigate to a different node in the session tree.
-     * Unlike fork() which creates a new session file, this stays in the same file.
-     *
-     * @param targetId The entry ID to navigate to
-     * @param options.summarize Whether user wants to summarize abandoned branch
-     * @param options.customInstructions Custom instructions for summarizer
-     * @param options.replaceInstructions If true, customInstructions replaces the default prompt
-     * @param options.label Label to attach to the branch summary entry
-     * @returns Result with editorText (if user message) and cancelled status
-     */
     navigateTree(targetId: string, options?: {
         summarize?: boolean;
         customInstructions?: string;
@@ -1206,51 +979,17 @@ export declare class AgentSession {
         aborted?: boolean;
         summaryEntry?: BranchSummaryEntry;
     }>;
-    /**
-     * Get all user messages from session for fork selector.
-     */
     getUserMessagesForForking(): Array<{
         entryId: string;
         text: string;
     }>;
-    private _extractUserMessageText;
-    /**
-     * Get session statistics.
-     */
     getSessionStats(): SessionStats;
-    /**
-     * Cumulative usage (full breakdown) for this session's entire spawn subtree: its own
-     * assistant messages PLUS every `spawned_usage` report it has rolled up. Single source of
-     * truth for "how much did this session and everything it spawned spend" — used by print-mode
-     * to emit a child's total so a spawner can roll it up via {@link addSpawnedUsage}.
-     *
-     * Including the `spawned_usage` reports is what keeps the single-hop invariant intact: a child
-     * that itself spawned grandchildren must report own + sub-usage in one number, or the parent
-     * silently under-counts the grandchildren.
-     */
     getCumulativeUsage(): Usage;
-    /**
-     * Record usage spent by a spawned/subagent session so the footer can roll it into the
-     * displayed cost. Persisted as a `CustomEntry` (`customType: "spawned_usage"`, Model A) so
-     * it survives reload and is reconstructed exactly like main usage; a new/forked session
-     * starts fresh because it owns a new log file.
-     *
-     * Idempotent on `opts.reportId`: a re-report (retry, duplicate `agent_end`) with a
-     * previously-seen id is ignored, so cost cannot be double-counted. Honors the single-hop
-     * invariant documented on {@link SpawnedUsageReport}.
-     *
-     * @returns the id of the appended entry, or `undefined` if the report was a duplicate.
-     */
     addSpawnedUsage(usage: Usage, opts?: {
         label?: string;
         sourceSessionId?: string;
         reportId?: string;
     }): string | undefined;
-    /**
-     * Aggregate all recorded spawned-usage reports (see {@link addSpawnedUsage}). Cached by the session
-     * entry count so the interactive footer (which calls this every render frame) is O(1) between turns
-     * instead of an O(N) scan on every keystroke (Bug #22). Recomputes only when entries change.
-     */
     getSpawnedUsage(): SpawnedUsageTotals;
     getDailyUsageTotals(now?: Date): DailyUsageTotals;
     getDailyUsageBreakdown(formatLabel?: (label: string) => string, now?: Date): string;
@@ -1277,21 +1016,7 @@ export declare class AgentSession {
     getEvidenceBundleSnapshots(): EvidenceBundle[];
     /** Live lane records tracked by this process (running and terminal). */
     getLaneRecords(): LaneRecord[];
-    /**
-     * G3: bounded autonomy-telemetry sink. Passes the whole event through {@link redactTelemetryValue}
-     * (the taxonomy's redaction contract) before storing it, so a secret that leaked into a payload
-     * field never lands in the session log. Observe-only: a failure here can never surface into the
-     * turn it is measuring, so the whole body is swallowed. Payloads MUST stay small (ids, codes,
-     * numbers) — never prompt/summary text; callers own that discipline.
-     */
     private _emitAutonomyTelemetry;
-    /**
-     * G8: single sink for a gate outcome. Keeps the latest-outcome getter behavior identical (the
-     * full {@link GateOutcome} still lands in `_lastAutonomyGateOutcome`), and additionally appends a
-     * bounded codes-only entry to {@link _gateOutcomeHistory} (oldest evicted at
-     * {@link GATE_OUTCOME_HISTORY_LIMIT}) and emits the `gate_outcome` telemetry event. The history
-     * tail therefore always mirrors the latest outcome. Only called with an active envelope.
-     */
     private _recordGateOutcome;
     /** G8: copies of the bounded gate-outcome history, oldest first, latest last. */
     getGateOutcomeHistory(): GateOutcomeHistoryEntry[];
@@ -1300,52 +1025,14 @@ export declare class AgentSession {
     saveLearningDecisionSnapshot(decision: LearningDecision): string;
     getLearningDecisionSnapshots(): LearningDecision[];
     getGoalRuntimeSnapshot(settings: GoalRuntimeSnapshotSettings): GoalRuntimeSnapshot;
-    private _clearGoalAutoContinueTimer;
-    private _scheduleGoalAutoContinueFromIdle;
-    private _runScheduledGoalAutoContinue;
-    private _clearResearchLaneTimer;
-    /**
-     * Derive the research demand from durable goal state: an active goal with open requirements,
-     * deduplicated against the latest persisted bundle so the same requirement set is never
-     * researched twice (the query is deterministic, so dedupe survives session reload).
-     */
-    private _buildResearchLaneDemand;
-    /**
-     * Idle trigger for the autonomous research lane (mirrors {@link _scheduleGoalAutoContinueFromIdle}).
-     * All skips are recorded in `_lastResearchLaneSkipReason` and surfaced via diagnostics — the lane
-     * informs, it never prompts or blocks the foreground.
-     */
-    private _scheduleResearchLaneFromIdle;
-    private _runScheduledResearchLane;
     /**
      * Capability profile derived from the CURRENT session model's own metadata (context window),
      * honoring the modelCapability.mode setting ("off" disables, a class name forces).
      */
     getModelCapabilityProfile(): ModelCapabilityProfile;
-    /** Capability profile for a specific lane model (lane budgets scale to the lane model's window). */
-    private _laneCapabilityProfile;
-    /**
-     * Resolve the model for a background lane. Lanes are shipped BY this session, so they inherit
-     * the session's own model unless a lane-specific model is explicitly configured — a single-model
-     * setup (e.g. one local open model) runs its lanes on that same model. An explicitly configured
-     * pattern that cannot resolve/authenticate is a visible skip, not a silent fallback.
-     */
-    private _resolveLaneModel;
-    /**
-     * Resolve what a lane ships with. Precedence: explicit lane model setting, then the lane
-     * profile's model (a shipped profile with a model MUST be obeyed — unresolvable is a visible
-     * skip, never a fallback), then generic inheritance of the session model.
-     */
-    private _resolveLaneShipment;
-    /** UAC tool grants from a shipped lane profile, recorded on the lane envelope. */
-    private _laneProfileToolGrants;
-    /** Stripped research envelope — never the foreground/architect envelope. */
-    private _buildResearchLaneEnvelope;
     /**
-     * Run one bounded, read-only research pass and persist its results: evidence bundle snapshot,
-     * terminal lane record, and spawned-usage cost report (single-hop invariant, idempotent on the
-     * lane's reportId). Explicit calls (e.g. `/autonomy research`) express user intent and bypass the
-     * enabled/mode/dedupe gates the idle scheduler enforces; budget and capability gates always apply.
+     * Run one bounded, read-only research pass and persist its results. Delegates to
+     * {@link BackgroundLaneController}; see there for the full gating/budget/dedupe contract.
      */
     runResearchLaneOnce(request?: {
         query?: string;
@@ -1353,21 +1040,16 @@ export declare class AgentSession {
         goalId?: string;
     }): Promise<ResearchLaneRunOutcome>;
     /**
-     * Run one bounded scout-worker delegation: build a WorkerRequest with a stripped read-only
-     * envelope, execute it as an isolated completion on a cheap lane, validate the result via
-     * {@link validateWorkerResult} before acceptance, and persist result + lane record + spawned
-     * usage (idempotent per-lane reportId). Consumed by the `delegate` tool.
+     * Run one bounded scout-worker delegation. Delegates to {@link BackgroundLaneController};
+     * consumed by the `delegate` tool.
      */
     runWorkerDelegationOnce(request: {
         instructions: string;
-        /** Model-provided replacement for the worker role prompt (the level-0 core always remains). */
         systemPrompt?: string;
     }): Promise<WorkerDelegationRunOutcome>;
     /**
-     * Probe a candidate model against the subagent contracts (research/worker/judge/search/
-     * tool-call surfaces) via {@link runModelFitnessProbe}. The model must resolve and
-     * authenticate; every probe call runs as an isolated completion on that model, and probe
-     * spend is reported through spawned-usage accounting.
+     * Probe a candidate model against the subagent contracts. Delegates to
+     * {@link BackgroundLaneController}; probe spend is reported through spawned-usage accounting.
      */
     runModelFitness(args: {
         model: string;
@@ -1385,26 +1067,13 @@ export declare class AgentSession {
     continueGoalOnce(options: GoalContinuationOnceOptions): Promise<GoalContinuationOnceResult>;
     continueGoalLoop(options: GoalContinuationLoopOptions): Promise<GoalContinuationLoopResult>;
     /**
-     * Run a one-shot LLM completion fully ISOLATED from the main session — the load-bearing
-     * primitive for the native reflection engine (adaptive-agent design §6c/§7).
-     *
-     * Isolation invariants (audited by codex): builds a fresh {@link Context} (no main history), runs
-     * with `tools: []`, sets `cacheRetention: "none"`, and passes **no `sessionId`** — so it cannot
-     * mutate `agent.state.messages`, cannot append session entries, cannot touch the tool registry,
-     * and cannot churn the main session's prompt cache. Mirrors `generateSummary()`'s mechanics.
-     *
-     * Returns the result even on an error/aborted stop reason (callers — e.g. a background reflection
-     * microtask — decide whether to act); it does not throw on a model-level error.
+     * Run a one-shot LLM completion fully ISOLATED from the main session — the load-bearing primitive
+     * for native reflection (see reflection-controller.ts for the isolation invariants).
      */
     runIsolatedCompletion(opts: IsolatedCompletionOptions): Promise<IsolatedCompletionResult>;
     /**
-     * Native end-of-loop reflection pass (R2). Demand-gates (zero-I/O), and when warranted runs the
-     * {@link ReflectionEngine} via an isolated completion ({@link runIsolatedCompletion}), applies the
-     * resulting memory writes through the bundled `memory` tool, and accounts the reflection's token
-     * cost via the cost-aggregation surface so it stays visible and net-negative-auditable.
-     *
-     * Returns `null` when the gate skips (or in a child session, which must not learn). The whole pass
-     * is best-effort: a model/parse error yields no writes, never throws into the caller.
+     * Native end-of-loop reflection pass (R2). Delegates to {@link ReflectionController}; returns null
+     * when the demand gate skips or in a child session.
      */
     runReflectionPass(input: {
         signals: DemandSignals;
@@ -1416,41 +1085,14 @@ export declare class AgentSession {
         reportId?: string;
     }): Promise<ReflectionResult | null>;
     getLearningAuditRecords(): LearningAuditRecord[];
-    /**
-     * Roll back one applied durable learning change by executing the inverse operation recorded in
-     * its audit record (memory ops run through the same bundled memory-tool path as the original
-     * apply; promoted skills are archived). Appends a linked "rollback" audit record on success so
-     * the change history stays complete and a change cannot be rolled back twice.
-     */
+    /** Roll back one applied durable learning change. Delegates to {@link ReflectionController}. */
     rollbackLearningWrite(auditId: string): Promise<{
         ok: boolean;
         reason: string;
     }>;
-    private _applyReflectionWrite;
-    /**
-     * R7: write a reflection-promoted skill as `<agentDir>/skills/<name>/SKILL.md` so it loads like any
-     * user skill. Best-effort; never clobbers an existing (hand-authored) skill of the same name.
-     */
-    private _promoteReflectionSkill;
     getContextUsage(): ContextUsage | undefined;
-    /**
-     * Export session to HTML.
-     * @param outputPath Optional output path (defaults to session directory)
-     * @returns Path to exported file
-     */
     exportToHtml(outputPath?: string): Promise<string>;
-    /**
-     * Export the current session branch to a JSONL file.
-     * Writes the session header followed by all entries on the current branch path.
-     * @param outputPath Target file path. If omitted, generates a timestamped file in cwd.
-     * @returns The resolved output file path.
-     */
     exportToJsonl(outputPath?: string): string;
-    /**
-     * Get text content of last assistant message.
-     * Useful for /copy command.
-     * @returns Text content, or undefined if no assistant message exists
-     */
     getLastAssistantText(): string | undefined;
     getAutonomyStatusSnapshot(): AutonomyStatusSnapshot;
     /**