@caupulican/pi-adaptative 0.85.8 → 0.86.2

package/dist/core/delegation/worker-delegation-controller.js

@@ -3,6 +3,7 @@ import { getPrivateLaneDeniedPaths } from "../autonomy/lane-private-paths.js";
 import { createLaneToolSurface } from "../autonomy/lane-tool-surface.js";
 import { appendLaneRecordSnapshot } from "../autonomy/session-lane-record.js";
 import { AUTONOMY_TELEMETRY_EVENT_TYPES } from "../autonomy/telemetry-events.js";
+import { STABLE_SHELL_TOOL_NAME } from "../default-tool-surface.js";
 import { deriveModelCapabilityProfile } from "../model-capability.js";
 import { isLoopbackModelEndpoint } from "../models/model-endpoint.js";
 import { providerUsageFromAttemptUsage } from "../orchestration/attempt-usage.js";
@@ -10,10 +11,15 @@ import { SessionTaskProfileStore } from "../orchestration/session-task-profile-s
 import { TaskProfileWriter, } from "../orchestration/task-profile-writer.js";
 import { createWorkerExecutionContract, verifierWorkerExecutionContract, } from "../orchestration/worker-execution-contract.js";
 import { registerInFlightWork } from "../reload-blockers.js";
+import { createDelegateToolDefinition } from "../tools/delegate.js";
+import { disposePersistentShellSession } from "../tools/shell-session.js";
+import { wrapToolDefinition } from "../tools/tool-definition-wrapper.js";
 import { applyWorkerActions } from "./worker-actions.js";
 import { WorkerAgentControlCoordinator } from "./worker-agent-control-coordinator.js";
 import { createWorkerAttemptExecutor } from "./worker-attempt-executor.js";
+import { resolveWorkerAuthority } from "./worker-authority-resolver.js";
 import { WorkerConversationStore, } from "./worker-conversation-store.js";
+import { parseWorkerDelegationAuthorityRequest } from "./worker-delegation-request.js";
 import { WorkerDispatchScheduler } from "./worker-dispatch-scheduler.js";
 import { buildWorkerExecutionPlan, compileWorkerExecutionGrant, narrowWorkerExecutionPlan, workerExecutionAuthorityFromPlan, } from "./worker-execution-policy.js";
 import { createLocalWorkerProcessOwnerId } from "./worker-process-owner.js";
@@ -22,6 +28,7 @@ import { WorkerRecoveryCoordinator } from "./worker-recovery-coordinator.js";
 import { selectWorkerResourcePointers } from "./worker-resource-catalog.js";
 import { materializeWorkerResourceBundle } from "./worker-resource-materializer.js";
 import { finalizeWorkerClaim } from "./worker-terminal-finalizer.js";
