@caupulican/pi-adaptative 0.90.2 → 0.90.5

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

@@ -14,6 +14,7 @@ import { MAX_ORCHESTRATION_DISPATCH_INSTRUCTIONS_LENGTH, } from "../orchestratio
 import { SessionTaskProfileStore } from "../orchestration/session-task-profile-store.js";
 import { TaskProfileWriter, } from "../orchestration/task-profile-writer.js";
 import { createWorkerExecutionContract, verifierWorkerExecutionContract, } from "../orchestration/worker-execution-contract.js";
+import { resolveWorkerModelPin } from "../orchestration/worker-model-pins.js";
 import { registerInFlightWork } from "../reload-blockers.js";
 import { createDelegateToolDefinition } from "../tools/delegate.js";
 import { disposePersistentShellSession } from "../tools/shell-session.js";
@@ -29,16 +30,17 @@ 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 { DEFAULT_WORKER_FLEET_LIMITS, evaluateNewWorkerAdmission, pendingVerifierSubjectTaskIds, } from "./worker-fleet-limits.js";
+import { DEFAULT_WORKER_FLEET_LIMITS, evaluateNewWorkerAdmission, intersectWorkerDelegationLimits, pendingVerifierSubjectTaskIds, resolveWorkerFleetLimits, } from "./worker-fleet-limits.js";
+import { WorkerLeaseHeartbeat } from "./worker-lease-heartbeat.js";
 import { createLocalWorkerProcessOwnerId } from "./worker-process-owner.js";
-import { WorkerProfileResolver } from "./worker-profile-resolver.js";
+import { WorkerProfileResolver, } from "./worker-profile-resolver.js";
 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 { WorkerTerminalHandoffCoordinator, } from "./worker-terminal-handoff-coordinator.js";
 import { collectWorkerTreeBudgetSeeds, WorkerTreeBudgetCoordinator } from "./worker-tree-budget-coordinator.js";
