@caupulican/pi-adaptative 0.81.38 → 0.81.40

package/dist/core/background-lane-controller.js

@@ -1,10 +1,9 @@
 /**
- * Background-lane controller: goal auto-continue, the research lane, scout-worker delegation, and
- * the model-fitness probe.
+ * Execution-plane coordinator for goal continuation, research, managed lanes, worker delegation,
+ * and model fitness.
  *
- * Extracted verbatim from agent-session.ts (god-file decomposition). Owns the lane timers, the
- * single-flight guards, the last research-lane skip reason, the live {@link LaneTracker}, and the
- * session-lifetime abort controllers for in-flight research/worker passes. Everything else it needs
+ * Coordination state is owned by focused controllers. This coordinator retains one AgentSession
+ * composition seam and a shared lane read model. Everything it needs
  * — the session manager, settings, model registry, live model, capability envelope, the goal
  * continuation LOOP, the isolated-completion primitive, spawned-usage accounting, and the telemetry
  * sink — is reached through narrow deps accessors rather than the whole AgentSession.
@@ -14,438 +13,223 @@
  * delegations; goal auto-continue itself only ever asks the session to `continueGoalLoop`, so this
  * controller never touches `prompt()`, the last-assistant-message, retry, or streaming state.
  */
-import path from "node:path";
-import { createLaneToolSurface } from "./autonomy/lane-tool-surface.js";
 import { LaneTracker } from "./autonomy/lane-tracker.js";