+import { collectWorkerTreeBudgetSeeds, WorkerTreeBudgetCoordinator } from "./worker-tree-budget-coordinator.js";
 import { WorkerWriteReservationCoordinator } from "./worker-write-reservation-coordinator.js";
 export function isLocalExecutionModel(model) {
     if (model.provider === "ollama" || model.provider === "transformers" || model.provider === "llama-cpp") {
@@ -54,8 +61,11 @@ export class WorkerDelegationController {
     constructor(deps, notifications, lifecycle) {
         this.workerAbort = new AbortController();
         this.laneAbortControllers = new Map();
+        this.shellSessionKeys = new Set();
         this.publishedTerminalAttemptIds = new Set();
+        this.yieldedCapacityAttemptIds = new Set();
         this.conversations = new WorkerConversationStore();
+        this.treeBudgets = new WorkerTreeBudgetCoordinator();
         this.inFlightLedgers = new Map();
         this.deps = deps;
         this.notifications = notifications;
@@ -106,6 +116,7 @@ export class WorkerDelegationController {
                     this.publishTerminalRecord(terminal);
                 return terminal;
             },
+            yieldCapacity: (callerAgentId, targetAgentId) => this.yieldWorkerCapacity(callerAgentId, targetAgentId),
         });
         this.writeReservations = new WorkerWriteReservationCoordinator({
             agentDir: this.deps.getAgentDir(),
@@ -226,6 +237,9 @@ export class WorkerDelegationController {
         }
         this.scheduler.cancelQueued();
         this.writeReservations.dispose();
+        for (const shellSessionKey of this.shellSessionKeys)
+            disposePersistentShellSession(shellSessionKey);
+        this.shellSessionKeys.clear();
     }
     getWorkerLifecycle() {
         return this.lifecycle;
@@ -240,7 +254,6 @@ export class WorkerDelegationController {
             getResourceLoader: () => this.deps.getResourceLoader(),
             getModelRegistry: () => this.deps.getModelRegistry(),
             isModelExhausted: (model) => this.deps.isModelExhausted(model),
-            getActiveOrchestrationProfile: () => this.deps.getActiveOrchestrationProfile?.(),
             getTaskProfileStore: () => this.getTaskProfileStore(),
             onDiagnostic: (message) => this.safeWarn(message),
         });
@@ -325,6 +338,23 @@ export class WorkerDelegationController {
             ? { ok: true, shipment: resolved.resolved }
             : { ok: false, skipReason: `independent_verifier_unavailable:${resolved.reason}` };
     }
+    hasExactRecursiveCycle(parentAgentId, instructions, profileId) {
+        const normalizedInstructions = instructions.trim();
+        const visited = new Set();
+        let current = this.lifecycle.getAgent(parentAgentId);
+        while (current) {
+            if (visited.has(current.agentId))
+                return true;
+            visited.add(current.agentId);
+            const attempt = this.lifecycle.getLatestAgentAttempt(current.agentId);
+            if (attempt?.dispatch.instructions.trim() === normalizedInstructions &&
+                attempt.dispatch.profileId === profileId) {
+                return true;
+            }
+            current = current.parentAgentId ? this.lifecycle.getAgent(current.parentAgentId) : undefined;
+        }
+        return false;
+    }
     /** Single admission contract shared by enqueue, scheduler revalidation, and execution. */
     resolveWorkerAdmission(request, pinnedContract) {
         if (this.deps.isDisposed())
@@ -337,16 +367,64 @@ export class WorkerDelegationController {
         const settings = this.deps.getSettingsManager().getWorkerDelegationSettings();
         if (!settings.enabled)
             return { ok: false, skipReason: "worker_delegation_disabled" };
+        const parentAgent = request.parentAgentId ? this.lifecycle.getAgent(request.parentAgentId) : undefined;
+        if (request.parentAgentId && !parentAgent) {
+            return { ok: false, skipReason: "orchestration_parent_agent_unknown" };
+        }
+        const parentAttempt = parentAgent ? this.lifecycle.getLatestAgentAttempt(parentAgent.agentId) : undefined;
+        const parentContract = parentAttempt?.dispatch.executionContract;
+        if (parentAgent && !parentContract) {
+            return { ok: false, skipReason: "orchestration_parent_authority_missing" };
+        }
         if (pinnedContract && request.profileId && request.profileId !== pinnedContract.worker.profile.profileId) {
             return { ok: false, skipReason: "orchestration_execution_contract_mismatch" };
         }
-        const resolved = pinnedContract
-            ? this.getWorkerProfileResolver().resolveContract(pinnedContract.worker)
-            : this.resolveWorkerShipment(request, settings);
-        if (!resolved.ok) {
-            return { ok: false, skipReason: "skipReason" in resolved ? resolved.skipReason : resolved.reason };
+        let authority = request.authority;
+        if (!pinnedContract && authority) {
+            try {
+                authority = parseWorkerDelegationAuthorityRequest(authority);
+            }
+            catch (error) {
+                return {
+                    ok: false,
+                    skipReason: `orchestration_authority_invalid:${error instanceof Error ? error.message : String(error)}`,
+                };
+            }
+        }
+        let baseShipment;
+        if (pinnedContract) {
+            const pinned = this.getWorkerProfileResolver().resolveContract(pinnedContract.worker);
+            if (!pinned.ok)
+                return { ok: false, skipReason: pinned.reason };
+            baseShipment = pinned.resolved;
+        }
+        else if (!request.profileId && parentContract) {
+            const inherited = this.getWorkerProfileResolver().resolveContract(parentContract.worker);
+            if (!inherited.ok)
+                return { ok: false, skipReason: inherited.reason };
+            baseShipment = inherited.resolved;
+        }
+        else if (request.profileId || settings.orchestrationProfile) {
+            const configured = this.resolveWorkerShipment(request, settings);
+            if (!configured.ok)
+                return configured;
+            baseShipment = configured.shipment;
+        }
+        const adaptive = pinnedContract
+            ? { ok: true, shipment: baseShipment }
+            : resolveWorkerAuthority({
+                authority,
+                ...(baseShipment ? { base: baseShipment } : {}),
+                ...(this.deps.getModel() ? { foregroundModel: this.deps.getModel() } : {}),
+                modelRegistry: this.deps.getModelRegistry(),
+                isModelExhausted: (model) => this.deps.isModelExhausted(model),
+            });
+        if (!adaptive.ok)
+            return { ok: false, skipReason: adaptive.reason };
+        const shipment = adaptive.shipment;
+        if (parentAgent && this.hasExactRecursiveCycle(parentAgent.agentId, instructions, shipment.profile.profileId)) {
+            return { ok: false, skipReason: "recursive_delegation_cycle" };
         }
-        const shipment = "shipment" in resolved ? resolved.shipment : resolved.resolved;
         if (request.verificationOfTaskId && shipment.profile.role !== "verifier") {
             return { ok: false, skipReason: "verification_profile_role_mismatch" };
         }
@@ -380,9 +458,10 @@ export class WorkerDelegationController {
             : shipment.resourcePointers.map((pointer) => pointer.id));
         if (!selectedResources.ok)
             return { ok: false, skipReason: selectedResources.reason };
-        const currentExecutionPlan = this.buildWorkerExecutionPlan(shipment.profile, settings);
-        const executionPlan = pinnedContract
-            ? narrowWorkerExecutionPlan(pinnedContract.worker.authority, currentExecutionPlan)
+        const currentExecutionPlan = this.buildWorkerExecutionPlan(shipment.profile, settings, adaptive.requestedReadPaths, adaptive.requestedWritePaths);
+        const inheritedAuthority = pinnedContract?.worker.authority ?? parentContract?.worker.authority;
+        const executionPlan = inheritedAuthority
+            ? narrowWorkerExecutionPlan(inheritedAuthority, currentExecutionPlan)
             : currentExecutionPlan;
         const executionContract = pinnedContract ??
             createWorkerExecutionContract({
@@ -428,10 +507,37 @@ export class WorkerDelegationController {
         };
     }
     publishTerminalRecord(record) {
-        const attemptId = this.lifecycle?.getActiveAttempt(record.laneId)?.attemptId;
+        const attempt = this.lifecycle?.getActiveAttempt(record.laneId);
+        const attemptId = attempt?.attemptId;
         if (attemptId && this.publishedTerminalAttemptIds.has(attemptId))
             return;
-        this.recordTerminal(record);
+        const childAgentId = attempt?.agentId ?? attempt?.dispatch.logicalLaneId ?? record.laneId;
+        const parentAgentId = this.lifecycle.getAgent(childAgentId)?.parentAgentId ?? attempt?.dispatch.parentAgentId;
+        let handedOffToParent = false;
+        if (attemptId && parentAgentId) {
+            try {
+                this.agentControl.deliverWorkerTerminalHandoff({
+                    parentAgentId,
+                    childAgentId,
+                    terminalAttemptId: attemptId,
+                    record,
+                });
+                handedOffToParent = true;
+            }
+            catch (error) {
+                this.safeWarn(`Worker terminal handoff for ${record.laneId} failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        if (handedOffToParent) {
+            const notification = this.lifecycle.getTerminalNotification(record.laneId);
+            if (notification?.status === "pending") {
+                this.lifecycle.markNotificationsDelivered([notification.notificationId]);
+            }
+            this.notifications.statusChanged();
+        }
+        else {
+            this.recordTerminal(record);
+        }
         appendLaneRecordSnapshot(this.deps.getSessionManager(), record);
         this.deps.emitAutonomyTelemetry({
             type: AUTONOMY_TELEMETRY_EVENT_TYPES.workerTerminal,
@@ -444,6 +550,7 @@ export class WorkerDelegationController {
                 costUsd: record.costUsd ?? null,
             },
         });
+        this.agentControl.signalStateChanged();
         if (attemptId)
             this.publishedTerminalAttemptIds.add(attemptId);
     }
@@ -459,18 +566,44 @@ export class WorkerDelegationController {
             this.publishTerminalRecord(record);
         return record;
     }
-    hasWorkerCapacity(settings, profile) {
-        const lifecycle = this.getWorkerLifecycle();
-        if (lifecycle.getRunningCount() >= settings.maxConcurrent)
-            return false;
-        return lifecycle.getRunningCount(profile.profileId) < profile.maxConcurrent;
+    hasWorkerCapacity(settings) {
+        const snapshot = this.getWorkerLifecycle().getTaskRuntimeSnapshot();
+        let yielded = 0;
+        for (const attemptId of [...this.yieldedCapacityAttemptIds]) {
+            const status = snapshot.attempts[attemptId]?.status;
+            if (status === "leased" || status === "running")
+                yielded += 1;
+            else
+                this.yieldedCapacityAttemptIds.delete(attemptId);
+        }
+        return Math.max(0, this.getWorkerLifecycle().getRunningCount() - yielded) < settings.maxConcurrent;
+    }
+    yieldWorkerCapacity(callerAgentId, targetAgentId) {
+        const caller = this.lifecycle.getAgent(callerAgentId);
+        const target = this.lifecycle.getAgent(targetAgentId);
+        if (!caller || !target || caller.rootAgentId !== target.rootAgentId)
+            return () => undefined;
+        const attempt = this.lifecycle.getLatestAgentAttempt(caller.agentId);
+        if (!attempt || (attempt.status !== "leased" && attempt.status !== "running"))
+            return () => undefined;
+        this.yieldedCapacityAttemptIds.add(attempt.attemptId);
+        this.scheduler.drain();
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            this.yieldedCapacityAttemptIds.delete(attempt.attemptId);
+            if (!this.deps.isDisposed())
+                this.scheduler.drain();
+        };
     }
     workerDispatchAdmission(request, record) {
         const contract = this.getWorkerLifecycle().getActiveAttempt(record.laneId)?.dispatch.executionContract;
         const admission = this.resolveWorkerAdmission(request, contract);
         if (!admission.ok)
             return { action: "cancel", reasonCode: admission.skipReason };
-        if (!this.hasWorkerCapacity(admission.settings, admission.shipment.profile))
+        if (!this.hasWorkerCapacity(admission.settings))
             return { action: "wait", reason: "capacity" };
         const attempt = this.getWorkerLifecycle().getActiveAttempt(record.laneId);
         if (!attempt)
@@ -480,7 +613,7 @@ export class WorkerDelegationController {
             return { action: "cancel", reasonCode: reservation.reasonCode };
         return reservation.kind === "granted" ? { action: "start" } : { action: "wait", reason: "write_reservation" };
     }
-    buildWorkerExecutionPlan(profile, settings) {
+    buildWorkerExecutionPlan(profile, settings, requestedReadPaths, requestedWritePaths) {
         return buildWorkerExecutionPlan({
             profile,
             settings,
@@ -488,6 +621,8 @@ export class WorkerDelegationController {
             deniedPaths: getPrivateLaneDeniedPaths(this.deps.getCwd(), this.deps.getAgentDir()),
             foregroundMaxCostUsd: this.deps.getCapabilityEnvelope()?.maxEstimatedUsd,
             memoryEnabled: this.deps.getSettingsManager().getMemoryRetrievalSettings().enabled,
+            ...(requestedReadPaths ? { requestedReadPaths } : {}),
+            ...(requestedWritePaths ? { requestedWritePaths } : {}),
         });
     }
     /** One durable preparation path for queued, immediate, and recovered execution. */
@@ -504,6 +639,7 @@ export class WorkerDelegationController {
         const goal = this.deps.getGoalStateSnapshot();
         const prepared = lifecycle.prepare({
             instructions: admission.instructions,
+            ...(request.parentAgentId ? { parentAgentId: request.parentAgentId } : {}),
             executionContract: admission.executionContract,
             requiredCapabilities: admission.executionPlan.requiredCapabilities,
             ...(request.verificationOfTaskId ? { verificationOfTaskId: request.verificationOfTaskId } : {}),
@@ -517,6 +653,57 @@ export class WorkerDelegationController {
         });
         return { executionPlan: admission.executionPlan, lifecycle, ...prepared };
     }
+    ensurePreparedAgent(prepared, admission) {
+        if (!prepared.attempt)
+            throw new Error("Prepared worker attempt is missing.");
+        const immutableWorker = prepared.attempt.dispatch.executionContract?.worker;
+        if (!immutableWorker)
+            throw new Error("Prepared worker execution contract is missing.");
+        const agentId = prepared.attempt.agentId ?? prepared.attempt.dispatch.logicalLaneId ?? prepared.record.laneId;
+        const existing = prepared.lifecycle.getAgent(agentId);
+        if (existing) {
+            const conversation = this.conversations.open({
+                agentDir: this.deps.getAgentDir(),
+                resumeContext: existing.resumeContext,
+                expectedLogicalAgentId: existing.agentId,
+            });
+            const materialized = materializeWorkerResourceBundle(existing.resumeContext.contextPointers);
+            if (!materialized.ok)
+                throw new Error(`worker_resource_materialization_${materialized.code}`);
+            return {
+                conversation,
+                resources: materialized.pointers,
+                resourceSystemPrompt: materialized.systemPrompt,
+            };
+        }
+        const selected = selectWorkerResourcePointers(immutableWorker.resourcePointers, admission.resourcePointerIds);
+        if (!selected.ok)
+            throw new Error(selected.reason);
+        const materialized = materializeWorkerResourceBundle(selected.pointers);
+        if (!materialized.ok)
+            throw new Error(`worker_resource_materialization_${materialized.code}`);
+        const conversation = this.conversations.ensure({
+            agentDir: this.deps.getAgentDir(),
+            parentSessionId: this.deps.getSessionId(),
+            logicalAgentId: agentId,
+            cwd: this.deps.getCwd(),
+            orchestrationProfileId: immutableWorker.profile.profileId,
+            modelRef: `${immutableWorker.modelBinding.provider}/${immutableWorker.modelBinding.modelId}`,
+            resourceProfileNames: immutableWorker.profile.resourceProfileNames,
+            contextPointers: materialized.pointers,
+        });
+        prepared.lifecycle.ensureAgent({
+            agentId,
+            ...(prepared.attempt.dispatch.parentAgentId ? { parentAgentId: prepared.attempt.dispatch.parentAgentId } : {}),
+            role: immutableWorker.profile.role,
+            resumeContext: conversation.getResumeContext(),
+        });
+        return {
+            conversation,
+            resources: materialized.pointers,
+            resourceSystemPrompt: materialized.systemPrompt,
+        };
+    }
     start(request) {
         return this.startInternal(request);
     }
@@ -529,21 +716,24 @@ export class WorkerDelegationController {
         const { settings, shipment } = admission;
         const foreground = this.deps.getModel();
         const contendsWithLocalForeground = foreground !== undefined && isLocalExecutionModel(foreground) && isLocalExecutionModel(shipment.model);
-        if (contendsWithLocalForeground || !this.hasWorkerCapacity(settings, shipment.profile)) {
+        if (contendsWithLocalForeground || !this.hasWorkerCapacity(settings)) {
             // A mandatory verifier is the continuation of an already admitted implementation, not a
             // new owner request. Reserve its queue admission so a burst of ordinary work cannot strand
             // the subject behind `independent_verification_required` with no terminal handoff.
-            if (this.scheduler.queuedCount >= 8 && !request.verificationOfTaskId) {
-                return { started: false, skipReason: "worker_delegation_queue_full" };
-            }
             let record;
             try {
-                record = this.prepareWorkerAttempt(request, admission).record;
+                const prepared = this.prepareWorkerAttempt(request, admission);
+                record = prepared.record;
+                this.ensurePreparedAgent(prepared, admission);
             }
             catch (error) {
+                if (record)
+                    this.cancelAndPublish(this.lifecycle, record.laneId, "worker_conversation_unavailable");
                 this.safeWarn(`Worker dispatch was not persisted: ${error instanceof Error ? error.message : String(error)}`);
                 return { started: false, skipReason: "orchestration_ledger_error" };
             }
+            if (!record)
+                return { started: false, skipReason: "orchestration_attempt_missing" };
             this.scheduler.enqueue(record, { ...request, profileId: shipment.profile.profileId }, false, request.verificationOfTaskId !== undefined);
             this.notifications.statusChanged();
             return { started: true, record };
@@ -575,7 +765,7 @@ export class WorkerDelegationController {
             this.recovery.recover();
         const { instructions, settings, verifierShipment } = admission;
         const { model, modelBinding, profile: orchestrationProfile, soul } = admission.shipment;
-        if (!this.hasWorkerCapacity(settings, orchestrationProfile)) {
+        if (!this.hasWorkerCapacity(settings)) {
             return { started: false, skipReason: "worker_delegation_already_running" };
         }
         const laneCapability = this.laneCapabilityProfile(model);
@@ -584,42 +774,31 @@ export class WorkerDelegationController {
         const { executionPlan, lifecycle } = prepared;
         if (!prepared.attempt)
             return { started: false, skipReason: "orchestration_attempt_missing" };
+        let preparedAgent;
+        try {
+            preparedAgent = this.ensurePreparedAgent(prepared, admission);
+        }
+        catch (error) {
+            this.cancelAndPublish(lifecycle, prepared.record.laneId, "worker_conversation_unavailable");
+            this.safeWarn(`Worker conversation setup failed: ${error instanceof Error ? error.message : String(error)}`);
+            return { started: false, skipReason: "worker_conversation_unavailable" };
+        }
         const durableTask = lifecycle.getTask(prepared.record.laneId);
         if (!durableTask)
             return { started: false, skipReason: "orchestration_task_missing" };
         const immutableWorker = prepared.attempt.dispatch.executionContract?.worker;
         if (!immutableWorker)
             return { started: false, skipReason: "orchestration_execution_contract_missing" };
-        const selectedResources = selectWorkerResourcePointers(immutableWorker.resourcePointers, prepared.attempt.dispatch.resourcePointerIds.length > 0
-            ? prepared.attempt.dispatch.resourcePointerIds
-            : admission.resourcePointerIds);
-        if (!selectedResources.ok) {
-            this.cancelAndPublish(lifecycle, prepared.record.laneId, selectedResources.reason);
-            return { started: false, skipReason: selectedResources.reason };
-        }
         let grant;
-        let workerResourceSystemPrompt;
+        const workerResourceSystemPrompt = preparedAgent.resourceSystemPrompt;
         if (prepared.attempt.grant) {
-            if (!this.recovery.durableGrantIsStillPermitted(prepared.attempt.grant, executionPlan, selectedResources.pointers)) {
+            if (!this.recovery.durableGrantIsStillPermitted(prepared.attempt.grant, executionPlan, preparedAgent.resources)) {
                 this.cancelAndPublish(lifecycle, prepared.record.laneId, "recovered_grant_revoked");
                 return { started: false, skipReason: "recovered_grant_revoked" };
             }
             grant = prepared.attempt.grant;
-            const materialized = materializeWorkerResourceBundle(grant.resources);
-            if (!materialized.ok) {
-                const reason = `worker_resource_materialization_${materialized.code}`;
-                this.cancelAndPublish(lifecycle, prepared.record.laneId, reason);
-                return { started: false, skipReason: reason };
-            }
-            workerResourceSystemPrompt = materialized.systemPrompt;
         }
         else {
-            const materialized = materializeWorkerResourceBundle(selectedResources.pointers);
-            if (!materialized.ok) {
-                const reason = `worker_resource_materialization_${materialized.code}`;
-                this.cancelAndPublish(lifecycle, prepared.record.laneId, reason);
-                return { started: false, skipReason: reason };
-            }
             const compiled = compileWorkerExecutionGrant({
                 target: {
                     objectiveId: durableTask.task.objectiveId,
@@ -628,7 +807,7 @@ export class WorkerDelegationController {
                 },
                 profile: orchestrationProfile,
                 plan: executionPlan,
-                resources: materialized.pointers,
+                resources: preparedAgent.resources,
             });
             if (!compiled.ok) {
                 this.cancelAndPublish(lifecycle, prepared.record.laneId, compiled.reasonCodes.join(","));
@@ -636,7 +815,6 @@ export class WorkerDelegationController {
             }
             lifecycle.bindGrant(prepared.attempt.attemptId, compiled.grant);
             grant = compiled.grant;
-            workerResourceSystemPrompt = materialized.systemPrompt;
         }
         const immutableProfile = immutableWorker.profile;
         // Follow-up tasks deliberately receive unique task ids while retaining the original logical
@@ -647,44 +825,9 @@ export class WorkerDelegationController {
             this.cancelAndPublish(lifecycle, prepared.record.laneId, "orchestration_agent_missing");
             return { started: false, skipReason: "orchestration_agent_missing" };
         }
-        let conversation;
-        try {
-            if (registeredAgent) {
-                // Recovery must trust only the registered resume context; reconstructing one here could
-                // silently redirect a logical worker to a different transcript or resource scope.
-                conversation = this.conversations.open({
-                    agentDir: this.deps.getAgentDir(),
-                    resumeContext: registeredAgent.resumeContext,
-                    expectedLogicalAgentId: registeredAgent.agentId,
-                });
-                if (prepared.attempt.status === "suspended")
-                    this.recovery.repairInterruptedToolResults(conversation);
-            }
-            else {
-                conversation = this.conversations.ensure({
-                    agentDir: this.deps.getAgentDir(),
-                    parentSessionId: this.deps.getSessionId(),
-                    logicalAgentId: agentId,
-                    cwd: this.deps.getCwd(),
-                    orchestrationProfileId: immutableProfile.profileId,
-                    modelRef: `${prepared.attempt.dispatch.executionContract.worker.modelBinding.provider}/${prepared.attempt.dispatch.executionContract.worker.modelBinding.modelId}`,
-                    resourceProfileNames: immutableProfile.resourceProfileNames,
-                    contextPointers: grant.resources,
-                });
-                lifecycle.ensureAgent({
-                    agentId,
-                    role: immutableProfile.role,
-                    resumeContext: conversation.getResumeContext(),
-                });
-            }
-        }
-        catch (error) {
-            if (prepared.attempt.status !== "suspended") {
-                this.cancelAndPublish(lifecycle, prepared.record.laneId, "worker_conversation_unavailable");
-            }
-            this.safeWarn(`Worker conversation setup failed: ${error instanceof Error ? error.message : String(error)}`);
-            return { started: false, skipReason: "worker_conversation_unavailable" };
-        }
+        const conversation = preparedAgent.conversation;
+        if (prepared.attempt.status === "suspended")
+            this.recovery.repairInterruptedToolResults(conversation);
         const reservation = this.writeReservations.acquire(prepared.record.laneId, prepared.attempt, executionPlan);
         if (reservation.kind === "denied") {
             this.cancelAndPublish(lifecycle, prepared.record.laneId, reservation.reasonCode);
@@ -727,6 +870,31 @@ export class WorkerDelegationController {
         onStarted?.(startedRecord);
         const maxUsd = grant.budget.maxCostUsd;
         const executionPolicy = orchestrationProfile.executionPolicy;
+        const recursiveDelegateTool = wrapToolDefinition(createDelegateToolDefinition({
+            startWorkerDelegation: (childRequest) => this.start({ ...childRequest, parentAgentId: agentId }),
+            runWorkerDelegation: (childRequest) => this.runOnce({ ...childRequest, parentAgentId: agentId }),
+            orchestrationProfiles: this.getProfileCatalog(),
+            workerAgentControl: this.agentControl,
+            callerAgentId: agentId,
+        }));
+        const agentBinding = lifecycle.getAgent(agentId);
+        if (!agentBinding) {
+            this.cancelAndPublish(lifecycle, prepared.record.laneId, "orchestration_agent_missing");
+            return { started: false, skipReason: "orchestration_agent_missing" };
+        }
+        const rootAttempt = lifecycle.getLatestAgentAttempt(agentBinding.rootAgentId);
+        const rootBudget = rootAttempt?.dispatch.executionContract?.worker.authority.budget ?? grant.budget;
+        const sharedBudget = this.treeBudgets.createPort({
+            rootAgentId: agentBinding.rootAgentId,
+            attemptId: durableHandle.attemptId,
+            budget: rootBudget,
+            seeds: collectWorkerTreeBudgetSeeds(lifecycle.getTaskRuntimeSnapshot(), agentBinding.rootAgentId),
+            initialUsage,
+        });
+        const shellGranted = executionPlan.toolManifests.some((manifest) => manifest.toolName === STABLE_SHELL_TOOL_NAME);
+        const shellSessionKey = shellGranted ? `worker:${this.deps.getSessionId()}:${agentId}` : undefined;
+        if (shellSessionKey)
+            this.shellSessionKeys.add(shellSessionKey);
         const toolSurface = createLaneToolSurface({
             cwd: this.deps.getCwd(),
             readMemory: executionPlan.readMemory ? (query) => this.deps.readMemoryForLane(query) : undefined,
@@ -734,9 +902,12 @@ export class WorkerDelegationController {
             writePaths: executionPlan.writePaths,
             ...(executionPlan.processEnabled && executionPolicy ? { executionPolicy } : {}),
             processMaxWallClockMs: grant.budget.maxWallClockMs ?? 0,
+            ...(shellSessionKey ? { shellSessionKey } : {}),
             grant,
             toolManifests: executionPlan.toolManifests,
+            additionalTools: [recursiveDelegateTool],
             initialUsage,
+            sharedBudget,
         });
         const writeGranted = executionPlan.writeEnabled &&
             toolSurface.gateway !== undefined &&
@@ -1010,6 +1181,8 @@ export class WorkerDelegationController {
             }
             this.agentControl.signalStateChanged();
             deregisterInFlight();
+            if (!this.deps.isDisposed())
+                this.scheduler.drain(true);
         }
     }
     /** Start every capacity-eligible queued worker at the owner session's foreground-idle boundary. */