-import { WorkerWriteReservationCoordinator } from "./worker-write-reservation-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") {
         return true;
@@ -82,6 +84,7 @@ export class WorkerDelegationController {
         this.shellSessionKeys = new Set();
         this.publishedTerminalAttemptIds = new Set();
         this.yieldedCapacityAttemptIds = new Map();
+        this.yieldedWriteReservations = new Map();
         this.conversations = new WorkerConversationStore();
         this.treeBudgets = new WorkerTreeBudgetCoordinator();
         this.inFlightLedgers = new Map();
@@ -150,7 +153,8 @@ export class WorkerDelegationController {
                     ? this.workerProjectionHeadroomSkipReason(contract)
                     : "orchestration_execution_contract_missing";
             },
-            yieldCapacity: (callerAgentId, targetAgentId) => this.yieldWorkerCapacity(callerAgentId, targetAgentId),
+            waitBlockedByCaller: (callerAgentId, targetAgentIds) => this.waitTargetsBlockedByCaller(callerAgentId, targetAgentIds),
+            yieldCallerForWait: (callerAgentId) => this.yieldWorkerForWait(callerAgentId),
             warn: (message) => this.safeWarn(message),
         });
         this.terminalHandoffs = new WorkerTerminalHandoffCoordinator({
@@ -166,8 +170,10 @@ export class WorkerDelegationController {
             getParentSessionId: () => this.deps.getSessionId(),
             ownerId: this.agentControl.getProcessOwnerId(),
             drainQueuedWorkers: () => {
-                if (!this.deps.isDisposed())
-                    this.scheduler.drain(true);
+                if (this.deps.isDisposed())
+                    return;
+                this.scheduler.drain(true);
+                this.agentControl.signalStateChanged();
             },
             warn: (message) => this.safeWarn(message),
         });
@@ -427,20 +433,27 @@ export class WorkerDelegationController {
     createTaskProfile(input) {
         return this.getTaskProfileWriter().createTaskProfile(input);
     }
-    resolveWorkerShipment(request, settings) {
-        const resolved = this.getWorkerProfileResolver().resolve(request, settings.orchestrationProfile);
-        return resolved.ok ? { ok: true, shipment: resolved.resolved } : { ok: false, skipReason: resolved.reason };
+    resolveWorkerPreset(request, settings) {
+        const resolved = this.getWorkerProfileResolver().resolvePreset(request, settings.orchestrationProfile);
+        return resolved.ok ? { ok: true, preset: resolved.resolved } : { ok: false, skipReason: resolved.reason };
     }
-    resolveRequiredVerifier(profile) {
+    resolveRequiredVerifier(profile, modelPinPolicy) {
         if (!profile.requireIndependentVerification)
             return { ok: true };
-        const resolved = this.getWorkerProfileResolver().resolveVerifier(profile);
-        if (!resolved.ok)
-            return { ok: false, skipReason: `independent_verifier_unavailable:${resolved.reason}` };
+        const preset = this.getWorkerProfileResolver().resolveVerifierPreset(profile);
+        if (!preset.ok)
+            return { ok: false, skipReason: `independent_verifier_unavailable:${preset.reason}` };
+        const modelPin = resolveWorkerModelPin(modelPinPolicy, "verifier");
+        const resolved = this.getWorkerProfileResolver().bindPreset(preset.resolved, modelPin?.binding);
+        if (!resolved.ok) {
+            const reason = modelPin ? "worker_model_pin_unavailable:verifier" : resolved.reason;
+            return { ok: false, skipReason: `independent_verifier_unavailable:${reason}` };
+        }
         // Fresh verifier profiles pass through the same shipment admission owner as fresh workers.
         // Recovery-pinned verifier contracts bypass this path and preserve their immutable grant.
         const admitted = resolveWorkerAuthority({
             base: resolved.resolved,
+            ...(modelPin ? { modelPin: modelPin.binding } : {}),
             modelRegistry: this.deps.getModelRegistry(),
             isModelExhausted: (model) => this.deps.isModelExhausted(model),
         });
@@ -449,9 +462,10 @@ export class WorkerDelegationController {
             : { ok: false, skipReason: `independent_verifier_unavailable:${admitted.reason}` };
     }
     /**
-     * A descendant may select a different routing profile, but that preset cannot introduce context
-     * its ancestor never admitted. Pointer ids alone are insufficient authority: retain only pointers
-     * whose complete immutable metadata matches the ancestral contract, and require exact soul text.
+     * A descendant may select a different routing profile, but that preset cannot introduce context or
+     * recursive authority its ancestor never admitted. Pointer ids alone are insufficient authority:
+     * retain only pointers whose complete immutable metadata matches the ancestral contract, require
+     * exact soul text, and intersect durable delegation limits.
      */
     narrowWorkerShipmentContext(shipment, boundary) {
         const boundaryPointers = new Map(boundary.resourcePointers.map((pointer) => [pointer.id, pointer]));
@@ -466,10 +480,15 @@ export class WorkerDelegationController {
         if (shipment.soul !== undefined && shipment.soul !== boundary.soul) {
             return { ok: false, skipReason: "orchestration_context_authority_exceeded" };
         }
+        const delegationLimits = intersectWorkerDelegationLimits(shipment.profile.delegationLimits, boundary.profile.delegationLimits);
         return {
             ok: true,
             shipment: {
                 ...shipment,
+                profile: {
+                    ...shipment.profile,
+                    ...(delegationLimits ? { delegationLimits } : {}),
+                },
                 resourcePointers,
                 ...(shipment.soul ? { soul: shipment.soul } : {}),
             },
@@ -494,7 +513,11 @@ export class WorkerDelegationController {
     }
     /** Reject a new logical identity before creating its task, transcript, agent, or queue entry. */
     newWorkerFleetSkipReason(request, requiredAgentSlots = 1) {
-        const decision = evaluateNewWorkerAdmission(this.lifecycle.getTaskRuntimeSnapshot().agents, request.parentAgentId, DEFAULT_WORKER_FLEET_LIMITS, requiredAgentSlots);
+        const parentAttempt = request.parentAgentId
+            ? this.lifecycle.getLatestAgentAttempt(request.parentAgentId)
+            : undefined;
+        const limits = resolveWorkerFleetLimits(parentAttempt?.dispatch.executionContract?.worker.profile.delegationLimits);
+        const decision = evaluateNewWorkerAdmission(this.lifecycle.getTaskRuntimeSnapshot().agents, request.parentAgentId, limits, requiredAgentSlots);
         return decision.ok ? undefined : decision.reasonCode;
     }
     requiredAgentSlotsForAdmission(request, admission) {
@@ -515,6 +538,12 @@ export class WorkerDelegationController {
         const settings = this.deps.getSettingsManager().getWorkerDelegationSettings();
         if (!settings.enabled)
             return { ok: false, skipReason: "worker_delegation_disabled" };
+        const modelPinPolicy = pinnedContract
+            ? { status: "absent" }
+            : this.deps.getSettingsManager().getWorkerModelPinPolicy();
+        if (modelPinPolicy.status === "invalid") {
+            return { ok: false, skipReason: "worker_model_pins_invalid" };
+        }
         const parentAgent = request.parentAgentId ? this.lifecycle.getAgent(request.parentAgentId) : undefined;
         if (request.parentAgentId && !parentAgent) {
             return { ok: false, skipReason: "orchestration_parent_agent_unknown" };
@@ -540,6 +569,7 @@ export class WorkerDelegationController {
             }
         }
         let baseShipment;
+        let basePreset;
         if (pinnedContract) {
             const pinned = this.getWorkerProfileResolver().resolveContract(pinnedContract.worker);
             if (!pinned.ok)
@@ -553,22 +583,41 @@ export class WorkerDelegationController {
             baseShipment = inherited.resolved;
         }
         else if (request.profileId || settings.orchestrationProfile) {
-            const configured = this.resolveWorkerShipment(request, settings);
+            const configured = this.resolveWorkerPreset(request, settings);
             if (!configured.ok)
                 return configured;
-            baseShipment = configured.shipment;
+            basePreset = configured.preset;
+        }
+        const effectiveRole = authority?.role ?? baseShipment?.profile.role ?? basePreset?.profile.role ?? "orchestrator";
+        const modelPin = resolveWorkerModelPin(modelPinPolicy, effectiveRole);
+        if (basePreset) {
+            const bound = this.getWorkerProfileResolver().bindPreset(basePreset, modelPin?.binding);
+            if (!bound.ok) {
+                return {
+                    ok: false,
+                    skipReason: modelPin ? `worker_model_pin_unavailable:${effectiveRole}` : bound.reason,
+                };
+            }
+            baseShipment = bound.resolved;
         }
         const adaptive = pinnedContract
             ? { ok: true, shipment: baseShipment }
             : resolveWorkerAuthority({
                 authority,
                 ...(baseShipment ? { base: baseShipment } : {}),
+                ...(modelPin ? { modelPin: modelPin.binding } : {}),
                 ...(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 };
+        if (!adaptive.ok) {
+            return {
+                ok: false,
+                skipReason: modelPin && adaptive.reason === "orchestration_model_unavailable"
+                    ? `worker_model_pin_unavailable:${effectiveRole}`
+                    : adaptive.reason,
+            };
+        }
         let shipment = adaptive.shipment;
         if (parentContract) {
             const narrowed = this.narrowWorkerShipmentContext(shipment, parentContract.worker);
@@ -594,7 +643,7 @@ export class WorkerDelegationController {
             verifierShipment = verifier.resolved;
         }
         else {
-            const verifier = this.resolveRequiredVerifier(shipment.profile);
+            const verifier = this.resolveRequiredVerifier(shipment.profile, modelPinPolicy);
             if (!verifier.ok)
                 return verifier;
             verifierShipment = verifier.shipment;
@@ -829,37 +878,89 @@ export class WorkerDelegationController {
             const status = snapshot.attempts[attemptId]?.status;
             if (status === "leased" || status === "running")
                 yielded += 1;
-            else
+            else {
                 this.yieldedCapacityAttemptIds.delete(attemptId);
+                this.yieldedWriteReservations.delete(attemptId);
+            }
         }
         return Math.max(0, this.getWorkerLifecycle().getRunningCount() - yielded) < settings.maxConcurrent;
     }
-    yieldWorkerCapacity(callerAgentId, targetAgentId) {
+    waitTargetsBlockedByCaller(callerAgentId, targetAgentIds) {
         const caller = this.lifecycle.getAgent(callerAgentId);
-        const target = this.lifecycle.getAgent(targetAgentId);
-        if (!caller || !target || caller.rootAgentId !== target.rootAgentId)
-            return () => undefined;
+        const callerAttempt = caller ? this.lifecycle.getLatestAgentAttempt(caller.agentId) : undefined;
+        if (!callerAttempt || (callerAttempt.status !== "leased" && callerAttempt.status !== "running"))
+            return [];
+        const blockedAgentIds = [];
+        for (const targetAgentId of targetAgentIds) {
+            const target = this.lifecycle.getAgent(targetAgentId);
+            const targetAttempt = target ? this.lifecycle.getLatestAgentAttempt(target.agentId) : undefined;
+            if (targetAttempt?.status === "queued" &&
+                this.writeReservations.isBlockedBy(targetAttempt.taskId, callerAttempt.taskId)) {
+                blockedAgentIds.push(targetAgentId);
+            }
+        }
+        return blockedAgentIds;
+    }
+    yieldWorkerForWait(callerAgentId) {
+        const caller = this.lifecycle.getAgent(callerAgentId);
+        if (!caller)
+            return () => true;
         const attempt = this.lifecycle.getLatestAgentAttempt(caller.agentId);
         if (!attempt || (attempt.status !== "leased" && attempt.status !== "running"))
-            return () => undefined;
-        this.yieldedCapacityAttemptIds.set(attempt.attemptId, (this.yieldedCapacityAttemptIds.get(attempt.attemptId) ?? 0) + 1);
-        this.scheduler.drain();
-        let released = false;
-        return () => {
-            if (released)
-                return;
-            released = true;
+            return () => true;
+        const existingYields = this.yieldedCapacityAttemptIds.get(attempt.attemptId) ?? 0;
+        if (existingYields === 0 && attempt.lease) {
+            const yieldedReservation = this.writeReservations.yieldForWait(attempt.taskId, attempt.attemptId, attempt.lease.fencingToken);
+            if (yieldedReservation)
+                this.yieldedWriteReservations.set(attempt.attemptId, yieldedReservation);
+        }
+        this.yieldedCapacityAttemptIds.set(attempt.attemptId, existingYields + 1);
+        let restored = false;
+        const restore = () => {
+            if (restored)
+                return true;
             const leases = this.yieldedCapacityAttemptIds.get(attempt.attemptId);
-            if (leases === undefined)
-                return;
+            if (leases === undefined) {
+                restored = true;
+                return true;
+            }
             if (leases > 1) {
                 this.yieldedCapacityAttemptIds.set(attempt.attemptId, leases - 1);
-                return;
+                restored = true;
+                return true;
+            }
+            const current = this.lifecycle.getLatestAgentAttempt(caller.agentId);
+            if (!this.deps.isDisposed() &&
+                current?.attemptId === attempt.attemptId &&
+                (current.status === "leased" || current.status === "running")) {
+                const yieldedReservation = this.yieldedWriteReservations.get(attempt.attemptId);
+                if (yieldedReservation) {
+                    const reservation = this.writeReservations.restoreAfterWait(yieldedReservation);
+                    if (reservation.kind === "blocked")
+                        return false;
+                    if (reservation.kind === "denied") {
+                        this.laneAbortControllers.get(attempt.taskId)?.abort(reservation.reasonCode);
+                        throw new Error(`Worker wait could not restore its write reservation: ${reservation.reasonCode}.`);
+                    }
+                }
             }
             this.yieldedCapacityAttemptIds.delete(attempt.attemptId);
+            this.yieldedWriteReservations.delete(attempt.attemptId);
+            restored = true;
             if (!this.deps.isDisposed())
-                this.scheduler.drain();
+                this.scheduler.drain(true);
+            return true;
         };
+        try {
+            this.scheduler.drain(true);
+        }
+        catch (error) {
+            if (!restore()) {
+                throw new AggregateError([error], "Worker wait dispatch failed before its write reservation could be restored.");
+            }
+            throw error;
+        }
+        return restore;
     }
     workerDispatchAdmission(request, record) {
         if (this.recovery.deferRetryIfNeeded(record, request))
@@ -942,13 +1043,14 @@ export class WorkerDelegationController {
     workerContextForkMode(request, contract) {
         if (request.verificationOfTaskId)
             return { kind: "none" };
+        const mode = request.forkTurns ?? (request.parentAgentId ? "none" : undefined);
         return resolveWorkerContextInheritanceMode({
             parent: this.workerContextParentModel(request),
             worker: {
                 provider: contract.worker.modelBinding.provider,
                 model: contract.worker.modelBinding.modelId,
             },
-            ...(request.forkTurns !== undefined ? { mode: request.forkTurns } : {}),
+            ...(mode !== undefined ? { mode } : {}),
         });
     }
     workerContextForkAdmissionSkipReason(request, contract) {
@@ -1412,6 +1514,7 @@ export class WorkerDelegationController {
             startWorkerDelegation: (childRequest) => this.start({ ...childRequest, parentAgentId: agentId }),
             runWorkerDelegation: (childRequest) => this.runOnce({ ...childRequest, parentAgentId: agentId }),
             orchestrationProfiles: this.getProfileCatalog(),
+            workerModelPinPolicy: this.deps.getSettingsManager().getWorkerModelPinPolicy(),
             workerAgentControl: this.agentControl,
             caller: { kind: "worker", agentId },
             resolveMessageReplayScope: () => ({
@@ -1499,6 +1602,16 @@ export class WorkerDelegationController {
         const laneAbortController = new AbortController();
         this.laneAbortControllers.set(startedRecord.laneId, laneAbortController);
         const workerSignal = AbortSignal.any([this.workerAbort.signal, laneAbortController.signal]);
+        const leaseHeartbeat = new WorkerLeaseHeartbeat({
+            leaseTtlMs: immutableProfile.leaseTtlMs,
+            renew: () => {
+                lifecycle.renewLease(startedRecord.laneId, immutableProfile.leaseTtlMs);
+            },
+            onFailure: (error) => {
+                this.safeWarn(`Worker ${startedRecord.laneId} lease renewal failed: ${error.message}`);
+                laneAbortController.abort(error);
+            },
+        });
         // Registered for the lane's full run so the reload gate waits it out; deregistered in the
         // finally below no matter how this lane terminates (success, disposal, or a thrown error).
         // registerInFlightWork is a pure sync map op (cannot throw), so placing it as the last
@@ -1551,7 +1664,9 @@ export class WorkerDelegationController {
                 request: workerRequest,
                 handle: durableHandle,
             });
+            leaseHeartbeat.start();
             const executionResult = await executor.run();
+            leaseHeartbeat.assertHealthy();
             const rawOutcome = executionResult.rawOutcome;
             // Attempt ladder: a retryable bounded failure suspends and re-enqueues instead of
             // terminalizing, resuming from the persisted transcript under a fresh fence.
@@ -1733,7 +1848,10 @@ export class WorkerDelegationController {
             return { started: true, record };
         }
         finally {
+            leaseHeartbeat.stop();
             this.writeReservations.release(startedRecord.laneId, durableHandle.attemptId, durableHandle.fencingToken);
+            this.yieldedCapacityAttemptIds.delete(durableHandle.attemptId);
+            this.yieldedWriteReservations.delete(durableHandle.attemptId);
             this.inFlightLedgers.delete(startedRecord.laneId);
             this.laneAbortControllers.delete(startedRecord.laneId);
             try {