Oct 27, 2026

Add a CLI for reviewing agent feedbackTypeScript · 256 + / 0 −

Introduces 9 new declarations in packages/next/src/cli/internal/agent-feedback.ts.

Adds new framework internals rather than adjusting what was there. Tests changed with it, with code of their own.

packages/next/src/cli/internal/agent-feedback.ts ↗ · 7 files

@@ -0,0 +1,243 @@+import type { ChildProcess, SpawnOptions } from 'child_process'+import { addAbortSignal, type Readable } from 'stream'++import spawn from 'next/dist/compiled/cross-spawn'+import { z } from 'next/dist/compiled/zod'++const AGENT_FEEDBACK_REVIEW_URL = 'https://nextjs.org/agent-feedback#report='+const MAX_AGENT_FEEDBACK_INPUT_BYTES = 16 * 1024+const AGENT_FEEDBACK_INPUT_TIMEOUT_MS = 5_000++type SpawnReviewForm = (+  command: string,+  args: string[],+  options: SpawnOptions+) => ChildProcess++type FeedbackInput = Readable & {+  isTTY?: boolean+}++export type NextFeedbackOptions = {+  dryRun?: boolean+}++const agentFeedbackReportFields = {+  triggerReason: z.enum([+    'unexpected-behavior',+    'documentation-mismatch',+    'misleading-error',+    'repeated-failed-approach',+    'non-obvious-workaround',+  ]),+  title: z.string().min(1).max(100),

Fix PDB controller to enqueue all affected budgets on pod changesGo · 64 + / 25 −

Introduces 3 new declarations in pkg/controller/disruption/disruption.go.

Adds new systems design rather than adjusting what was there. Tests changed with it, with code of their own.

pkg/controller/disruption/disruption.go ↗ · 2 files

@@ -533,18 +536,43 @@ func (dc *DisruptionController) addPod(logger klog.Logger, obj interface{}) { 	} } -func (dc *DisruptionController) updatePod(logger klog.Logger, _, cur interface{}) {-	pod := cur.(*v1.Pod)-	logger.V(4).Info("UpdatePod called on pod", "pod", klog.KObj(pod))-	pdb := dc.getPdbForPod(logger, pod)-	if pdb == nil {-		logger.V(4).Info("No matching PDB for pod", "pod", klog.KObj(pod))-	} else {-		logger.V(4).Info("updatePod -> PDB", "pod", klog.KObj(pod), "podDisruptionBudget", klog.KObj(pdb))+func (dc *DisruptionController) updatePod(logger klog.Logger, old, cur interface{}) {+	curPod := cur.(*v1.Pod)+	oldPod := old.(*v1.Pod)+	syncPdbs := map[string]*policy.PodDisruptionBudget{}++	logger.V(4).Info("UpdatePod called on pod", "pod", klog.KObj(curPod))++	if !reflect.DeepEqual(oldPod.Labels, curPod.Labels) {+		for _, pdb := range dc.getPdbsForPod(logger, oldPod) {+			key, err := controller.KeyFunc(pdb)+			if err != nil {+				logger.Error(err, "Couldn't get key for PodDisruptionBudget", "podDisruptionBudget", klog.KObj(pdb))+				continue+			}+			syncPdbs[key] = pdb+		}+	}+	curPdbs := dc.getPdbsForPod(logger, curPod)+	// Warn only for curPod. Old labels are no longer on the live pod.+	dc.warnMultiplePodDisruptionBudgets(logger, curPod, curPdbs)+	for _, pdb := range curPdbs {+		key, err := controller.KeyFunc(pdb)

feat(core): add the PiecewiseLinear learning rate schedulerPython · 115 + / 2 −

Introduces 5 new declarations in nemo/core/optim/lr_scheduler.py.

Adds new core implementation rather than adjusting what was there. Tests changed with it, with code of their own.

nemo/core/optim/lr_scheduler.py ↗ · 6 files

@@ -713,6 +714,97 @@ def _get_lr(self, step):         return new_lrs  +class PiecewiseLinear(_LRScheduler):+    """Learning rate interpolated linearly between given values at given points of the training.++    ``boundaries`` are increasing positions in the training+    and ``values`` the learning-rate multipliers at those positions;+    between two boundaries the multiplier is interpolated linearly,+    before the first and after the last boundary it stays at the nearest value.+    Positions are optimizer steps, or fractions of ``max_steps`` with ``relative=True``,+    so that one configuration describes the schedule for any training length.+    The multipliers scale the learning rate of each parameter group;+    with ``lr: 1.0`` they are the learning rates.++    Example, a warmup over the first 45% of the training and a decay to the end:++    .. code-block:: yaml++        sched:+          name: PiecewiseLinear+          relative: true+          boundaries: [0.0, 0.45, 0.9, 1.0]+          values: [1e-5, 4e-3, 1e-5, 1e-6]++    Args:+        optimizer: the wrapped optimizer+        boundaries: increasing positions, in optimizer steps or (``relative``) in fractions of ``max_steps``+        values: learning-rate multiplier at each boundary, one per boundary+        relative: interpret ``boundaries`` as fractions of ``max_steps``+        max_steps: the number of optimizer steps of the training, a positive integer;+            required with ``relative`` and ignored otherwise;+            :func:`prepare_lr_scheduler` fills it in from the trainer or from ``sched.max_steps``

🚨 Separate EP logic into its own filePython · 606 + / 440 −

Introduces 53 new declarations in src/transformers/distributed/tensor_parallel.py.

Adds new core implementation rather than adjusting what was there. Tests changed with it, with code of their own.

src/transformers/distributed/tensor_parallel.py ↗ · 26 files

@@ -753,300 +645,29 @@ def transform_inputs_pre_forward(self, module, args, kwargs, mesh):         return (input_tensor / mesh.size(), *args[1:]), kwargs  -class EpRouterParallel(TensorParallelLayer):-    """Expert-parallel router: forward-only slicing of router outputs to local experts.--    Expects the router to return `(router_logits, router_scores, router_indices, *extra)`.-    `router_logits` and any trailing `extra` outputs are passed through unchanged.--    The gate runs replicated on every rank and emits global expert IDs and scores.-    Under EP each rank owns `num_experts // ep_size` experts, so this post-forward hook:--    - zeroes scores for non-local experts-    - remaps surviving global indices to local indices (`fmod` after masking non-local slots)-    - sets dropped slots to sentinel `num_local_experts` (skipped by grouped_gemm experts forward)--    Downstream `moe_tp_experts` allreduce-sums partial per-rank expert outputs.--    Example: 4 tokens, top_k=4, 128 experts, EP=8 → num_local_experts=16.--    Router output (identical on all ranks):-        router_indices:-            [ 52,  42, 119,  67],-            [102,  89,  61,  40],-            [ 82, 103,   4,  34],-            [ 93,  23, 109,  11]--    Owning rank (`index // 16`):-            [ 3,  2,  7,  4],-            [ 6,  5,  3,  2],-            [ 5,  6,  0,  2],-            [ 5,  1,  6,  0],-

fix(arima): use the configured innovation distribution on every fit and refitPython · 67 + / 25 −

Introduces 2 new declarations in python/statsforecast/arima.py.

Adds new core implementation rather than adjusting what was there. Tests changed with it, with code of their own.

python/statsforecast/arima.py ↗ · 4 files

@@ -786,6 +789,26 @@ def arma_css_op(p, x, coef, mask, arma, ncxreg, xreg, narma):         # objective actually optimized, plus the tail appended to the arma params         # (empty for normal/laplace, which concentrate their scale out)         ml_obj = armafn if distribution == Distribution.NORMAL else armafn_laplace+        fixed_tail = None+        if fixed_dist is not None and distribution_n_extra_params(distribution):+            if not no_optim:+                raise ValueError("fixed_dist requires all coefficients to be fixed")+            fixed_tail = np.array(dist_tail_from_params(distribution, fixed_dist))++        def minimize_tail(obj, init_ext):+            if fixed_tail is None:+                return minimize(+                    obj,+                    init_ext,+                    args=ml_args,+                    method=optim_method,+                    tol=tol,+                    options=optim_control,+                )+            return OptimResult(+                True, 0, fixed_tail, obj(fixed_tail, *ml_args), np.array([])+            )+         dist_tail_fit = np.array([])         nu_t = None         sigma2_t = None