-import { safeRealpathSync } from "./autonomy/path-scope.js";
-import { appendLaneRecordSnapshot, getLaneRecordSnapshots } from "./autonomy/session-lane-record.js";
-import { composeSubagentSystemPrompt } from "./autonomy/subagent-prompt.js";
-import { AUTONOMY_TELEMETRY_EVENT_TYPES } from "./autonomy/telemetry-events.js";
-import { applyWorkerActions } from "./delegation/worker-actions.js";
-import { runWorker } from "./delegation/worker-runner.js";
-import { deriveModelCapabilityProfile, scaleContinuationBudgetsForCapability, } from "./model-capability.js";
-import { resolveCliModel } from "./model-resolver.js";
-import { FitnessStore } from "./models/fitness-store.js";
-import { runModelFitnessProbe } from "./research/model-fitness.js";
-import { runResearch } from "./research/research-runner.js";
-const WORKER_HANDOFF_TIMEOUT_MS = 30_000;
-export function clampLaneMaxUsd(settingsMaxUsd, foregroundMaxEstimatedUsd) {
-    return Math.min(settingsMaxUsd, foregroundMaxEstimatedUsd ?? Number.POSITIVE_INFINITY);
-}
-export function getPrivateLaneDeniedPaths(cwd, agentDir) {
-    return [
-        "auth.json",
-        "MEMORY.md",
-        "USER.md",
-        "settings.json",
-        "models.json",
-        "trust.json",
-        "sessions",
-        "state",
-        "work",
-    ]
-        .map((entry) => path.join(agentDir, entry))
-        .concat(path.join(cwd, ".pi", "settings.json"));
-}
-export function isLocalExecutionModel(model) {
-    if (model.provider === "ollama" || model.provider === "transformers" || model.provider === "llama-cpp") {
-        return true;
-    }
-    try {
-        const hostname = new URL(model.baseUrl).hostname.toLowerCase();
-        return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]";
-    }
-    catch {
-        return false;
-    }
-}
+import { appendLaneRecordSnapshot, getLatestLaneRecordSnapshots } from "./autonomy/session-lane-record.js";
+import { ManagedLaneController } from "./delegation/managed-lane-controller.js";
+import { WorkerDelegationController, } from "./delegation/worker-delegation-controller.js";
+import { WorkerLifecycle } from "./delegation/worker-lifecycle.js";
+import { WorkerNotificationCoordinator } from "./delegation/worker-notification-coordinator.js";
+import { GoalAutoContinueController } from "./goals/goal-auto-continue-controller.js";
+import { LaneModelResolver } from "./research/lane-model-resolver.js";
+import { ModelFitnessController } from "./research/model-fitness-controller.js";
+import { ResearchLaneController } from "./research/research-lane-controller.js";
+import { getActiveSessionBranchEntries } from "./session-snapshot.js";
+export { isLocalExecutionModel } from "./delegation/worker-delegation-controller.js";
+export { clampLaneMaxUsd } from "./research/lane-model-resolver.js";
 export class BackgroundLaneController {
-    /** Pending idle timer that starts bounded goal continuation after the session becomes idle. */
-    _goalAutoContinueTimer;
-    /** Guards bounded idle autosteer so continuation prompts do not recursively trigger themselves. */
-    _isGoalAutoContinuing = false;
-    /** Pending idle timer that starts an autonomous research pass after the session becomes idle. */
-    _researchLaneTimer;
-    /** Single-flight guard: at most one research pass runs at a time per session. */
-    _isResearchLaneRunning = false;
-    /** Why the last idle research-lane evaluation skipped, for /autonomy diagnostics. */
-    _lastResearchLaneSkipReason;
     /** Live lane registry — the real source for AutonomyStatusSnapshot.activeLaneCount. */
     _laneTracker = new LaneTracker();
-    _laneHistorySeeded = false;
-    _persistedResearchRunCount = 0;
-    /** Session-lifetime abort for in-flight research passes (same pattern as _reflectionAbort). */
-    _researchLaneAbort = new AbortController();
-    /** Session-lifetime abort for in-flight delegated workers. */
-    _workerDelegationAbort = new AbortController();
-    /** Session-local de-duplication for fail-closed profile grants that cannot bind to lane tools. */
-    _warnedUnboundLaneToolGrants = new Set();
-    /** Every background execution is retained until its terminal result is observed. */
-    _workerPromises = new Map();
-    _queuedWorkers = new Map();
-    _workerNotificationScheduled = false;
-    _workerNotificationTail = Promise.resolve();
-    _disposed = false;
-    _workersCompletedSinceFlush = 0;
-    _workersFailedSinceFlush = 0;
-    _workerTerminalSinceFlush = [];
+    _laneModels;
+    _goalAutoContinue;
+    _research;
+    _fitness;
+    /** Lazily materialized only when managed-lane state is queried or reported. */
+    _managedLanes;
+    /** Lazily materialized so a UAC surface without `delegate` allocates no worker runtime state. */
+    _workers;
+    /** One durable lifecycle shared by every worker execution adapter. */
+    _workerLifecycle;
+    /** Shared terminal outbox for managed and in-process workers; lazy under UAC omission. */
+    _workerNotifications;
     deps;
-    _scheduleWorkerNotification() {
-        if (this._disposed || this._workerNotificationScheduled)
-            return;
-        this._workerNotificationScheduled = true;
-        queueMicrotask(() => this._flushWorkerNotification());
+    /** Emit a warning without ever throwing — used from disposal-adjacent persistence where a
+     * listener failure (or a bare test double missing `emit`) must never block or crash cleanup. */
+    _safeWarn(message) {
+        try {
+            this.deps.emit({ type: "warning", message });
+        }
+        catch {
+            // Dispose must never throw.
+        }
     }
-    _flushWorkerNotification() {
-        this._workerNotificationScheduled = false;
-        if (this._disposed)
-            return;
-        const queued = this._laneTracker
-            .getRecords()
-            .filter((record) => record.type === "worker" && record.status === "queued").length;
-        const running = this._laneTracker.getRunningCount("worker");
-        const terminalSinceFlush = this._workerTerminalSinceFlush.splice(0);
-        const completedSinceFlush = this._workersCompletedSinceFlush;
-        const failedSinceFlush = this._workersFailedSinceFlush;
-        this._workersCompletedSinceFlush = 0;
-        this._workersFailedSinceFlush = 0;
-        this.deps.emit({
-            type: "delegate_workers",
-            active: queued + running,
-            queued,
-            running,
-            completedSinceFlush,
-            failedSinceFlush,
-            terminalSinceFlush,
-        });
-        if (terminalSinceFlush.length === 0)
-            return;
-        const delivery = this._workerNotificationTail.then(async () => {
-            if (this._disposed)
-                return;
-            let timeout;
-            try {
-                await Promise.race([
-                    this.deps.notifyWorkerTerminalHandoff(terminalSinceFlush),
-                    new Promise((_resolve, reject) => {
-                        timeout = setTimeout(() => reject(new Error(`worker terminal handoff timed out after ${WORKER_HANDOFF_TIMEOUT_MS}ms`)), WORKER_HANDOFF_TIMEOUT_MS);
-                        timeout.unref();
-                    }),
-                ]);
-            }
-            finally {
-                if (timeout)
-                    clearTimeout(timeout);
-            }
+    _recordWorkerTerminal(record, durableNotificationId) {
+        this._getWorkerNotificationCoordinator().recordTerminal(record, durableNotificationId);
+    }
+    constructor(deps) {
+        this.deps = deps;
+        this._laneModels = new LaneModelResolver(deps);
+        this._research = new ResearchLaneController(deps, this._laneTracker, this._laneModels);
+        this._fitness = new ModelFitnessController(deps, this._laneModels);
+        this._goalAutoContinue = new GoalAutoContinueController({
+            isDisposed: deps.isDisposed,
+            isGoalToolActive: deps.isGoalToolActive,
+            getSettingsManager: deps.getSettingsManager,
+            getModelCapabilityProfile: deps.getModelCapabilityProfile,
+            getGoalRuntimeSnapshot: deps.getGoalRuntimeSnapshot,
+            hasInFlightLaneForGoal: (goalId) => this._hasInFlightLaneForGoal(goalId),
+            continueGoalLoop: deps.continueGoalLoop,
+            emit: deps.emit,
         });
-        this._workerNotificationTail = delivery.catch((error) => {
-            this.deps.emit({
-                type: "warning",
-                message: `Background worker handoff failed: ${error instanceof Error ? error.message : String(error)}`,
-            });
+    }
+    _getWorkerController() {
+        this._workers ??= new WorkerDelegationController(this.deps, this._getWorkerNotificationCoordinator(), this._getWorkerLifecycle());
+        return this._workers;
+    }
+    _getWorkerLifecycle() {
+        if (this._workerLifecycle)
+            return this._workerLifecycle;
+        const lifecycle = new WorkerLifecycle({
+            agentDir: this.deps.getAgentDir(),
+            sessionId: this.deps.getSessionId(),
         });
+        this._workerLifecycle = lifecycle;
+        for (const notification of lifecycle.getPendingTerminalNotifications()) {
+            this._getWorkerNotificationCoordinator().recordTerminal(notification.record, notification.notificationId);
+        }
+        return lifecycle;
     }
-    _recordWorkerTerminal(record) {
-        if (record.status === "queued" || record.status === "running")
-            return;
-        if (record.status === "succeeded")
-            this._workersCompletedSinceFlush++;
-        else
-            this._workersFailedSinceFlush++;
-        this._workerTerminalSinceFlush.push({
-            laneId: record.laneId,
-            status: record.status,
-            ...(record.reasonCode ? { reasonCode: record.reasonCode } : {}),
+    _getWorkerNotificationCoordinator() {
+        this._workerNotifications ??= new WorkerNotificationCoordinator({
+            getWorkerRecords: () => this._workerLifecycle?.getAllRecords() ?? [],
+            emitStatus: (status) => {
+                try {
+                    this.deps.emit({
+                        type: "delegate_workers",
+                        ...status,
+                        terminalSinceFlush: [...status.terminalSinceFlush],
+                    });
+                }
+                catch {
+                    // A partial integration must not crash the event-driven terminal outbox.
+                }
+            },
+            notify: (records) => this.deps.notifyWorkerTerminalHandoff(records),
+            warn: (message) => this._safeWarn(message),
+            markDurableDelivered: (notificationIds) => this._workerLifecycle?.markNotificationsDelivered(notificationIds),
         });
-        this._scheduleWorkerNotification();
+        return this._workerNotifications;
     }
-    constructor(deps) {
-        this.deps = deps;
+    _getManagedLaneController() {
+        this._managedLanes ??= new ManagedLaneController(this.deps, this._getWorkerLifecycle(), (record, notificationId) => this._recordWorkerTerminal(record, notificationId));
+        return this._managedLanes;
     }
-    _seedLaneHistory() {
-        if (this._laneHistorySeeded)
+    _hydrateManagedLanes() {
+        if (this._managedLanes) {
+            this._managedLanes.ensureHydrated();
             return;
-        const records = getLaneRecordSnapshots(this.deps.getSessionManager().getEntries());
-        this._laneTracker.ensureCounterAtLeast(records.length + 1);
-        this._persistedResearchRunCount = records.filter((record) => record.type === "research").length;
-        this._laneHistorySeeded = true;
+        }
+        const hasPersistedActiveManagedLane = getLatestLaneRecordSnapshots(getActiveSessionBranchEntries(this.deps.getSessionManager())).some((record) => record.type === "tmux-worker" && (record.status === "queued" || record.status === "running"));
+        if (hasPersistedActiveManagedLane)
+            this._getManagedLaneController().ensureHydrated();
     }
     /** Live lane records tracked by this process (running and terminal). */
     getLaneRecords() {
-        return this._laneTracker.getRecords();
+        this._hydrateManagedLanes();
+        const workerRecords = this._workers?.getRecords() ??
+            (this.deps.isDelegateToolActive?.() ? this._getWorkerController().getRecords() : []);
+        return [
+            ...this._laneTracker.getRecords(),
+            ...workerRecords,
+            ...(this._workerLifecycle?.getManagedRecords() ?? []),
+        ];
+    }
+    /** Does not materialize the worker controller when UAC omitted delegation. */
+    getTaskRuntimeSnapshot() {
+        return this._workerLifecycle?.getTaskRuntimeSnapshot();
+    }
+    /** Reconcile only when delegation has already been materialized; UAC omission stays zero-load. */
+    synchronizeGoalState(goal) {
+        this._workers?.synchronizeGoalState(goal);
+    }
+    /**
+     * Resolve a tracked managed-lane dispatch. The caller's stable id is also the canonical durable
+     * lane id, so this is an existence check rather than an id translation.
+     */
+    resolveManagedLaneId(callerLaneId) {
+        return this._getManagedLaneController().resolve(callerLaneId);
     }
     /** Live count of active lanes — the real source for AutonomyStatusSnapshot.activeLaneCount. */
     getActiveLaneCount() {
-        return this._laneTracker.getActiveCount();
+        return this.getLaneRecords().filter((record) => record.status === "queued" || record.status === "running").length;
+    }
+    /** Belt-and-braces guard: whether ANY queued/running lane is tagged with this goalId. */
+    _hasInFlightLaneForGoal(goalId) {
+        return this.getLaneRecords().some((record) => record.goalId === goalId && (record.status === "queued" || record.status === "running"));
+    }
+    /** Delegate the out-of-process dispatch/terminal claim to its single lifecycle owner. */
+    recordManagedLane(event) {
+        return this._getManagedLaneController().record(event);
     }
     /** Why the last idle research-lane evaluation skipped, for /autonomy diagnostics. */
     getLastResearchLaneSkipReason() {
-        return this._lastResearchLaneSkipReason;
+        return this._research.getLastSkipReason();
     }
-    /** Abort any in-flight research pass or delegated worker (called on session dispose). */
+    /**
+     * Abort in-flight research and delegate worker disposal to its single owning controller.
+     *
+     * This synchronous body is the LAST provably-safe write window for canceled/in-flight work.
+     * `dispose()` (agent-session.ts) has already set the session's own disposed flag but has not yet
+     * returned — no successor session (e.g. a `/reload` adoption) can exist yet, so an append here
+     * cannot interleave with one; a post-await continuation resuming AFTER this method returns must
+     * not append (see the disposed branch in `runWorkerDelegationOnce`). Persist FIRST, then
+     * complete-in-memory, so a throw from one lane's persist cannot skip another's; each persist gets
+     * its own try/catch — dispose must never throw.
+     */
     abortInFlightLanes() {
-        this._disposed = true;
-        this._researchLaneAbort.abort();
-        this._workerDelegationAbort.abort();
-        this._queuedWorkers.clear();
+        this._goalAutoContinue.clearTimer();
+        this._research.abort();
+        this._fitness.abort();
         for (const record of this._laneTracker.getRecords()) {
-            if (record.status === "queued" || record.status === "running") {
-                this._laneTracker.complete(record.laneId, {
-                    status: "canceled",
-                    reasonCode: "session_disposed",
-                });
+            if (record.status !== "queued" && record.status !== "running")
+                continue;
+            if (record.type === "tmux-worker")
+                continue;
+            const canceled = this._laneTracker.complete(record.laneId, {
+                status: "canceled",
+                reasonCode: "session_disposed",
+            });
+            if (!canceled)
+                continue;
+            try {
+                appendLaneRecordSnapshot(this.deps.getSessionManager(), canceled);
+            }
+            catch (error) {
+                this._safeWarn(`Failed to persist canceled lane record ${canceled.laneId}: ${error instanceof Error ? error.message : String(error)}`);
             }
         }
-        this._workerNotificationScheduled = false;
-        this._workerTerminalSinceFlush.length = 0;
+        this._managedLanes?.release();
+        this._workers?.abort();
+        this._workerNotifications?.dispose();
     }
     clearGoalAutoContinueTimer() {
-        if (this._goalAutoContinueTimer !== undefined) {
-            clearTimeout(this._goalAutoContinueTimer);
-            this._goalAutoContinueTimer = undefined;
-        }
+        this._goalAutoContinue.clearTimer();
     }
     scheduleGoalAutoContinueFromIdle(options) {
-        if (options?.autoContinueGoal === false || this._isGoalAutoContinuing || this.deps.isDisposed())
-            return;
-        // Small-window models cannot afford multi-thousand-token continuation prompts per idle turn.
-        if (!this.deps.getModelCapabilityProfile().backgroundLanesEnabled)
-            return;
-        const { maxStallTurns, goalAutoContinue, goalAutoContinueDelayMs } = this.deps
-            .getSettingsManager()
-            .getAutonomySettings();
-        if (!goalAutoContinue)
-            return;
-        const snapshot = this.deps.getGoalRuntimeSnapshot({ maxStallTurns });
-        if (snapshot.continuation.action !== "continue")
-            return;
-        this.clearGoalAutoContinueTimer();
-        this._goalAutoContinueTimer = setTimeout(() => {
-            this._goalAutoContinueTimer = undefined;
-            void this._runScheduledGoalAutoContinue();
-        }, goalAutoContinueDelayMs);
-        const timer = this._goalAutoContinueTimer;
-        if (typeof timer === "object" && timer && "unref" in timer) {
-            const { unref } = timer;
-            unref?.call(timer);
-        }
-    }
-    async _runScheduledGoalAutoContinue() {
-        if (this._isGoalAutoContinuing || this.deps.isDisposed())
-            return;
-        const { maxStallTurns, goalContinueTurns, goalContinueMaxWallClockMinutes, goalAutoContinue } = this.deps
-            .getSettingsManager()
-            .getAutonomySettings();
-        if (!goalAutoContinue)
-            return;
-        const snapshot = this.deps.getGoalRuntimeSnapshot({ maxStallTurns });
-        if (snapshot.continuation.action !== "continue")
-            return;
-        // Lean-window models (16-32k) keep autosteer but at a reduced budget; full passes through.
-        const scaled = scaleContinuationBudgetsForCapability(this.deps.getModelCapabilityProfile(), {
-            maxTurns: goalContinueTurns,
-            maxWallClockMinutes: goalContinueMaxWallClockMinutes,
-        });
-        this._isGoalAutoContinuing = true;
-        try {
-            await this.deps.continueGoalLoop({
-                maxTurns: scaled.maxTurns,
-                maxStallTurns,
-                maxWallClockMinutes: scaled.maxWallClockMinutes,
-            });
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            this.deps.emit({ type: "warning", message: `Goal auto-continuation failed: ${message}` });
-        }
-        finally {
-            this._isGoalAutoContinuing = false;
-        }
-    }
-    clearResearchLaneTimer() {
-        if (this._researchLaneTimer !== undefined) {
-            clearTimeout(this._researchLaneTimer);
-            this._researchLaneTimer = undefined;
-        }
+        this._goalAutoContinue.scheduleFromIdle(options);
     }
     /**
-     * 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).
+     * Single-flight entry point for EVERY goal-continuation loop invocation — idle autosteer
+     * ({@link _runScheduledGoalAutoContinue}) AND the manual `/goal start` / `/goal-continue`
+     * commands (reached through `AgentSession.continueGoalLoop`). Both paths ultimately submit
+     * continuation prompts through the session's single `prompt()` path, so two loops racing throws
+     * "Agent is already processing" from whichever submits second. `_isGoalAutoContinuing` is the
+     * ONE owner of that mutex; `deps.continueGoalLoop` (the raw {@link GoalLoopController} loop)
+     * must never be called directly outside this method, or the guard is bypassed.
      */
-    _buildResearchLaneDemand() {
-        const goal = this.deps.getGoalStateSnapshot();
-        if (!goal || goal.status !== "active") {
-            this._lastResearchLaneSkipReason = "no_active_goal";
-            return undefined;
-        }
-        const open = goal.requirements.filter((requirement) => requirement.status === "open");
-        if (open.length === 0) {
-            this._lastResearchLaneSkipReason = "no_open_requirements";
-            return undefined;
-        }
-        const query = `goal:${goal.goalId} requirements:${open
-            .map((requirement) => requirement.id)
-            .sort()
-            .join(",")}`;
-        if (this.deps.getEvidenceBundleSnapshot()?.query === query) {
-            this._lastResearchLaneSkipReason = "recent_evidence_sufficient";
-            return undefined;
-        }
-        const context = [
-            `Goal: ${goal.userGoal}`,
-            "Open requirements:",
-            ...open.slice(0, 20).map((requirement) => `- ${requirement.text}`),
-        ].join("\n");
-        return { query, context, goalId: goal.goalId };
-    }
-    /**
-     * 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.
-     */
-    scheduleResearchLaneFromIdle() {
-        if (this._isResearchLaneRunning || this.deps.isDisposed() || this.deps.isChildSession())
-            return;
-        const research = this.deps.getSettingsManager().getResearchLaneSettings();
-        if (!research.enabled) {
-            this._lastResearchLaneSkipReason = "research_lane_disabled";
-            return;
-        }
-        const { mode } = this.deps.getSettingsManager().getAutonomySettings();
-        if (mode === "off") {
-            this._lastResearchLaneSkipReason = "autonomy_mode_off";
-            return;
-        }
-        this._seedLaneHistory();
-        if (this._persistedResearchRunCount >= research.maxRunsPerSession) {
-            this._lastResearchLaneSkipReason = "max_runs_reached";
-            return;
-        }
-        if (!this._buildResearchLaneDemand())
-            return;
-        const shipment = this._resolveLaneShipment(research, "no_research_model");
-        if (!shipment.ok) {
-            this._lastResearchLaneSkipReason = shipment.skipReason;
-            return;
-        }
-        if (!this._laneCapabilityProfile(shipment.model).backgroundLanesEnabled) {
-            this._lastResearchLaneSkipReason = "model_research_unsupported";
-            return;
-        }
-        this.clearResearchLaneTimer();
-        this._researchLaneTimer = setTimeout(() => {
-            this._researchLaneTimer = undefined;
-            void this._runScheduledResearchLane();
-        }, research.idleDelayMs);
-        const timer = this._researchLaneTimer;
-        if (typeof timer === "object" && timer && "unref" in timer) {
-            const { unref } = timer;
-            unref?.call(timer);
-        }
+    async continueGoalLoopExclusive(options) {
+        return this._goalAutoContinue.continueExclusive(options);
     }
-    async _runScheduledResearchLane() {
-        if (this._isResearchLaneRunning || this.deps.isDisposed())
-            return;
-        const research = this.deps.getSettingsManager().getResearchLaneSettings();
-        const { mode } = this.deps.getSettingsManager().getAutonomySettings();
-        if (!research.enabled || mode === "off")
-            return;
-        try {
-            await this.runResearchLaneOnce();
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            this.deps.emit({ type: "warning", message: `Research lane failed: ${message}` });
-        }
+    clearResearchLaneTimer() {
+        this._research.clearTimer();
     }
-    /** Capability profile for a specific lane model (lane budgets scale to the lane model's window). */
-    _laneCapabilityProfile(model) {
-        return deriveModelCapabilityProfile({
-            contextWindow: model.contextWindow,
-            mode: this.deps.getSettingsManager().getModelCapabilitySettings().mode,
-        });
+    scheduleResearchLaneFromIdle() {
+        this._research.scheduleFromIdle();
     }
-    /**
-     * 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.
-     */
     resolveLaneModel(configuredPattern) {
-        if (configuredPattern) {
-            const resolved = resolveCliModel({ cliModel: configuredPattern, modelRegistry: this.deps.getModelRegistry() });
-            if (resolved.model && this.deps.getModelRegistry().hasConfiguredAuth(resolved.model)) {
-                return resolved.model;
-            }
-            return undefined;
-        }
-        return this.deps.getModel() ?? undefined;
+        return this._laneModels.resolveModel(configuredPattern);
     }
-    /**
-     * 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.
-     */
-    _resolveLaneShipment(laneSettings, missingModelReason) {
-        let laneProfile;
-        if (laneSettings.profile) {
-            const profileRef = laneSettings.profile.trim();
-            const registry = this.deps.getSettingsManager().getProfileRegistry();
-            laneProfile =
-                profileRef.startsWith("./") || profileRef.startsWith("../")
-                    ? registry.resolveProfileRef(profileRef, this.deps.getCwd())
-                    : registry.getProfile(profileRef);
-            if (!laneProfile) {
-                return { ok: false, skipReason: "lane_profile_not_found" };
-            }
-        }
-        let model;
-        if (laneSettings.model) {
-            model = this.resolveLaneModel(laneSettings.model);
-            if (!model)
-                return { ok: false, skipReason: missingModelReason };
-        }
-        else if (laneProfile?.model) {
-            model = this.resolveLaneModel(laneProfile.model);
-            if (!model)
-                return { ok: false, skipReason: "no_lane_profile_model" };
-        }
-        else {
-            model = this.deps.getModel() ?? undefined;
-            if (!model)
-                return { ok: false, skipReason: missingModelReason };
-        }
-        if (this.deps.isModelExhausted(model)) {
-            return { ok: false, skipReason: `${model.provider}/${model.id} model exhausted: quota` };
-        }
-        return { ok: true, model, laneProfile };
-    }
-    _warnUnboundLaneToolGrants(laneProfile, surface) {
-        if (!laneProfile || surface.unboundAllowPatterns.length === 0)
-            return;
-        const warningKey = `${laneProfile.name}\0${[...surface.unboundAllowPatterns].sort().join("\0")}`;
-        if (this._warnedUnboundLaneToolGrants.has(warningKey))
-            return;
-        this._warnedUnboundLaneToolGrants.add(warningKey);
-        this.deps.emit({
-            type: "warning",
-            message: `Lane profile '${laneProfile.name}' grants unavailable isolated-lane tools: ${surface.unboundAllowPatterns.join(", ")}. Only classified lane tools can execute.`,
-        });
-    }
-    /** Stripped research envelope — never the foreground/architect envelope. */
-    _buildResearchLaneEnvelope(maxUsd, laneProfile, surface) {
-        return {
-            id: `research-${this.deps.getSessionId()}-${Date.now()}`,
-            profileId: laneProfile?.name,
-            capabilities: ["research", "read_files", "memory_read"],
-            allowedTools: [...surface.allowedTools],
-            deniedTools: [...surface.deniedTools],
-            allowedPaths: [this.deps.getCwd()],
-            deniedPaths: getPrivateLaneDeniedPaths(this.deps.getCwd(), this.deps.getAgentDir()),
-            maxEstimatedUsd: clampLaneMaxUsd(maxUsd, this.deps.getCapabilityEnvelope()?.maxEstimatedUsd),
-            createdAt: new Date().toISOString(),
-        };
+    getOrchestrationProfileCatalog() {
+        return this._getWorkerController().getProfileCatalog();
     }
     /**
      * Run one bounded, read-only research pass and persist its results: evidence bundle snapshot,
@@ -454,468 +238,15 @@ export class BackgroundLaneController {
      * enabled/mode/dedupe gates the idle scheduler enforces; budget and capability gates always apply.
      */
     async runResearchLaneOnce(request) {
-        if (this._isResearchLaneRunning) {
-            return { started: false, skipReason: "research_lane_already_running" };
-        }
-        if (this.deps.isDisposed()) {
-            return { started: false, skipReason: "session_disposed" };
-        }
-        const settings = this.deps.getSettingsManager().getResearchLaneSettings();
-        const demand = request?.query
-            ? { query: request.query, context: request.context ?? "", goalId: request.goalId }
-            : this._buildResearchLaneDemand();
-        if (!demand) {
-            return { started: false, skipReason: this._lastResearchLaneSkipReason ?? "no_research_demand" };
-        }
-        const shipment = this._resolveLaneShipment(settings, "no_research_model");
-        if (!shipment.ok) {
-            this._lastResearchLaneSkipReason = shipment.skipReason;
-            return { started: false, skipReason: shipment.skipReason };
-        }
-        const { model, laneProfile } = shipment;
-        const laneCapability = this._laneCapabilityProfile(model);
-        if (!laneCapability.backgroundLanesEnabled) {
-            this._lastResearchLaneSkipReason = "model_research_unsupported";
-            return { started: false, skipReason: "model_research_unsupported" };
-        }
-        this._isResearchLaneRunning = true;
-        this._seedLaneHistory();
-        const startedRecord = this._laneTracker.start({ type: "research", goalId: demand.goalId });
-        this._persistedResearchRunCount++;
-        try {
-            let spentUsage;
-            // Best-effort, pointer-first workspace evidence. Derives search terms from the goal/requirement
-            // text (not the identity-key query) and is bounded + silent-on-failure: [] == today's behavior.
-            const workspaceSources = await this.deps.collectWorkspaceSources({
-                query: `${demand.context}\n${demand.query}`,
-                cwd: this.deps.getCwd(),
-                maxSources: settings.maxSources,
-            });
-            const maxUsd = clampLaneMaxUsd(settings.maxUsd, this.deps.getCapabilityEnvelope()?.maxEstimatedUsd);
-            const toolSurface = createLaneToolSurface({
-                cwd: this.deps.getCwd(),
-                profile: laneProfile,
-                deniedPaths: getPrivateLaneDeniedPaths(this.deps.getCwd(), this.deps.getAgentDir()),
-            });
-            this._warnUnboundLaneToolGrants(laneProfile, toolSurface);
-            const result = await runResearch({
-                query: demand.query,
-                context: demand.context,
-                sources: workspaceSources,
-                envelope: this._buildResearchLaneEnvelope(maxUsd, laneProfile, toolSurface),
-                maxUsd,
-                maxSources: settings.maxSources,
-                maxFindings: settings.maxFindings,
-                maxWallClockMs: settings.maxWallClockMs,
-                signal: this._researchLaneAbort.signal,
-                complete: async ({ systemPrompt, userPrompt, signal }) => {
-                    const completion = await this.deps.runIsolatedCompletion({
-                        // Level-0 core always survives; profile soul and role prompt are the replaceable
-                        // layers; a settings-provided prompt replaces everything above the core.
-                        systemPrompt: composeSubagentSystemPrompt({
-                            soul: laneProfile?.soul,
-                            rolePrompt: systemPrompt,
-                            override: settings.systemPrompt,
-                        }),
-                        messages: [{ role: "user", content: [{ type: "text", text: userPrompt }], timestamp: Date.now() }],
-                        model,
-                        thinkingLevel: laneProfile?.thinking ?? "off",
-                        maxTokens: laneCapability.laneMaxOutputTokens,
-                        tools: toolSurface.tools,
-                        maxTurns: 6,
-                        beforeToolCall: toolSurface.beforeToolCall,
-                        signal,
-                        // Core/soul/role are all static per configuration — the provider can cache the prefix.
-                        cacheRetention: "short",
-                    });
-                    spentUsage = completion.usage;
-                    return {
-                        text: completion.text,
-                        costUsd: completion.usage.cost.total,
-                        stopReason: String(completion.stopReason),
-                    };
-                },
-            });
-            // Bug #21 pattern: if the session was disposed while the completion was in flight, do NOT
-            // persist evidence/records/usage against the dead session.
-            if (this.deps.isDisposed()) {
-                const record = this._laneTracker.complete(startedRecord.laneId, {
-                    status: "canceled",
-                    reasonCode: "session_disposed",
-                });
-                return { started: true, record, result };
-            }
-            let evidenceEntryId;
-            if (result.bundle) {
-                evidenceEntryId = this.deps.saveEvidenceBundleSnapshot(result.bundle);
-            }
-            if (spentUsage && (spentUsage.cost.total > 0 || spentUsage.totalTokens > 0)) {
-                this.deps.addSpawnedUsage(spentUsage, {
-                    label: "research-lane",
-                    reportId: `research:${this.deps.getSessionId()}:${startedRecord.laneId}`,
-                });
-            }
-            const record = this._laneTracker.complete(startedRecord.laneId, {
-                status: result.status,
-                reasonCode: result.reasonCode,
-                costUsd: result.costUsd,
-                evidenceEntryId,
-            });
-            if (record) {
-                appendLaneRecordSnapshot(this.deps.getSessionManager(), record);
-                // G3: a research lane's product is an evidence bundle, so its terminal record maps to
-                // the evidence_bundle event. Lane outcome only (status/reasonCode/cost) — no findings text.
-                this.deps.emitAutonomyTelemetry({
-                    type: AUTONOMY_TELEMETRY_EVENT_TYPES.evidenceBundle,
-                    timestamp: new Date().toISOString(),
-                    payload: {
-                        laneId: record.laneId,
-                        laneType: record.type,
-                        status: record.status,
-                        reasonCode: record.reasonCode ?? null,
-                        costUsd: record.costUsd ?? null,
-                        hasEvidence: record.evidenceEntryId !== undefined,
-                    },
-                });
-            }
-            return { started: true, record, result };
-        }
-        catch (error) {
-            const record = this._laneTracker.complete(startedRecord.laneId, {
-                status: "failed",
-                reasonCode: "research_lane_error",
-            });
-            if (record && !this.deps.isDisposed()) {
-                appendLaneRecordSnapshot(this.deps.getSessionManager(), record);
-                this.deps.emitAutonomyTelemetry({
-                    type: AUTONOMY_TELEMETRY_EVENT_TYPES.evidenceBundle,
-                    timestamp: new Date().toISOString(),
-                    payload: {
-                        laneId: record.laneId,
-                        laneType: record.type,
-                        status: record.status,
-                        reasonCode: record.reasonCode ?? null,
-                        costUsd: record.costUsd ?? null,
-                        hasEvidence: record.evidenceEntryId !== undefined,
-                    },
-                });
-            }
-            const message = error instanceof Error ? error.message : String(error);
-            this.deps.emit({ type: "warning", message: `Research lane failed: ${message}` });
-            return { started: true, record };
-        }
-        finally {
-            this._isResearchLaneRunning = false;
-        }
+        return this._research.runOnce(request);
     }
-    /**
-     * 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.
-     */
+    /** Start a durable, profile-bound worker delegation. */
     startWorkerDelegation(request) {
-        const settings = this.deps.getSettingsManager().getWorkerDelegationSettings();
-        if (this.deps.isDisposed())
-            return { started: false, skipReason: "session_disposed" };
-        if (request.instructions.trim().length === 0)
-            return { started: false, skipReason: "missing_instructions" };
-        if (!this.deps.isDelegateToolActive())
-            return { started: false, skipReason: "delegate_tool_inactive" };
-        if (!settings.enabled)
-            return { started: false, skipReason: "worker_delegation_disabled" };
-        const shipment = this._resolveLaneShipment(settings, "no_worker_model");
-        if (!shipment.ok)
-            return { started: false, skipReason: shipment.skipReason };
-        if (!this._laneCapabilityProfile(shipment.model).backgroundLanesEnabled) {
-            return { started: false, skipReason: "model_delegation_unsupported" };
-        }
-        const foreground = this.deps.getModel();
-        const contendsWithLocalForeground = foreground !== undefined && isLocalExecutionModel(foreground) && isLocalExecutionModel(shipment.model);
-        if (contendsWithLocalForeground) {
-            if (this._queuedWorkers.size >= 8 ||
-                this._laneTracker.getActiveCount("worker") >= settings.maxConcurrent + 8) {
-                return { started: false, skipReason: "worker_delegation_queue_full" };
-            }
-            const record = this._laneTracker.enqueue({ type: "worker" });
-            this._queuedWorkers.set(record.laneId, request);
-            this._scheduleWorkerNotification();
-            return { started: true, record };
-        }
-        if (this._laneTracker.getRunningCount("worker") >= settings.maxConcurrent) {
-            return { started: false, skipReason: "worker_delegation_already_running" };
-        }
-        let startedRecord;
-        const promise = this.runWorkerDelegationOnce(request, (record) => {
-            startedRecord = record;
-        });
-        if (!startedRecord) {
-            // Preparation is synchronous up to the first isolated completion await. A promise that
-            // rejected before producing a lane is still observed below, so it cannot become unhandled.
-            void promise.catch(() => undefined);
-            return { started: false, skipReason: "worker_not_started" };
-        }
-        this._workerPromises.set(startedRecord.laneId, promise);
-        void promise.then(() => this._workerPromises.delete(startedRecord?.laneId ?? ""), () => this._workerPromises.delete(startedRecord?.laneId ?? ""));
-        return { started: true, record: startedRecord };
+        return this._getWorkerController().start(request);
     }
+    /** Run one worker immediately; used by focused integrations and tests. */
     async runWorkerDelegationOnce(request, onStarted, existingRecord) {
-        const delegationSettings = this.deps.getSettingsManager().getWorkerDelegationSettings();
-        const runningWorkers = this._laneTracker.getRunningCount("worker");
-        if (runningWorkers >= delegationSettings.maxConcurrent) {
-            return { started: false, skipReason: "worker_delegation_already_running" };
-        }
-        if (this.deps.isDisposed()) {
-            return { started: false, skipReason: "session_disposed" };
-        }
-        const instructions = request.instructions.trim();
-        if (instructions.length === 0) {
-            return { started: false, skipReason: "missing_instructions" };
-        }
-        const settings = delegationSettings;
-        if (!this.deps.isDelegateToolActive()) {
-            return { started: false, skipReason: "delegate_tool_inactive" };
-        }
-        if (!settings.enabled) {
-            return { started: false, skipReason: "worker_delegation_disabled" };
-        }
-        const shipment = this._resolveLaneShipment(settings, "no_worker_model");
-        if (!shipment.ok) {
-            return { started: false, skipReason: shipment.skipReason };
-        }
-        const { model, laneProfile } = shipment;
-        const laneCapability = this._laneCapabilityProfile(model);
-        if (!laneCapability.backgroundLanesEnabled) {
-            return { started: false, skipReason: "model_delegation_unsupported" };
-        }
-        this._seedLaneHistory();
-        const startedRecord = existingRecord ?? this._laneTracker.start({ type: "worker" });
-        if (existingRecord)
-            this._laneTracker.markRunning(existingRecord.laneId);
-        onStarted?.(startedRecord);
-        const maxUsd = Math.min(settings.maxUsd, this.deps.getCapabilityEnvelope()?.maxEstimatedUsd ?? Number.POSITIVE_INFINITY);
-        const writeEnabled = settings.writeEnabled && settings.writePaths.length > 0;
-        const toolSurface = createLaneToolSurface({
-            cwd: this.deps.getCwd(),
-            profile: laneProfile,
-            deniedPaths: getPrivateLaneDeniedPaths(this.deps.getCwd(), this.deps.getAgentDir()),
-            readMemory: request.memoryRead ? (query) => this.deps.readMemoryForLane(query) : undefined,
-            writeEnabled,
-            writePaths: settings.writePaths,
-        });
-        this._warnUnboundLaneToolGrants(laneProfile, toolSurface);
-        const allowedActionOps = new Set(toolSurface.allowedTools.filter((name) => name === "write" || name === "edit"));
-        const writeGranted = writeEnabled && allowedActionOps.size > 0;
-        const memoryReadGranted = request.memoryRead === true && toolSurface.allowedTools.includes("memory");
-        const workerRequest = {
-            id: startedRecord.laneId,
-            instructions,
-            route: {
-                tier: "cheap",
-                risk: writeGranted ? "scoped-write" : "read-only",
-                confidence: 1,
-                reasonCode: "scout_worker",
-                reasons: [writeGranted ? "Path-scoped worker delegation" : "Read-only scout delegation"],
-            },
-            envelope: {
-                id: `worker-${this.deps.getSessionId()}-${startedRecord.laneId}`,
-                profileId: laneProfile?.name,
-                // write_files requires BOTH the opt-in AND an explicit non-empty path scope —
-                // an unscoped write grant is refused here, not discovered at validation time.
-                capabilities: [
-                    "read_files",
-                    ...(memoryReadGranted ? ["memory_read"] : []),
-                    ...(writeGranted ? ["write_files"] : []),
-                ],
-                ...(writeGranted ? { allowedPaths: [...settings.writePaths] } : {}),
-                deniedPaths: getPrivateLaneDeniedPaths(this.deps.getCwd(), this.deps.getAgentDir()),
-                allowedTools: [...toolSurface.allowedTools],
-                deniedTools: [...toolSurface.deniedTools],
-                maxEstimatedUsd: maxUsd,
-                createdAt: new Date().toISOString(),
-            },
-            maxEstimatedUsd: maxUsd,
-            createdAt: new Date().toISOString(),
-        };
-        // G8: worker delegation START. Routing/scope codes + budget only — never the instructions text.
-        this.deps.emitAutonomyTelemetry({
-            type: AUTONOMY_TELEMETRY_EVENT_TYPES.workerRequest,
-            timestamp: new Date().toISOString(),
-            payload: {
-                id: workerRequest.id,
-                tier: workerRequest.route.tier,
-                capabilities: [...workerRequest.envelope.capabilities],
-                maxEstimatedUsd: workerRequest.maxEstimatedUsd ?? null,
-            },
-        });
-        const usageReportId = `worker:${this.deps.getSessionId()}:${startedRecord.laneId}`;
-        try {
-            let spentUsage;
-            const toolChangedFiles = new Set();
-            const toolIssues = new Set();
-            const outcome = await runWorker({
-                request: workerRequest,
-                maxUsd,
-                maxWallClockMs: settings.maxWallClockMs,
-                usageReportId,
-                getChangedFiles: () => [...toolChangedFiles],
-                signal: this._workerDelegationAbort.signal,
-                // Parent validation must use the same relative-path baseline the runner reports in.
-                cwd: this.deps.getCwd(),
-                // Write lane (G2): runner-side action application through the envelope path scope.
-                applyActions: workerRequest.envelope.capabilities.includes("write_files")
-                    ? (actions) => {
-                        const permitted = actions.filter((action) => allowedActionOps.has(action.op));
-                        const applied = applyWorkerActions({
-                            actions: permitted,
-                            envelope: workerRequest.envelope,
-                            cwd: this.deps.getCwd(),
-                        });
-                        return {
-                            ...applied,
-                            refused: [
-                                ...actions
-                                    .filter((action) => !allowedActionOps.has(action.op))
-                                    .map((action) => ({
-                                    path: action.path,
-                                    reason: `${action.op} is not granted by the lane profile`,
-                                })),
-                                ...applied.refused,
-                            ],
-                        };
-                    }
-                    : undefined,
-                complete: async ({ systemPrompt, userPrompt, signal }) => {
-                    const completion = await this.deps.runIsolatedCompletion({
-                        // Level-0 core always survives. A model-provided prompt (delegate tool) is the most
-                        // specific override, then the settings-level prompt, then profile soul + role prompt.
-                        systemPrompt: composeSubagentSystemPrompt({
-                            soul: laneProfile?.soul,
-                            rolePrompt: systemPrompt,
-                            override: request.systemPrompt ?? settings.systemPrompt,
-                        }),
-                        messages: [{ role: "user", content: [{ type: "text", text: userPrompt }], timestamp: Date.now() }],
-                        model,
-                        thinkingLevel: laneProfile?.thinking ?? "off",
-                        maxTokens: laneCapability.laneMaxOutputTokens,
-                        tools: toolSurface.tools,
-                        maxTurns: 6,
-                        finalTextPrompt: "The tool-turn budget is exhausted. Do not call more tools. Return the required worker-result JSON envelope now using only evidence already gathered. If the investigation is incomplete, say so in the summary or blockers instead of omitting the envelope.",
-                        beforeToolCall: async (context, toolSignal) => {
-                            const decision = await toolSurface.beforeToolCall(context, toolSignal);
-                            if (decision?.block) {
-                                toolIssues.add(`${context.toolCall.name} blocked: ${decision.reason ?? "capability denied"}`);
-                            }
-                            return decision;
-                        },
-                        afterToolCall: async ({ toolCall, args, isError }) => {
-                            // This hook runs only for a validated, gate-approved tool that actually entered
-                            // execution. Record a direct mutation target before inspecting `isError`: write/edit
-                            // may have changed disk and then observed cancellation, timeout, or a late I/O error.
-                            // Pre-gate/profile/path refusals never reach afterToolCall, so they remain unreported.
-                            if (toolCall.name === "write" || toolCall.name === "edit") {
-                                if (args && typeof args === "object" && !Array.isArray(args)) {
-                                    const rawPath = args.path;
-                                    if (typeof rawPath === "string" && rawPath.length > 0) {
-                                        const absolutePath = path.isAbsolute(rawPath)
-                                            ? path.resolve(rawPath)
-                                            : path.resolve(this.deps.getCwd(), rawPath);
-                                        let canonicalPath = absolutePath;
-                                        try {
-                                            canonicalPath = safeRealpathSync(absolutePath);
-                                        }
-                                        catch {
-                                            // Execution was attempted; preserve conservative accounting with the lexical path.
-                                        }
-                                        toolChangedFiles.add(path.relative(this.deps.getCwd(), canonicalPath).split(path.sep).join("/"));
-                                    }
-                                }
-                            }
-                            if (isError) {
-                                toolIssues.add(`${toolCall.name} failed during isolated execution`);
-                                return undefined;
-                            }
-                            return undefined;
-                        },
-                        signal,
-                        // Core/soul/role are all static per configuration — the provider can cache the prefix.
-                        cacheRetention: "short",
-                    });
-                    spentUsage = completion.usage;
-                    return {
-                        text: completion.text,
-                        costUsd: completion.usage.cost.total,
-                        stopReason: String(completion.stopReason),
-                        changedFiles: [...toolChangedFiles],
-                        blockers: [...toolIssues],
-                    };
-                },
-            });
-            // Bug #21 pattern: never persist against a disposed session.
-            if (this.deps.isDisposed()) {
-                const record = this._laneTracker.complete(startedRecord.laneId, {
-                    status: "canceled",
-                    reasonCode: "session_disposed",
-                });
-                if (record)
-                    this._recordWorkerTerminal(record);
-                return { started: true, record, outcome };
-            }
-            this.deps.saveWorkerResultSnapshot(outcome.result, workerRequest);
-            if (spentUsage && (spentUsage.cost.total > 0 || spentUsage.totalTokens > 0)) {
-                this.deps.addSpawnedUsage(spentUsage, { label: "worker-delegation", reportId: usageReportId });
-            }
-            const record = this._laneTracker.complete(startedRecord.laneId, {
-                status: outcome.laneStatus,
-                reasonCode: outcome.reasonCode,
-                costUsd: outcome.costUsd,
-            });
-            if (record) {
-                this._recordWorkerTerminal(record);
-                appendLaneRecordSnapshot(this.deps.getSessionManager(), record);
-                // G3: worker lane terminal record -> worker_result event. Lane outcome only
-                // (status/reasonCode/cost) — never the worker's summary/changed-file text.
-                this.deps.emitAutonomyTelemetry({
-                    type: AUTONOMY_TELEMETRY_EVENT_TYPES.workerResult,
-                    timestamp: new Date().toISOString(),
-                    payload: {
-                        laneId: record.laneId,
-                        laneType: record.type,
-                        status: record.status,
-                        reasonCode: record.reasonCode ?? null,
-                        costUsd: record.costUsd ?? null,
-                    },
-                });
-            }
-            return { started: true, record, outcome };
-        }
-        catch (error) {
-            const record = this._laneTracker.complete(startedRecord.laneId, {
-                status: "failed",
-                reasonCode: "worker_delegation_error",
-            });
-            if (record)
-                this._recordWorkerTerminal(record);
-            if (record && !this.deps.isDisposed()) {
-                appendLaneRecordSnapshot(this.deps.getSessionManager(), record);
-                this.deps.emitAutonomyTelemetry({
-                    type: AUTONOMY_TELEMETRY_EVENT_TYPES.workerResult,
-                    timestamp: new Date().toISOString(),
-                    payload: {
-                        laneId: record.laneId,
-                        laneType: record.type,
-                        status: record.status,
-                        reasonCode: record.reasonCode ?? null,
-                        costUsd: record.costUsd ?? null,
-                    },
-                });
-            }
-            const message = error instanceof Error ? error.message : String(error);
-            this.deps.emit({ type: "warning", message: `Worker delegation failed: ${message}` });
-            return { started: true, record };
-        }
-        finally {
-        }
+        return this._getWorkerController().runOnce(request, onStarted, existingRecord);
     }
     /**
      * Probe a candidate model against the subagent contracts (research/worker/judge/search/
@@ -924,123 +255,16 @@ export class BackgroundLaneController {
      * spend is reported through spawned-usage accounting.
      */
     async runModelFitness(args) {
-        if (this.deps.isDisposed())
-            return { started: false, skipReason: "session_disposed" };
-        const resolved = this.resolveLaneModel(args.model.trim() || undefined);
-        if (!resolved)
-            return { started: false, skipReason: "model_unresolved_or_unauthenticated" };
-        const capability = this._laneCapabilityProfile(resolved);
-        const spent = {
-            input: 0,
-            output: 0,
-            cacheRead: 0,
-            cacheWrite: 0,
-            totalTokens: 0,
-            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-        };
-        const report = await runModelFitnessProbe({
-            trials: args.trials,
-            signal: this._researchLaneAbort.signal,
-            capacityProbe: resolved.provider === "ollama" && resolved.contextWindow > 0
-                ? { registeredContextWindow: resolved.contextWindow }
-                : undefined,
-            complete: async ({ systemPrompt, userPrompt, signal }) => {
-                const callStarted = Date.now();
-                const completion = await this.deps.runIsolatedCompletion({
-                    systemPrompt,
-                    messages: [{ role: "user", content: [{ type: "text", text: userPrompt }], timestamp: Date.now() }],
-                    model: resolved,
-                    thinkingLevel: "off",
-                    maxTokens: capability.laneMaxOutputTokens,
-                    signal,
-                    cacheRetention: "short",
-                });
-                const callMs = Date.now() - callStarted;
-                spent.input += completion.usage.input;
-                spent.output += completion.usage.output;
-                spent.cacheRead += completion.usage.cacheRead;
-                spent.cacheWrite += completion.usage.cacheWrite;
-                spent.totalTokens += completion.usage.totalTokens;
-                spent.cost.input += completion.usage.cost.input;
-                spent.cost.output += completion.usage.cost.output;
-                spent.cost.cacheRead += completion.usage.cost.cacheRead;
-                spent.cost.cacheWrite += completion.usage.cost.cacheWrite;
-                spent.cost.total += completion.usage.cost.total;
-                return {
-                    text: completion.text,
-                    costUsd: completion.usage.cost.total,
-                    stopReason: String(completion.stopReason),
-                    // Wall-clock fallback for tok/s: providers don't expose pure eval time, so the
-                    // measured call time stands in — slightly conservative (includes network/queue).
-                    outputTokens: completion.usage.output,
-                    evalMs: callMs,
-                };
-            },
-        });
-        if (!this.deps.isDisposed() && (spent.cost.total > 0 || spent.totalTokens > 0)) {
-            this.deps.addSpawnedUsage(spent, { label: "model-fitness" });
-        }
-        const modelRef = `${resolved.provider}/${resolved.id}`;
-        // Fitness is a property of a model ON a host — persist the report host-keyed so role
-        // assignments stay per-machine (a model can await better hardware without being forgotten).
-        // Best-effort: a disk problem must not fail the probe itself.
-        try {
-            if (!this.deps.isDisposed()) {
-                FitnessStore.forAgentDir(this.deps.getAgentDir()).save(modelRef, report);
-            }
-        }
-        catch {
-            // best-effort persistence
-        }
-        return { started: true, model: modelRef, report };
+        return this._fitness.run(args);
     }
-    /** Start queued local workers at the owner session's foreground-idle boundary. */
+    /** Start every capacity-eligible queued worker at the owner session's foreground-idle boundary. */
     drainQueuedWorkerDelegations() {
-        for (const [laneId, request] of [...this._queuedWorkers]) {
-            if (this._laneTracker.getRunningCount("worker") >=
-                this.deps.getSettingsManager().getWorkerDelegationSettings().maxConcurrent)
-                break;
-            const record = this._laneTracker.getRecords().find((candidate) => candidate.laneId === laneId);
-            if (!record) {
-                this._queuedWorkers.delete(laneId);
-                continue;
-            }
-            this._queuedWorkers.delete(laneId);
-            const promise = this.runWorkerDelegationOnce(request, undefined, record);
-            this._workerPromises.set(laneId, promise);
-            void promise.then((outcome) => {
-                if (!outcome.started) {
-                    const terminal = this._laneTracker.complete(laneId, {
-                        status: "canceled",
-                        reasonCode: outcome.skipReason,
-                    });
-                    if (terminal)
-                        this._recordWorkerTerminal(terminal);
-                }
-                this._workerPromises.delete(laneId);
-                if (!this.deps.isDisposed())
-                    this.drainQueuedWorkerDelegations();
-            }, () => {
-                const terminal = this._laneTracker.complete(laneId, {
-                    status: "failed",
-                    reasonCode: "worker_background_error",
-                });
-                if (terminal)
-                    this._recordWorkerTerminal(terminal);
-                this._workerPromises.delete(laneId);
-                if (!this.deps.isDisposed())
-                    this.drainQueuedWorkerDelegations();
-            });
-        }
+        if (this.deps.isDelegateToolActive?.())
+            this._getWorkerController().drain();
     }
     /** Fitness reports persisted for THIS host (measured evidence for architect/profile decisions). */
     getStoredFitnessReports() {
-        try {
-            return FitnessStore.forAgentDir(this.deps.getAgentDir()).getForHost();
-        }
-        catch {
-            return [];
-        }
+        return this._fitness.getStoredReports();
     }
 }
 //# sourceMappingURL=background-lane-controller.js.map