@caupulican/pi-adaptative 0.90.2 → 0.90.4

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

@@ -29,7 +29,8 @@ 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 { WorkerRecoveryCoordinator } from "./worker-recovery-coordinator.js";
@@ -38,7 +39,7 @@ import { materializeWorkerResourceBundle } from "./worker-resource-materializer.
 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 +83,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 +152,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 +169,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),
         });
@@ -449,9 +454,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 +472,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 +505,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) {
@@ -829,37 +844,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 +1009,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) {
@@ -1499,6 +1567,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 +1629,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 +1813,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 {