@outbuild-company/schedule-core 1.1.2 → 1.2.0

package/dist/index.cjs

@@ -926,7 +926,8 @@ function expandParentLinks(links, adapter) {
       targetIds,
       link,
       adapter,
-      virtualIdCounter
+      virtualIdCounter,
+      linksByActivity
     );
   }
   return expanded;
@@ -943,19 +944,96 @@ function expandedEndpoints(activityId, summary, adapter, linksByActivity, source
     sourceSide
   );
 }
-function pushOffsetPreservingLinks(expanded, sourceIds, leafIds, originalLink, adapter, virtualIdCounter) {
+function deriveSummaryBoundsWithDates(summaryId, adapter, resolveDates) {
+  const leaves = getLeafDescendants(summaryId, adapter);
+  if (leaves.length === 0) return null;
+  let earliestStart = null;
+  let latestEnd = null;
+  for (const leafId of leaves) {
+    const leafDates = resolveDates(leafId);
+    if (!leafDates) continue;
+    const startsEarlier = earliestStart === null || leafDates.startDate < earliestStart;
+    if (startsEarlier) earliestStart = leafDates.startDate;
+    const endsLater = latestEnd === null || leafDates.endDate > latestEnd;
+    if (endsLater) latestEnd = leafDates.endDate;
+  }
+  if (earliestStart === null || latestEnd === null) return null;
+  return { startDate: earliestStart, endDate: latestEnd };
+}
+function deriveSummaryBounds(summaryId, adapter) {
+  return deriveSummaryBoundsWithDates(summaryId, adapter, (leafId) => {
+    const leaf = adapter.getActivity(leafId);
+    if (!leaf) return null;
+    return { startDate: leaf.startDate, endDate: leaf.endDate };
+  });
+}
+function endpointSpanHours(endpoint, bounds, adapter) {
+  if (!endpoint) return 0;
+  if (!bounds) return endpoint.durationHours;
+  return adapter.calculateDuration({
+    startDate: bounds.startDate,
+    endDate: bounds.endDate,
+    task: endpoint
+  });
+}
+function sourceLagForLeaf(leafId, source, sourceBounds, adapter) {
+  if (!source) return 0;
+  const leaf = adapter.getActivity(leafId);
+  if (!sourceBounds || !leaf) return -source.durationHours;
+  return -adapter.calculateDuration({
+    startDate: sourceBounds.startDate,
+    endDate: leaf.endDate,
+    task: source
+  });
+}
+function hasIncomingRawLink(leafId, linksByActivity) {
+  const leafKey = String(leafId);
+  const bucket = linksByActivity.get(leafKey) ?? [];
+  return bucket.some((rawLink) => String(rawLink.target) === leafKey);
+}
+function targetOffsetForLeaf(leafId, targetStart, source, adapter, linksByActivity) {
+  if (hasIncomingRawLink(leafId, linksByActivity)) return 0;
+  const leaf = adapter.getActivity(leafId);
+  if (!targetStart || !leaf || !source) return 0;
+  return adapter.calculateDuration({
+    startDate: targetStart,
+    endDate: leaf.startDate,
+    task: source
+  });
+}
+function resolveExpansionAnchors(originalLink, adapter) {
   const source = adapter.getActivity(originalLink.source);
   const target = adapter.getActivity(originalLink.target);
-  const targetStart = target?.startDate;
-  const userLag = originalLink.lag ?? 0;
+  const sourceBounds = deriveSummaryBounds(originalLink.source, adapter);
+  const targetBounds = deriveSummaryBounds(originalLink.target, adapter);
   const sourceEndpointIsStart = originalLink.type === LINK_TYPE.START_TO_START || originalLink.type === LINK_TYPE.START_TO_FINISH;
   const targetEndpointIsFinish = originalLink.type === LINK_TYPE.FINISH_TO_FINISH || originalLink.type === LINK_TYPE.START_TO_FINISH;
-  const sourceLag = sourceEndpointIsStart ? -(source?.durationHours ?? 0) : 0;
-  const targetLag = targetEndpointIsFinish ? -(target?.durationHours ?? 0) : 0;
+  return {
+    source,
+    sourceBounds,
+    targetStart: targetBounds?.startDate ?? target?.startDate,
+    userLag: originalLink.lag ?? 0,
+    sourceEndpointIsStart,
+    targetLag: targetEndpointIsFinish ? -endpointSpanHours(target, targetBounds, adapter) : 0,
+    summarySourceId: originalLink.type === LINK_TYPE.START_TO_START && sourceBounds ? originalLink.source : void 0
+  };
+}
+function pushOffsetPreservingLinks(expanded, sourceIds, leafIds, originalLink, adapter, virtualIdCounter, linksByActivity) {
+  const anchors = resolveExpansionAnchors(originalLink, adapter);
+  const { source, sourceBounds, targetStart, userLag } = anchors;
+  const { sourceEndpointIsStart, targetLag, summarySourceId } = anchors;
   let counter = virtualIdCounter;
   for (const srcId of sourceIds) {
+    const sourceLag = sourceEndpointIsStart ? sourceLagForLeaf(srcId, source, sourceBounds, adapter) : 0;
     for (const tgtId of leafIds) {
       if (String(srcId) === String(tgtId)) continue;
+      const offTarget = targetOffsetForLeaf(
+        tgtId,
+        targetStart,
+        source,
+        adapter,
+        linksByActivity
+      );
       expanded.push(
         buildVirtualLink(
           originalLink,
@@ -964,10 +1042,9 @@ function pushOffsetPreservingLinks(expanded, sourceIds, leafIds, originalLink, a
           counter,
           sourceLag,
           targetLag,
-          userLag,
-          source,
-          targetStart,
-          adapter
+          userLag + offTarget,
+          summarySourceId,
+          offTarget !== 0 && targetLag === 0 ? originalLink.target : void 0
         )
       );
       counter += 1;
@@ -975,13 +1052,7 @@ function pushOffsetPreservingLinks(expanded, sourceIds, leafIds, originalLink, a
   }
   return counter;
 }
-function buildVirtualLink(originalLink, sourceId, targetId, counter, sourceLag, targetLag, userLag, source, targetStart, adapter) {
-  const leaf = adapter.getActivity(targetId);
-  const offTarget = targetStart && leaf && source ? adapter.calculateDuration({
-    startDate: targetStart,
-    endDate: leaf.startDate,
-    task: source
-  }) : 0;
+function buildVirtualLink(originalLink, sourceId, targetId, counter, sourceLag, targetLag, trueLag, summarySourceId, offsetSummaryTargetId) {
   return {
     id: `virtual_${originalLink.id}_${counter}`,
     source: sourceId,
@@ -990,7 +1061,9 @@ function buildVirtualLink(originalLink, sourceId, targetId, counter, sourceLag,
     lag: originalLink.lag,
     _sourceLag: sourceLag,
     _targetLag: targetLag,
-    _trueLag: userLag + offTarget
+    _trueLag: trueLag,
+    ...summarySourceId === void 0 ? {} : { _summarySourceId: summarySourceId },
+    ...offsetSummaryTargetId === void 0 ? {} : { _summaryTargetId: offsetSummaryTargetId }
   };
 }
 
@@ -1122,33 +1195,49 @@ function normalize(predecessor, successor, link) {
       };
   }
 }
-function calculateSuccessorStartFromLink(predecessor, successor, link, adapter) {
-  const { sourceLag, targetLag, trueLag, isFS, isFF } = normalize(
-    predecessor,
-    successor,
+function summaryAnchoredSourceLag(link, predecessor, adapter) {
+  if (link._summarySourceId === void 0) return null;
+  const summarySource = adapter.getActivity(link._summarySourceId);
+  if (!summarySource) return null;
+  const summaryBounds = deriveSummaryBounds(link._summarySourceId, adapter);
+  if (!summaryBounds) return null;
+  return -adapter.calculateDuration({
+    startDate: summaryBounds.startDate,
+    endDate: predecessor.endDate,
+    task: summarySource
+  });
+}
+function noLagSuccessorStart(predecessor, successor, link, adapter, isEndAnchoredType) {
+  const snapsToPast = successor.durationHours === 0 && isEndAnchoredType;
+  return {
+    successorStart: adapter.getClosestWorkTime({
+      date: predecessor.endDate,
+      dir: snapsToPast ? "past" : "future",
+      task: successor
+    }),
     link
-  );
-  const hasLag = sourceLag !== 0 || targetLag !== 0 || trueLag !== 0;
+  };
+}
+function calculateSuccessorStartFromLink(predecessor, successor, link, adapter) {
+  const {
+    sourceLag: frozenSourceLag,
+    targetLag,
+    trueLag,
+    isFS,
+    isFF
+  } = normalize(predecessor, successor, link);
+  const sourceLag = summaryAnchoredSourceLag(link, predecessor, adapter) ?? frozenSourceLag;
+  const totalLag = sourceLag + targetLag + trueLag;
+  const isZeroDurationSuccessor = successor.durationHours === 0;
+  const hasLag = isZeroDurationSuccessor ? totalLag !== 0 : sourceLag !== 0 || targetLag !== 0 || trueLag !== 0;
   if (!hasLag) {
-    const isFForFS = isFS || isFF;
-    if (successor.durationHours === 0 && isFForFS) {
-      return {
-        successorStart: adapter.getClosestWorkTime({
-          date: predecessor.endDate,
-          dir: "past",
-          task: successor
-        }),
-        link
-      };
-    }
-    return {
-      successorStart: adapter.getClosestWorkTime({
-        date: predecessor.endDate,
-        dir: "future",
-        task: successor
-      }),
-      link
-    };
+    return noLagSuccessorStart(
+      predecessor,
+      successor,
+      link,
+      adapter,
+      isFS || isFF
+    );
   }
   const baseTask = isFS ? successor : predecessor;
   let date2 = adapter.getClosestWorkTime({
@@ -1369,10 +1458,12 @@ async function asapPass(orderedIds, links, adapter, options, isCurrent, plans) {
     const incoming = incomingLinks.get(String(activityId)) ?? [];
     let maxStart = null;
     let drivingLinkId = null;
+    let drivingOffsetIsStale = false;
     for (const link of incoming) {
       const predecessorSnap = adapter.getActivity(link.source);
       if (!predecessorSnap) continue;
       const predDates = getActivityDates(link.source);
+      const predecessorMovedThisRun = predDates.startDate.getTime() !== predecessorSnap.startDate.getTime() || predDates.endDate.getTime() !== predecessorSnap.endDate.getTime();
       const effectivePred = {
         ...predecessorSnap,
         startDate: predDates.startDate,
@@ -1402,8 +1493,13 @@ async function asapPass(orderedIds, links, adapter, options, isCurrent, plans) {
       if (!maxStart || result.successorStart > maxStart) {
         maxStart = result.successorStart;
         drivingLinkId = String(link.id);
+        drivingOffsetIsStale = link._summaryTargetId !== void 0 && !predecessorMovedThisRun;
       }
     }
+    const staleOffsetWouldPullBack = maxStart !== null && drivingOffsetIsStale && maxStart < activity.startDate;
+    if (staleOffsetWouldPullBack) {
+      maxStart = new Date(activity.startDate);
+    }
     const existing = plans.get(activityId);
     const plan = existing ? { ...existing } : {
       activityId,
@@ -1571,31 +1667,33 @@ async function alapPass(reversedIds, links, asapPlans, adapter, _options, isCurr
         latestEnd = boundary;
       }
     }
+    const incomingForKind = incomingLinks.get(String(activityId)) ?? [];
+    const isFinishMarker = incomingForKind.some(
+      (incomingLink) => incomingLink.type === LINK_TYPE.FINISH_TO_START || incomingLink.type === LINK_TYPE.FINISH_TO_FINISH
+    );
+    const latestEndAtDayStart = new Date(
+      Date.UTC(
+        latestEnd.getUTCFullYear(),
+        latestEnd.getUTCMonth(),
+        latestEnd.getUTCDate()
+      )
+    );
+    const finishMarkerEnd = () => adapter.getClosestWorkTime({
+      date: latestEndAtDayStart,
+      dir: "past",
+      task: activity
+    });
+    const latestEndLandsInsideWorkingDay = adapter.getClosestWorkTime({ date: latestEnd, dir: "future", task: activity }).getTime() === latestEnd.getTime();
     let snappedEnd;
     if (activity.durationHours === 0 && successorAnchor === null) {
-      snappedEnd = adapter.getClosestWorkTime({
+      snappedEnd = isFinishMarker && latestEndLandsInsideWorkingDay ? finishMarkerEnd() : adapter.getClosestWorkTime({
         date: latestEnd,
         dir: "past",
         task: activity
       });
     } else if (activity.durationHours === 0) {
-      const incoming = incomingLinks.get(String(activityId)) ?? [];
-      const isFinishKind = incoming.some(
-        (l) => l.type === LINK_TYPE.FINISH_TO_START || l.type === LINK_TYPE.FINISH_TO_FINISH
-      );
-      if (isFinishKind) {
-        const dayStart = new Date(
-          Date.UTC(
-            latestEnd.getUTCFullYear(),
-            latestEnd.getUTCMonth(),
-            latestEnd.getUTCDate()
-          )
-        );
-        snappedEnd = adapter.getClosestWorkTime({
-          date: dayStart,
-          dir: "past",
-          task: activity
-        });
+      if (isFinishMarker) {
+        snappedEnd = finishMarkerEnd();
       } else {
         snappedEnd = adapter.getClosestWorkTime({
           date: latestEnd,
@@ -1628,10 +1726,16 @@ async function alapPass(reversedIds, links, asapPlans, adapter, _options, isCurr
     plan.endDate = snappedEnd;
     plan.drivingLinkId = null;
     plan.kind = "alap";
+    const predecessorFloor = plan.earliestSchedulingStart ?? null;
     plan.earliestSchedulingStart = null;
     plan.earliestSchedulingEnd = null;
-    plan.latestSchedulingStart = snappedStart;
-    plan.latestSchedulingEnd = snappedEnd;
+    const alapTarget = predecessorFloor !== null && predecessorFloor.getTime() > snappedStart.getTime() ? predecessorFloor : snappedStart;
+    plan.latestSchedulingStart = alapTarget;
+    plan.latestSchedulingEnd = alapTarget === snappedStart ? snappedEnd : adapter.calculateEndDate({
+      startDate: alapTarget,
+      durationHours: activity.durationHours,
+      task: activity
+    });
     limitPlanDates(activity, plan, adapter);
     plans.set(activityId, plan);
   }
@@ -2066,18 +2170,9 @@ var AutoScheduler = class {
       }
       const phaseScope = startPhase("schedule.scoping");
       const allIds = this.adapter.getAllIds();
-      let scopedLinks = activeLinks;
-      let scopedIds = allIds;
-      let scopedIdSet = null;
-      if (options.triggerId !== void 0 && options.triggerId !== null) {
-        const group = findConnectedGroupForTrigger(
-          options.triggerId,
-          activeLinks
-        );
-        scopedLinks = group.links;
-        scopedIds = Array.from(group.activityIds);
-        scopedIdSet = new Set(scopedIds);
-      }
+      const scope = resolveScope(options, activeLinks, this.adapter);
+      const scopedLinks = scope.links;
+      const scopedIdSet = scope.idSet;
       endPhase(phaseScope);
       const phaseTopo = startPhase("schedule.topologicalSort");
       const topoResult = resolveTopoResult(
@@ -2174,6 +2269,34 @@ function endPhase(handle) {
   const elapsed = performance.now() - handle.startedAt;
   console.log(`[scheduler] ${handle.name} ${elapsed.toFixed(1)}ms`);
 }
+function resolveScope(options, activeLinks, adapter) {
+  const triggerId = options.triggerId;
+  if (triggerId === void 0 || triggerId === null) {
+    return { idSet: null, links: activeLinks };
+  }
+  const group = findConnectedGroupForTrigger(triggerId, activeLinks);
+  return widenScopeToAlapActivities(group, activeLinks, adapter);
+}
+function widenScopeToAlapActivities(group, allLinks, adapter) {
+  const idSet = new Set(group.activityIds);
+  const widenedAlapKeys = /* @__PURE__ */ new Set();
+  for (const activity of adapter.getAllActivities()) {
+    const activityKey = String(activity.id);
+    const isOutOfComponentAlap = activity.constraintType === CONSTRAINT_TYPE2.ALAP && !idSet.has(activityKey);
+    if (!isOutOfComponentAlap) continue;
+    widenedAlapKeys.add(activityKey);
+    idSet.add(activityKey);
+  }
+  if (widenedAlapKeys.size === 0) {
+    return { idSet, links: group.links };
+  }
+  const links = [...group.links];
+  for (const link of allLinks) {
+    const touchesWidenedAlap = widenedAlapKeys.has(String(link.source)) || widenedAlapKeys.has(String(link.target));
+    if (touchesWidenedAlap) links.push(link);
+  }
+  return { idSet, links };
+}
 function resolveTopoResult(cache, allIds, allLinks, scopedIdSet) {
   const fullTopo = cache.get(allIds, allLinks);
   if (fullTopo.hasCycles) {
@@ -2191,9 +2314,10 @@ function resolveTopoResult(cache, allIds, allLinks, scopedIdSet) {
 }
 
 // src/internal/post-processors/adjust-link-lag-on-task-move.ts
-function adjustLinkLagOnTaskMove(targetId, adapter) {
+function adjustLinkLagOnTaskMove(targetId, adapter, preEditTarget) {
   const target = adapter.getActivity(targetId);
   if (!target) return;
+  const targetForLagMath = preEditTarget ? { ...target, endDate: preEditTarget.endDate } : target;
   const calendarApi = adapter.calendarReader.getCalendar(
     String(target.calendarId)
   );
@@ -2203,9 +2327,11 @@ function adjustLinkLagOnTaskMove(targetId, adapter) {
     const source = adapter.getActivity(link.source);
     if (!source) continue;
     if (source.constraintType === "alap") continue;
+    const isEndAnchoredIntoMilestone = isMilestoneType(target.type) && (link.type === LINK_TYPE.START_TO_FINISH || link.type === LINK_TYPE.FINISH_TO_FINISH);
+    if (isEndAnchoredIntoMilestone) continue;
     const { sourceDate, targetDate } = pickDatesForLinkType(
       source,
-      target,
+      targetForLagMath,
       link.type
     );
     const newLag = dateMath.computeLagBetweenTasks(
@@ -2253,14 +2379,15 @@ function computeLeafRealWork(workHours, progress) {
 // src/propagations/upward/parent-bounds.ts
 async function updateParentBoundsFromChildren(adapter, dirtyIds, recomputeProgress = true, options = {}) {
   const parents = dirtyIds ? findAncestorsOfDirty(adapter, dirtyIds) : findAllParents(adapter);
-  await recomputeParentsCooperatively(parents, adapter, recomputeProgress, {
+  const progressMode = recomputeProgress ? options.progressMode ?? "freeze-when-no-contribution" : "skip";
+  await recomputeParentsCooperatively(parents, adapter, progressMode, {
     recomputeRealWork: options.recomputeRealWork ?? false
   });
 }
 function recomputeSingleParentDisplayBounds(parentId, adapter) {
-  recomputeParentFromChildren(parentId, adapter, false);
+  recomputeParentFromChildren(parentId, adapter, "skip");
 }
-async function recomputeParentsCooperatively(parents, adapter, recomputeProgress = true, options = {
+async function recomputeParentsCooperatively(parents, adapter, progressMode, options = {
   recomputeRealWork: false
 }) {
   const YIELD_EVERY_N_PARENTS = 200;
@@ -2269,7 +2396,7 @@ async function recomputeParentsCooperatively(parents, adapter, recomputeProgress
     recomputeParentFromChildren(
       parentId,
       adapter,
-      recomputeProgress,
+      progressMode,
       options.recomputeRealWork
     );
     processed += 1;
@@ -2319,7 +2446,7 @@ function aggregateChildren(childrenIds, adapter, includeRealWork) {
   }
   return { minStart, maxEnd, realWorkSum, weightedChildren };
 }
-function recomputeParentFromChildren(parentId, adapter, recomputeProgress = true, recomputeRealWork = false) {
+function recomputeParentFromChildren(parentId, adapter, progressMode = "freeze-when-no-contribution", recomputeRealWork = false) {
   const parent = adapter.getActivity(parentId);
   if (!parent) return;
   const childrenIds = adapter.getChildren(parentId);
@@ -2337,11 +2464,12 @@ function recomputeParentFromChildren(parentId, adapter, recomputeProgress = true
   const progressRollup = computeWeightedProgressRollup(
     aggregate.weightedChildren
   );
-  if (recomputeProgress && progressRollup !== null) {
+  const shouldWriteProgress = progressMode !== "skip" && (progressRollup !== null || progressMode === "zero-when-no-contribution");
+  if (shouldWriteProgress) {
     adapter.setActivityField(
       parentId,
       "progress",
-      roundProgressPerLevel(progressRollup)
+      roundProgressPerLevel(progressRollup ?? 0)
     );
   }
   if (recomputeRealWork) {
@@ -2403,7 +2531,7 @@ function runRecordLastStartDate(activityId, adapter) {
   const activity = adapter.getActivity(activityId);
   if (activity) adapter.setLastStartDate(activityId, activity.startDate);
 }
-function runPostProcessorsOnAdapter(activityId, processorNames, adapter) {
+function runPostProcessorsOnAdapter(activityId, processorNames, adapter, preEditActivity) {
   for (const name of processorNames) {
     const fn = name in POST_PROCESSORS ? POST_PROCESSORS[name] : void 0;
     if (!fn) {
@@ -2412,7 +2540,7 @@ function runPostProcessorsOnAdapter(activityId, processorNames, adapter) {
       );
       continue;
     }
-    fn(activityId, adapter);
+    fn(activityId, adapter, preEditActivity ?? null);
   }
 }
 function runNoOp(name) {
@@ -2685,10 +2813,7 @@ var durationPipeline = {
     );
     return {
       ...fieldChanges(extraFields, {
-        // MAIN treats an ALAP duration edit as a resize from Start: Start is
-        // anchored and Finish moves. Running the ALAP pass would instead
-        // preserve Finish and pull Start, which is not the observed UI flow.
-        autoSchedule: activity.constraintType !== "alap",
+        autoSchedule: true,
         postProcessors: [POST_PROCESSOR.RECORD_LAST_START_DATE]
       }),
       ...constraintCheck.violated ? {
@@ -2850,16 +2975,22 @@ function buildCanonicalRealWorkOverlay(activity, progress, hierarchy) {
   realWorkByActivity.set(activity.id, selfRealWork);
   return realWorkByActivity;
 }
+function summariesOverSummariesDeepestFirst(activity, hierarchy) {
+  const subtreeIds = [activity.id, ...hierarchy.getDescendantIds(activity.id)];
+  const hasSummaryChild = (parentId) => hierarchy.getChildProgressInfo(parentId).some((child) => hierarchy.hasChildren(child.id));
+  const depthOf3 = (activityId) => hierarchy.getAncestorIds(activityId).length;
+  return subtreeIds.filter((candidateId) => hasSummaryChild(String(candidateId))).map(String).sort((first, second) => depthOf3(second) - depthOf3(first));
+}
 function buildAncestorRollupCascade(activity, newValue, hierarchy) {
   const overlay = /* @__PURE__ */ new Map();
   overlay.set(activity.id, newValue);
   for (const descendantId of hierarchy.getDescendantIds(activity.id)) {
     overlay.set(descendantId, newValue);
   }
-  const chain = [];
-  for (const ancestorId of hierarchy.getAncestorIds(activity.id)) {
-    chain.push(ancestorId);
-  }
+  const chain = [
+    ...summariesOverSummariesDeepestFirst(activity, hierarchy),
+    ...hierarchy.getAncestorIds(activity.id)
+  ];
   const mutations = [];
   for (const id of chain) {
     const rollup = computeWeightedProgress(id, overlay, hierarchy);
@@ -3256,6 +3387,8 @@ function checkIsWorkingDay(newDate, activity, ctx) {
   return null;
 }
 function detectEndDateConstraintWarning(activity, newEndDate) {
+  const cannotViolateStartPin = effectiveConstraintType(activity) === CONSTRAINT_TYPE2.MSO;
+  if (cannotViolateStartPin) return void 0;
   const projectedDate = pickProjectedDateForConstraint(
     effectiveConstraintType(activity),
     activity.startDate,
@@ -3276,7 +3409,8 @@ function detectEndDateConstraintWarning(activity, newEndDate) {
 function buildEndDateExtraFields(activity, newEndDate, ctx, violatesConstraint = false) {
   const fields = {};
   const isMilestone = isMilestoneType(activity.type);
-  if (isMilestone && !violatesConstraint) {
+  const seedsMilestoneDate = isMilestone && !violatesConstraint && hasDatelessConstraintType(activity);
+  if (seedsMilestoneDate) {
     Object.assign(fields, setConstraintDate(activity.startDate));
   } else if (violatesConstraint || hasDatelessConstraintType(activity)) {
     Object.assign(
@@ -3286,10 +3420,8 @@ function buildEndDateExtraFields(activity, newEndDate, ctx, violatesConstraint =
     );
   }
   const newDuration = calculateNewDuration(activity, newEndDate, ctx);
-  if (!isMilestone) {
-    const flippedType = typeForNewDuration(activity.durationHours, newDuration);
-    if (flippedType) fields.type = flippedType;
-  }
+  const flippedType = typeForNewDuration(activity.durationHours, newDuration);
+  if (flippedType) fields.type = flippedType;
   Object.assign(fields, setDuration(newDuration));
   fields.endDate = newEndDate;
   return fields;
@@ -3706,6 +3838,49 @@ function setLinkFieldDynamic(state, linkId, field, value) {
   state.setLinkFieldDynamic(linkId, field, value);
 }
 
+// src/internal/state/clone-core-activity.ts
+function cloneCoreActivity(activity) {
+  return {
+    ...activity,
+    startDate: new Date(activity.startDate),
+    endDate: new Date(activity.endDate),
+    constraintDate: cloneNullableDate(activity.constraintDate),
+    dateOrigin: cloneNullableDate(activity.dateOrigin),
+    newActivityIds: [...activity.newActivityIds],
+    pendingRequestIds: [...activity.pendingRequestIds],
+    responsableIds: [...activity.responsableIds],
+    tagIds: [...activity.tagIds],
+    baselinePoints: activity.baselinePoints.map((point) => ({
+      ...point,
+      startDate: cloneNullableDate(point.startDate),
+      endDate: cloneNullableDate(point.endDate)
+    })),
+    baselineSnapshot: cloneBaselineSnapshot(activity.baselineSnapshot),
+    criticalPath: cloneCriticalPath(activity.criticalPath)
+  };
+}
+function cloneNullableDate(value) {
+  return value === null ? null : new Date(value);
+}
+function cloneBaselineSnapshot(value) {
+  if (value === null) return null;
+  return {
+    ...value,
+    startDate: cloneNullableDate(value.startDate),
+    endDate: cloneNullableDate(value.endDate)
+  };
+}
+function cloneCriticalPath(value) {
+  if (value === null) return null;
+  return {
+    ...value,
+    earlyStart: cloneNullableDate(value.earlyStart),
+    earlyFinish: cloneNullableDate(value.earlyFinish),
+    lateStart: cloneNullableDate(value.lateStart),
+    lateFinish: cloneNullableDate(value.lateFinish)
+  };
+}
+
 // src/dispatch/shared/snapshots.ts
 function collectTouchedIds(primary, changes) {
   const ids = /* @__PURE__ */ new Set([String(primary)]);
@@ -3723,13 +3898,7 @@ function snapshotActivities(adapter, ids) {
   return out;
 }
 function structuredCloneActivity(activity) {
-  return {
-    ...activity,
-    startDate: new Date(activity.startDate),
-    endDate: new Date(activity.endDate),
-    constraintDate: activity.constraintDate ? new Date(activity.constraintDate) : null,
-    dateOrigin: activity.dateOrigin ? new Date(activity.dateOrigin) : null
-  };
+  return cloneCoreActivity(activity);
 }
 function applyFieldChanges(adapter, activityId, changes) {
   applyCanonicalPatch(adapter, activityId, changes.patch);
@@ -3782,12 +3951,33 @@ function diffActivity(before, after) {
   const afterRec = after;
   const keys = /* @__PURE__ */ new Set([...Object.keys(beforeRec), ...Object.keys(afterRec)]);
   for (const k of keys) {
-    if (!shallowEqual(beforeRec[k], afterRec[k])) {
+    if (Object.hasOwn(beforeRec, k) !== Object.hasOwn(afterRec, k) || !fieldValueEqual(beforeRec[k], afterRec[k])) {
       fields[k] = { before: beforeRec[k], after: afterRec[k] };
     }
   }
   return fields;
 }
+function fieldValueEqual(left, right) {
+  if (Object.is(left, right)) return true;
+  if (left instanceof Date && right instanceof Date) {
+    return left.getTime() === right.getTime();
+  }
+  if (left == null || right == null) return false;
+  if (Array.isArray(left) || Array.isArray(right)) {
+    if (!Array.isArray(left) || !Array.isArray(right)) return false;
+    if (left.length !== right.length) return false;
+    return left.every((value, index) => fieldValueEqual(value, right[index]));
+  }
+  if (typeof left !== "object" || typeof right !== "object") return false;
+  const leftRecord = left;
+  const rightRecord = right;
+  const leftKeys = Object.keys(leftRecord);
+  const rightKeys = Object.keys(rightRecord);
+  if (leftKeys.length !== rightKeys.length) return false;
+  return leftKeys.every(
+    (key) => Object.hasOwn(rightRecord, key) && fieldValueEqual(leftRecord[key], rightRecord[key])
+  );
+}
 function collectDirtyForInlineEdit(triggerId, touchedIds, scheduledIds) {
   const dirty = /* @__PURE__ */ new Set();
   dirty.add(triggerId);
@@ -3813,21 +4003,6 @@ function foldCorrelativeShifts(adapter, shifts, excludeIds, beforeSnap, touched)
     beforeSnap.set(shift.activityId, beforeImage);
   }
 }
-function shallowEqual(a, b) {
-  if (a === b) return true;
-  if (a instanceof Date && b instanceof Date)
-    return a.getTime() === b.getTime();
-  if (a == null || b == null) return false;
-  if (typeof a !== typeof b) return false;
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length !== b.length) return false;
-    for (let i = 0; i < a.length; i++) {
-      if (!shallowEqual(a[i], b[i])) return false;
-    }
-    return true;
-  }
-  return false;
-}
 
 // src/shared/backend-date.ts
 var BACKEND_DATE_FORMAT_REGEX = /^(\d{4})\/(\d{1,2})\/(\d{1,2})\s+(\d{1,2}):(\d{2})$/;
@@ -9357,6 +9532,9 @@ function resolveDerivedPasses(action, autoSchedule, options) {
 // src/dispatch/shared/post-mutation.ts
 async function runPostMutation(deps, args) {
   const passes = resolvePasses(args);
+  if (passes.has(DERIVED_PASS.AUTOSCHEDULE)) {
+    await refreshMutatedParentBounds(deps.adapter, args);
+  }
   const schedule = passes.has(DERIVED_PASS.AUTOSCHEDULE) ? await runAutoschedule(deps, args.autoscheduleFrom) : emptySchedule();
   await rollUpParentBounds(deps.adapter, args, schedule.scheduledIds, passes);
   await runDerivedRecomputes(deps, passes, args.now);
@@ -9365,7 +9543,11 @@ async function runPostMutation(deps, args) {
 function resolvePasses(args) {
   const requested = args.autoscheduleFrom !== null;
   const ran = !args.options.skipAutoSchedule && requested;
-  return resolveDerivedPasses(args.action, { ran }, args.options);
+  const passes = new Set(
+    resolveDerivedPasses(args.action, { ran }, args.options)
+  );
+  if (args.recomputeParentProgress) passes.add(DERIVED_PASS.PARENT_PROGRESS);
+  return passes;
 }
 async function runAutoschedule(deps, autoscheduleFrom) {
   const options = autoscheduleFrom === "roots" ? {} : { triggerId: autoscheduleFrom };
@@ -9376,20 +9558,23 @@ async function runAutoschedule(deps, autoscheduleFrom) {
 }
 function captureScheduledRows(adapter, updatedIds) {
   const scheduledIds = [];
-  const scheduledBeforeImages = /* @__PURE__ */ new Map();
   for (const id of updatedIds) {
     const activityId = String(id);
     scheduledIds.push(activityId);
     const snap = adapter.getActivity(activityId);
     if (snap) {
-      scheduledBeforeImages.set(activityId, structuredCloneActivity(snap));
       adapter.noteScheduledBefore(activityId, snap);
     }
   }
-  return { scheduledIds, scheduledBeforeImages };
+  return { scheduledIds };
 }
 function emptySchedule() {
-  return { scheduledIds: [], scheduledBeforeImages: /* @__PURE__ */ new Map() };
+  return { scheduledIds: [] };
+}
+async function refreshMutatedParentBounds(adapter, args) {
+  const mutated = args.collectDirty ? args.collectDirty([]) : collectDirtyForStructural(args.recomputeParentsFrom, []);
+  if (mutated.size === 0) return;
+  await updateParentBoundsFromChildren(adapter, mutated, false);
 }
 async function rollUpParentBounds(adapter, args, scheduledIds, passes) {
   const dirty = args.collectDirty ? args.collectDirty(scheduledIds) : collectDirtyForStructural(args.recomputeParentsFrom, scheduledIds);
@@ -9398,17 +9583,20 @@ async function rollUpParentBounds(adapter, args, scheduledIds, passes) {
     dirty,
     passes.has(DERIVED_PASS.PARENT_PROGRESS),
     {
-      recomputeRealWork: passes.has(DERIVED_PASS.REAL_WORK)
+      recomputeRealWork: passes.has(DERIVED_PASS.REAL_WORK),
+      progressMode: args.recomputeParentProgress ? "zero-when-no-contribution" : "freeze-when-no-contribution"
     }
   );
 }
 async function runDerivedRecomputes(deps, passes, now) {
   if (passes.has(DERIVED_PASS.EXPECTED_PROGRESS) && now !== null) {
-    runExpectedProgressBase(
-      deps.adapter,
-      now,
-      deps.defaultBaseCalendarId ?? null
-    );
+    if (hasActiveBaseline(deps.adapter)) {
+      runExpectedProgressBase(
+        deps.adapter,
+        now,
+        deps.defaultBaseCalendarId ?? null
+      );
+    }
     applyExpectedProgressLive(deps.adapter, now);
     applyStatusPass(deps.adapter, deps.sector.statusCriteria);
   }
@@ -9419,6 +9607,13 @@ async function runDerivedRecomputes(deps, passes, now) {
     await applyCriticalPath(deps.adapter, deps.sector.hoursPerDay);
   }
 }
+function hasActiveBaseline(adapter) {
+  let active = false;
+  adapter.forEachActivity((activity) => {
+    if (getActiveBaseline(activity)) active = true;
+  });
+  return active;
+}
 
 // src/dispatch/handlers/revert-no-op-constraint-edit.ts
 var CONSTRAINT_EDIT_COLUMNS = /* @__PURE__ */ new Set([
@@ -9429,6 +9624,9 @@ var MUST_CONSTRAINTS = /* @__PURE__ */ new Set(["mso", "mfo"]);
 function isConstraintEditColumn(column) {
   return CONSTRAINT_EDIT_COLUMNS.has(column);
 }
+function isExplicitConstraintDateEdit(column) {
+  return column === COLUMN.CONSTRAINT_DATE;
+}
 function revertNoOpConstraintEdit(activityId, priorConstraintDate, adapter, calendars) {
   const activity = adapter.getActivity(activityId);
   if (!activity) return false;
@@ -9472,7 +9670,7 @@ function sameDate(first, second) {
 
 // src/dispatch/shared/constraint-settle.ts
 async function settleConstraintEdits(deps, { postMutationArgs, revertTargets, revert }) {
-  let { scheduledIds, scheduledBeforeImages } = await runPostMutation(
+  let { scheduledIds } = await runPostMutation(
     deps,
     withCriticalPathSuppressed(postMutationArgs)
   );
@@ -9487,15 +9685,11 @@ async function settleConstraintEdits(deps, { postMutationArgs, revertTargets, re
       withCriticalPathSuppressed(postMutationArgs)
     );
     scheduledIds = mergeScheduledIds(scheduledIds, resettled.scheduledIds);
-    scheduledBeforeImages = mergeScheduledBeforeImagesFirstWins(
-      scheduledBeforeImages,
-      resettled.scheduledBeforeImages
-    );
   }
   if (resolveRunCriticalPath(postMutationArgs.action)) {
     await runPostMutation(deps, criticalPathOnlyArgs(postMutationArgs));
   }
-  return { scheduledIds, scheduledBeforeImages };
+  return { scheduledIds };
 }
 function withCriticalPathSuppressed(args) {
   return {
@@ -9517,13 +9711,6 @@ function mergeScheduledIds(firstSettleIds, secondSettleIds) {
   for (const scheduledId of secondSettleIds) merged.add(scheduledId);
   return [...merged];
 }
-function mergeScheduledBeforeImagesFirstWins(firstSettleImages, secondSettleImages) {
-  const merged = new Map(firstSettleImages);
-  for (const [imageId, image] of secondSettleImages) {
-    if (!merged.has(imageId)) merged.set(imageId, image);
-  }
-  return merged;
-}
 
 // src/dispatch/sir-auto-reject.ts
 function datesChanged(before, after) {
@@ -9558,33 +9745,12 @@ function detectSirAutoReject(beforeSnap, adapter, touchedIds) {
 
 // src/dispatch/shared/change-set.ts
 function assembleChangeSet(adapter, args) {
-  const allTouched = /* @__PURE__ */ new Set();
-  for (const id of args.touchedIds) allTouched.add(id);
-  for (const id of args.scheduledIds) allTouched.add(id);
-  if (args.includeAllIds) {
-    for (const id of adapter.getAllIds()) allTouched.add(id);
-  }
+  const allTouched = collectChangeSetIds(adapter, args);
   const before = new Map(args.beforeSnap);
   const captured = adapter.peekWriteCapture();
   if (captured) {
-    for (const id of captured.dirty) {
-      if (allTouched.has(id)) continue;
-      const beforeImg = captured.before.get(id);
-      const live = adapter.getActivity(id);
-      if (!beforeImg || !live) continue;
-      if (Object.keys(diffActivity(beforeImg, live)).length === 0) continue;
-      before.set(id, beforeImg);
-      allTouched.add(id);
-    }
-  }
-  if (args.scheduledBeforeImages) {
-    for (const [id, img] of args.scheduledBeforeImages) {
-      const sid = String(id);
-      if (!before.has(sid)) {
-        before.set(sid, img);
-        allTouched.add(sid);
-      }
-    }
+    const insertedIds = collectInsertedIds(captured);
+    mergeDirtyBeforeImages(adapter, captured, insertedIds, before, allTouched);
   }
   const beforeDiffEffects = args.sirDetection === "before-diff" ? detectSirAutoReject(before, adapter, allTouched) : [];
   const activityChanges = buildActivityChanges(adapter, before, allTouched);
@@ -9601,6 +9767,31 @@ function assembleChangeSet(adapter, args) {
     ...warnings.length > 0 ? { warnings } : {}
   };
 }
+function collectChangeSetIds(adapter, args) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const id of args.touchedIds) ids.add(id);
+  for (const id of args.scheduledIds) ids.add(id);
+  if (args.includeAllIds) {
+    for (const id of adapter.getAllIds()) ids.add(id);
+  }
+  return ids;
+}
+function mergeDirtyBeforeImages(adapter, captured, insertedIds, before, touched) {
+  for (const id of captured.dirty) {
+    if (insertedIds.has(id) || before.has(id)) continue;
+    const beforeImage = captured.before.get(id);
+    const live = adapter.getActivity(id);
+    if (!beforeImage || !live) continue;
+    if (Object.keys(diffActivity(beforeImage, live)).length === 0) continue;
+    before.set(id, beforeImage);
+    touched.add(id);
+  }
+}
+function collectInsertedIds(captured) {
+  return new Set(
+    captured.ops.filter((operation) => operation.kind === "insert").map((operation) => operation.activityId)
+  );
+}
 
 // src/dispatch/conversion.ts
 function snapshotToLink(l) {
@@ -9783,7 +9974,8 @@ async function dispatchInlineEdit(action, options, deps) {
   runPostProcessorsOnAdapter(
     action.activityId,
     changes.postProcessors ?? [],
-    adapter
+    adapter,
+    beforeSnap.get(String(action.activityId)) ?? null
   );
   const linkChanges = diffIncomingLinkLagChanges(
     beforeLinkLags,
@@ -9808,7 +10000,7 @@ async function dispatchInlineEdit(action, options, deps) {
     options
   });
   const isConstraintPath = isConstraintEditColumn(action.column);
-  const { scheduledIds, scheduledBeforeImages } = await (isConstraintPath ? settleConstraintEdits(
+  const { scheduledIds } = await (isConstraintPath ? settleConstraintEdits(
     {
       adapter,
       scheduler,
@@ -9817,9 +10009,7 @@ async function dispatchInlineEdit(action, options, deps) {
     },
     {
       postMutationArgs: buildPostMutationArgs(),
-      revertTargets: [
-        { activityId: action.activityId, priorConstraintDate }
-      ],
+      revertTargets: isExplicitConstraintDateEdit(action.column) ? [] : [{ activityId: action.activityId, priorConstraintDate }],
       revert: (activityId, capturedConstraintDate) => revertNoOpConstraintEdit(
         activityId,
         capturedConstraintDate,
@@ -9851,7 +10041,6 @@ async function dispatchInlineEdit(action, options, deps) {
       beforeSnap,
       touchedIds,
       scheduledIds,
-      scheduledBeforeImages,
       sirDetection: "before-diff",
       links: linkChanges,
       trackingEvents,
@@ -9865,6 +10054,40 @@ function columnInvalidatesExpandedLinks(column) {
 }
 
 // src/dispatch/handlers/link.ts
+function collectBatchContext(operations, adapter) {
+  const activityIds = /* @__PURE__ */ new Set();
+  const links = /* @__PURE__ */ new Map();
+  for (const operation of operations) {
+    if (operation.kind === "create") {
+      activityIds.add(String(operation.source));
+      activityIds.add(String(operation.target));
+      continue;
+    }
+    const link = adapter.getLink(operation.linkId);
+    if (!link) continue;
+    activityIds.add(String(link.source));
+    activityIds.add(String(link.target));
+    links.set(operation.linkId, { ...link });
+  }
+  return { activityIds, links };
+}
+function applyBatchOperations(operations, adapter, linkIdGen, deterministicIds) {
+  return operations.map((operation, index) => {
+    const deterministicId = operation.kind === "create" ? deterministicIds?.get(index) : void 0;
+    const result = applyLinkOperation(operation, {
+      port: adapter,
+      newLinkId: deterministicId ? () => deterministicId : linkIdGen.next
+    });
+    return {
+      op: operation,
+      finalLinkId: result.applied ? result.linkId : null,
+      rejected: result.applied ? null : result.rejected ?? "link_op_rejected"
+    };
+  });
+}
+function stringKeyedLinkSnapshots(links) {
+  return new Map([...links].map(([id, link]) => [String(id), link]));
+}
 async function dispatchLink(action, options, deps) {
   if (action.kind === "link-create" || action.kind === "link-update") {
     const type = action.type;
@@ -9922,40 +10145,14 @@ function batchOpToLinkOperation(op, hoursPerDay) {
 async function dispatchLinkBatch(operations, source, options, deps, deterministicIds) {
   const { adapter, scheduler, sector, linkIdGen } = deps;
   scheduler.invalidateAllCaches();
-  const affectedActivityIds = /* @__PURE__ */ new Set();
-  const beforeLinks = /* @__PURE__ */ new Map();
-  for (const op of operations) {
-    if (op.kind === "create") {
-      affectedActivityIds.add(String(op.source));
-      affectedActivityIds.add(String(op.target));
-    } else {
-      const link = adapter.getLink(op.linkId);
-      if (link) {
-        affectedActivityIds.add(String(link.source));
-        affectedActivityIds.add(String(link.target));
-        beforeLinks.set(op.linkId, { ...link });
-      }
-    }
-  }
+  const { activityIds: affectedActivityIds, links: beforeLinks } = collectBatchContext(operations, adapter);
   const beforeActivities = snapshotActivities(adapter, affectedActivityIds);
-  const applied = [];
-  for (let i = 0; i < operations.length; i++) {
-    const op = operations[i];
-    const detId = op.kind === "create" && deterministicIds ? deterministicIds.get(i) : void 0;
-    const result = applyLinkOperation(op, {
-      port: adapter,
-      // Si el caller pasó un id deterministic (test override, o el bridge
-      // pasando el id que DHTMLX iba a usar), lo respetamos. Si no, el
-      // generador del core arranca desde Date.now() — mismo formato que
-      // DHTMLX uid(). Ver `generators/link-id-generator.ts`.
-      newLinkId: detId ? () => detId : linkIdGen.next
-    });
-    applied.push({
-      op,
-      finalLinkId: result.applied ? result.linkId : null,
-      rejected: result.applied ? null : result.rejected ?? "link_op_rejected"
-    });
-  }
+  const applied = applyBatchOperations(
+    operations,
+    adapter,
+    linkIdGen,
+    deterministicIds
+  );
   if (operations.length === 1 && applied[0] && applied[0].rejected !== null && source.kind !== "inline-edit") {
     return { ok: false, reason: applied[0].rejected };
   }
@@ -9975,20 +10172,23 @@ async function dispatchLinkBatch(operations, source, options, deps, deterministi
       options
     }
   );
-  for (const id of scheduledIds) {
-    if (!beforeActivities.has(id)) {
-      const a = adapter.getActivity(id);
-      if (a) beforeActivities.set(id, structuredCloneActivity(a));
-    }
-  }
   const linkChanges = buildLinkChangesForBatch(applied, beforeLinks, adapter);
-  const beforeLinksByStringId = /* @__PURE__ */ new Map();
-  for (const [linkId, snap] of beforeLinks) {
-    beforeLinksByStringId.set(String(linkId), snap);
-  }
   return {
     ok: true,
-    __beforeLinks: beforeLinksByStringId,
+    linkVerdicts: applied.map(
+      (operation, operationIndex) => operation.rejected === null ? {
+        operationIndex,
+        kind: operation.op.kind,
+        ok: true,
+        linkId: String(operation.finalLinkId)
+      } : {
+        operationIndex,
+        kind: operation.op.kind,
+        ok: false,
+        reason: operation.rejected
+      }
+    ),
+    __beforeLinks: stringKeyedLinkSnapshots(beforeLinks),
     changes: assembleChangeSet(adapter, {
       source,
       beforeSnap: beforeActivities,
@@ -10361,8 +10561,7 @@ var NEW_ACTIVITY_DEFAULTS = Object.freeze({
   expectedProgress: null,
   expectedProgressBaseline: null,
   status: null,
-  criticalPath: null,
-  promotionRestore: null
+  criticalPath: null
 });
 var FIRST_ACTIVITY_TEXT = "New Master Plan";
 var NEW_ACTIVITY_TEXT = "New Activity";
@@ -10467,6 +10666,23 @@ function resolveStartDate(parent, fallback, override) {
 }
 
 // src/creation/parent-mutation-pipeline.ts
+function snapshotOf(parent) {
+  const type = parent.type;
+  if (type !== "task" && type !== "milestone") return null;
+  const startDate = parent.startDate;
+  const endDate = parent.endDate;
+  if (!(startDate instanceof Date) || !(endDate instanceof Date)) return null;
+  return {
+    type,
+    startDate: new Date(startDate),
+    endDate: new Date(endDate),
+    durationHours: Number(parent.durationHours ?? 0),
+    expectedProgressBaseline: typeof parent.expectedProgressBaseline === "number" ? parent.expectedProgressBaseline : null,
+    constraintType: parent.constraintType ?? null,
+    constraintDate: parent.constraintDate instanceof Date ? new Date(parent.constraintDate) : null,
+    progress: Number(parent.progress ?? 0)
+  };
+}
 function buildParentMutations(input) {
   const parent = input.getParent(input.parentId);
   if (!parent) return null;
@@ -10485,14 +10701,18 @@ function buildParentMutations(input) {
   }
   if (wasPromotableLeaf) {
     fields.type = PROMOTION_TARGET_TYPE;
-    fields.constraintType = CONSTRAINT_TYPE2.ASAP;
-    fields.constraintDate = null;
     if ((input.promotionSource ?? "create") === "create") {
+      fields.constraintType = CONSTRAINT_TYPE2.ASAP;
+      fields.constraintDate = null;
       fields.progress = 0;
       fields.expectedProgressBaseline = 0;
     }
   }
-  return { parentId: input.parentId, fields };
+  return {
+    parentId: input.parentId,
+    fields,
+    promotionSnapshot: snapshotOf(parent)
+  };
 }
 function isPromotableLeaf(parent) {
   return isPromotableLeafType(parent.type) && (!Array.isArray(parent.newActivityIds) || parent.newActivityIds.length === 0);
@@ -10718,6 +10938,12 @@ function applyParentMutations(action, newId, parent, adapter, preserveParentCust
     if (skipCustomIdMutation) continue;
     setActivityFieldDynamic(adapter, parentMutations.parentId, key, value);
   }
+  if (parentMutations.promotionSnapshot) {
+    adapter.setPromotionSnapshot(
+      parentMutations.parentId,
+      parentMutations.promotionSnapshot
+    );
+  }
 }
 function recomputeAndFoldCorrelatives(adapter, newId, beforeSnap, initialTouched, opts) {
   if (opts.skipCorrelativeRecompute) return;
@@ -10731,7 +10957,7 @@ function recomputeAndFoldCorrelatives(adapter, newId, beforeSnap, initialTouched
     initialTouched
   );
 }
-function buildCreateChangeSet(adapter, action, coreResult, scheduledIds, hoursPerDay, scheduledBeforeImages) {
+function buildCreateChangeSet(adapter, action, coreResult, scheduledIds, hoursPerDay) {
   const { newId, newActivity, beforeSnap, initialTouched } = coreResult;
   const trackingEvent = {
     name: DISPATCH_TRACK_EVENT.ACTIVITY_CREATION,
@@ -10744,17 +10970,11 @@ function buildCreateChangeSet(adapter, action, coreResult, scheduledIds, hoursPe
   if (action.eventSource !== void 0) {
     trackingEvent.properties.event_source = action.eventSource;
   }
-  const existingScheduledBeforeImages = scheduledBeforeImages ? new Map(
-    [...scheduledBeforeImages].filter(
-      ([scheduledId]) => String(scheduledId) !== String(newId)
-    )
-  ) : void 0;
   return assembleChangeSet(adapter, {
     source: action,
     beforeSnap,
     touchedIds: initialTouched,
     scheduledIds,
-    scheduledBeforeImages: existingScheduledBeforeImages,
     trackingEvents: [trackingEvent]});
 }
 async function dispatchActivityCreate(action, options, deps) {
@@ -10784,14 +11004,13 @@ async function dispatchActivityCreate(action, options, deps) {
   } finally {
     adapter.setActivityField(newId, "autoScheduling", createdAutoScheduling);
   }
-  const { scheduledIds, scheduledBeforeImages } = scheduleOutcome;
+  const { scheduledIds } = scheduleOutcome;
   const changeset = buildCreateChangeSet(
     adapter,
     action,
     core,
     scheduledIds,
-    sector.hoursPerDay,
-    scheduledBeforeImages
+    sector.hoursPerDay
   );
   return { ok: true, changes: changeset };
 }
@@ -10936,7 +11155,7 @@ async function dispatchActivityPaste(action, options, deps) {
       rejected: res.applied ? null : res.rejected ?? "link_op_rejected"
     });
   }
-  const { scheduledIds, scheduledBeforeImages } = await runPostMutation(
+  const { scheduledIds } = await runPostMutation(
     {
       adapter,
       scheduler,
@@ -10963,14 +11182,6 @@ async function dispatchActivityPaste(action, options, deps) {
       beforeSnap,
       touchedIds: touched,
       scheduledIds,
-      // Existing rows the autoscheduler moved need a before-image (the global
-      // beforeSnap used to supply it). Pass scheduledBeforeImages but filter out
-      // the pasted rows — their pre-schedule image would flip them to `updated`.
-      scheduledBeforeImages: new Map(
-        [...scheduledBeforeImages].filter(
-          ([schedId]) => !createdIdSet.has(String(schedId))
-        )
-      ),
       links: linkChanges,
       hoursPerDay: sector.hoursPerDay
     })
@@ -11105,10 +11316,8 @@ function collectIncidentLinkIds(activityIds, adapter) {
 }
 
 // src/internal/hierarchy/parent-demotion.ts
-function restoredPromotionFields(parent) {
-  const restore = parent.promotionRestore;
-  if (typeof restore !== "object" || restore === null) return null;
-  if (restore.type !== "task" && restore.type !== "milestone") return null;
+function restoredPromotionFields(restore) {
+  if (!restore) return null;
   return {
     type: restore.type,
     startDate: new Date(restore.startDate),
@@ -11117,16 +11326,20 @@ function restoredPromotionFields(parent) {
     expectedProgressBaseline: restore.expectedProgressBaseline,
     constraintType: restore.constraintType,
     constraintDate: restore.constraintDate ? new Date(restore.constraintDate) : null,
-    progress: restore.progress,
-    promotionRestore: null
+    progress: restore.progress
   };
 }
+function canonicalEndDateField(parent, durationHours, computeEndDate) {
+  const startDate = parent.startDate;
+  if (!computeEndDate || !(startDate instanceof Date)) return {};
+  return { endDate: computeEndDate(startDate, durationHours) };
+}
 function buildParentDemotionMutations(input) {
   if (input.remainingChildIds.length > 0) return null;
   const parent = input.parent;
   const canonicalDuration = input.defaultDurationHours;
   const hasCanonicalDefaults = Number.isFinite(canonicalDuration);
-  const fields = restoredPromotionFields(parent) ?? (hasCanonicalDefaults ? {
+  const fields = restoredPromotionFields(input.promotionSnapshot) ?? (hasCanonicalDefaults ? {
     type: DEMOTION_TARGET_TYPE,
     durationHours: canonicalDuration,
     progress: 0,
@@ -11134,7 +11347,11 @@ function buildParentDemotionMutations(input) {
     constraintType: "asap",
     constraintDate: null,
     hasNewActivities: false,
-    promotionRestore: null
+    ...canonicalEndDateField(
+      parent,
+      canonicalDuration,
+      input.computeEndDate
+    )
   } : { type: DEMOTION_TARGET_TYPE });
   if (input.idsRemoved && input.idsRemoved.size > 0) {
     const existing = Array.isArray(parent.newActivityIds) ? parent.newActivityIds : [];
@@ -11231,6 +11448,8 @@ async function dispatchActivityDelete(action, options, deps) {
       parent,
       remainingChildIds: remainingChildren.map(String),
       defaultDurationHours: sector.hoursPerDay,
+      promotionSnapshot: adapter.getPromotionSnapshot(parentId),
+      computeEndDate: (startDate, durationHours) => adapter.calculateEndDate({ startDate, durationHours, task: parent }),
       idsRemoved: toDelete
     });
     if (!demotion) {
@@ -11266,7 +11485,7 @@ async function dispatchActivityDelete(action, options, deps) {
     if (shift.before !== void 0) beforeImage.correlativeId = shift.before;
     beforeSnap.set(shift.activityId, beforeImage);
   }
-  const { scheduledIds, scheduledBeforeImages } = await runPostMutation(
+  const { scheduledIds } = await runPostMutation(
     {
       adapter,
       scheduler,
@@ -11303,7 +11522,6 @@ async function dispatchActivityDelete(action, options, deps) {
     beforeSnap,
     touchedIds,
     scheduledIds,
-    scheduledBeforeImages,
     sirDetection: "after-diff",
     links: buildLinkDeletions(beforeLinks),
     trackingEvents: [trackingEvent],
@@ -11475,6 +11693,12 @@ async function dispatchActivityMove(action, options, deps) {
           for (const [key, value] of Object.entries(promotion.fields)) {
             setActivityFieldDynamic(adapter, promotion.parentId, key, value);
           }
+          if (promotion.promotionSnapshot) {
+            adapter.setPromotionSnapshot(
+              promotion.parentId,
+              promotion.promotionSnapshot
+            );
+          }
           if (promotion.fields.customId === null) {
             releaseClearedCustomId(oldNewParentCustomId, deps.customIdTracker);
           }
@@ -11489,6 +11713,12 @@ async function dispatchActivityMove(action, options, deps) {
           parent: oldParentActivity,
           remainingChildIds: remaining.map(String),
           defaultDurationHours: sector.hoursPerDay,
+          promotionSnapshot: adapter.getPromotionSnapshot(oldParentKey),
+          computeEndDate: (startDate, durationHours) => adapter.calculateEndDate({
+            startDate,
+            durationHours,
+            task: oldParentActivity
+          }),
           idsRemoved: /* @__PURE__ */ new Set([action.activityId])
         });
         if (demotion) {
@@ -11528,7 +11758,8 @@ async function dispatchActivityMove(action, options, deps) {
     if (shift.before !== void 0) beforeImage.correlativeId = shift.before;
     beforeSnap.set(shift.activityId, beforeImage);
   }
-  const { scheduledIds, scheduledBeforeImages } = await runPostMutation(
+  const sourceParentDirtyIds = parentChanged && oldParentKey !== ROOT_PARENT_ID ? adapter.getChildren(oldParentKey).map(String) : [];
+  const { scheduledIds } = await runPostMutation(
     {
       adapter,
       scheduler,
@@ -11538,9 +11769,14 @@ async function dispatchActivityMove(action, options, deps) {
     {
       action,
       autoscheduleFrom: action.activityId,
-      recomputeParentsFrom: [action.activityId, action.parentId],
+      recomputeParentsFrom: [
+        action.activityId,
+        action.parentId,
+        ...sourceParentDirtyIds
+      ],
       now: deps.now,
-      options
+      options,
+      recomputeParentProgress: parentChanged
     }
   );
   const invalidLinkIds = parentChanged ? collectInvalidLinkIdsForCycle([action.activityId], adapter) : [];
@@ -11564,7 +11800,6 @@ async function dispatchActivityMove(action, options, deps) {
       beforeSnap,
       touchedIds: touched,
       scheduledIds,
-      scheduledBeforeImages,
       sirDetection: "before-diff",
       trackingEvents: [trackingEvent],
       hoursPerDay: sector.hoursPerDay
@@ -11654,6 +11889,12 @@ async function dispatchActivityIndent(action, options, deps) {
       for (const [key, value] of Object.entries(promotion.fields)) {
         setActivityFieldDynamic(adapter, promotion.parentId, key, value);
       }
+      if (promotion.promotionSnapshot) {
+        adapter.setPromotionSnapshot(
+          promotion.parentId,
+          promotion.promotionSnapshot
+        );
+      }
       if (!wasTrackedAsNewChild) {
         adapter.setActivityField(
           newParentId,
@@ -11699,7 +11940,7 @@ async function dispatchActivityIndent(action, options, deps) {
     if (shift.before !== void 0) beforeImage.correlativeId = shift.before;
     beforeSnap.set(shift.activityId, beforeImage);
   }
-  const { scheduledIds, scheduledBeforeImages } = await runPostMutation(
+  const { scheduledIds } = await runPostMutation(
     {
       adapter,
       scheduler,
@@ -11756,12 +11997,21 @@ async function dispatchActivityIndent(action, options, deps) {
   }
   return {
     ok: true,
+    activityVerdicts: action.activityIds.map((activityId) => {
+      const failure = failed.find(
+        (entry) => String(entry.activityId) === String(activityId)
+      );
+      return failure ? {
+        activityId: String(activityId),
+        ok: false,
+        reason: failure.reason
+      } : { activityId: String(activityId), ok: true };
+    }),
     changes: assembleChangeSet(adapter, {
       source: action,
       beforeSnap,
       touchedIds: touched,
       scheduledIds,
-      scheduledBeforeImages,
       trackingEvents: [trackingEvent],
       hoursPerDay: sector.hoursPerDay
     })
@@ -11883,6 +12133,12 @@ async function dispatchActivityOutdent(action, options, deps) {
       parent: parentActivity,
       remainingChildIds: remaining.map(String),
       defaultDurationHours: sector.hoursPerDay,
+      promotionSnapshot: adapter.getPromotionSnapshot(oldParentKey),
+      computeEndDate: (startDate, durationHours) => adapter.calculateEndDate({
+        startDate,
+        durationHours,
+        task: parentActivity
+      }),
       idsRemoved: new Set(
         planned.filter((plan) => plan.oldParentKey === oldParentKey).map((plan) => plan.activityId)
       )
@@ -11928,7 +12184,7 @@ async function dispatchActivityOutdent(action, options, deps) {
     if (shift.before !== void 0) beforeImage.correlativeId = shift.before;
     beforeSnap.set(shift.activityId, beforeImage);
   }
-  const { scheduledIds, scheduledBeforeImages } = await runPostMutation(
+  const { scheduledIds } = await runPostMutation(
     {
       adapter,
       scheduler,
@@ -11961,12 +12217,21 @@ async function dispatchActivityOutdent(action, options, deps) {
   }
   return {
     ok: true,
+    activityVerdicts: action.activityIds.map((activityId) => {
+      const failure = failed.find(
+        (entry) => String(entry.activityId) === String(activityId)
+      );
+      return failure ? {
+        activityId: String(activityId),
+        ok: false,
+        reason: failure.reason
+      } : { activityId: String(activityId), ok: true };
+    }),
     changes: assembleChangeSet(adapter, {
       source: action,
       beforeSnap,
       touchedIds: touched,
       scheduledIds,
-      scheduledBeforeImages,
       trackingEvents: [trackingEvent],
       hoursPerDay: sector.hoursPerDay
     })
@@ -12058,11 +12323,15 @@ async function dispatchDatesBatch(action, options, deps) {
     mergeBeforeSnapshots(beforeSnap, editTouched, deps);
     for (const id of editTouched) touchedIds.add(id);
     const beforeLinkLags = snapshotIncomingLinkLags(adapter, edit.activityId);
+    const preEditSnapshot = snapshotActivities(adapter, /* @__PURE__ */ new Set([String(edit.activityId)])).get(
+      String(edit.activityId)
+    ) ?? null;
     applyFieldChanges(adapter, edit.activityId, outcome.changes);
     runPostProcessorsOnAdapter(
       edit.activityId,
       outcome.changes.postProcessors ?? [],
-      adapter
+      adapter,
+      preEditSnapshot
     );
     linkChanges.push(
       ...diffIncomingLinkLagChanges(beforeLinkLags, adapter, edit.activityId)
@@ -12197,6 +12466,7 @@ async function dispatchBulkEdit(action, options, deps) {
   const verdicts = [];
   const beforeSnap = /* @__PURE__ */ new Map();
   const constraintPriorsByActivity = /* @__PURE__ */ new Map();
+  const explicitDateEditActivities = /* @__PURE__ */ new Set();
   const touchedIds = /* @__PURE__ */ new Set();
   const trackingEvents = [];
   const linkChanges = [];
@@ -12215,14 +12485,21 @@ async function dispatchBulkEdit(action, options, deps) {
     mergeBeforeSnapshots2(beforeSnap, editTouched, deps);
     for (const touchedId of editTouched) touchedIds.add(touchedId);
     recordConstraintPrior(constraintPriorsByActivity, edit, beforeSnap);
+    if (isExplicitConstraintDateEdit(edit.column)) {
+      explicitDateEditActivities.add(String(edit.activityId));
+    }
     const beforeLinkLags = snapshotIncomingLinkLags(adapter, edit.activityId);
+    const preEditSnapshot = snapshotActivities(adapter, /* @__PURE__ */ new Set([String(edit.activityId)])).get(
+      String(edit.activityId)
+    ) ?? null;
     const customIdBeforeApply = readLiveCustomId(edit, deps);
     const changes = outcome.changes;
     applyFieldChanges(adapter, edit.activityId, changes);
     runPostProcessorsOnAdapter(
       edit.activityId,
       outcome.changes.postProcessors ?? [],
-      adapter
+      adapter,
+      preEditSnapshot
     );
     syncCustomIdTracker(edit, customIdBeforeApply, deps);
     linkChanges.push(
@@ -12244,7 +12521,7 @@ async function dispatchBulkEdit(action, options, deps) {
     options
   };
   const batchHasConstraintEdits = constraintPriorsByActivity.size > 0;
-  const { scheduledIds, scheduledBeforeImages } = await (batchHasConstraintEdits ? settleConstraintEdits(
+  const { scheduledIds } = await (batchHasConstraintEdits ? settleConstraintEdits(
     {
       adapter,
       scheduler,
@@ -12253,12 +12530,12 @@ async function dispatchBulkEdit(action, options, deps) {
     },
     {
       postMutationArgs,
-      revertTargets: [...constraintPriorsByActivity].map(
-        ([activityId, priorConstraintDate]) => ({
-          activityId,
-          priorConstraintDate
-        })
-      ),
+      revertTargets: [...constraintPriorsByActivity].filter(
+        ([activityId]) => !explicitDateEditActivities.has(activityId)
+      ).map(([activityId, priorConstraintDate]) => ({
+        activityId,
+        priorConstraintDate
+      })),
       revert: (activityId, priorConstraintDate) => revertNoOpConstraintEdit(
         activityId,
         priorConstraintDate,
@@ -12286,7 +12563,6 @@ async function dispatchBulkEdit(action, options, deps) {
       // Los dependientes que mueve el autoscheduler no están en beforeSnap;
       // sin su before-image el diff los marca FALSE-CREATED y el undo los
       // borra (fix 4bbccbc de inline-edit).
-      scheduledBeforeImages,
       sirDetection: "before-diff",
       links: linkChanges,
       trackingEvents,
@@ -15885,8 +16161,15 @@ var WriteCapture = class {
   /** Pre-applyResults clone of an activity the autoscheduler will move (first-wins). */
   noteScheduledBefore(activityId, current) {
     const journal = this._journal;
-    if (!journal || journal.scheduledBefore.has(activityId)) return;
-    journal.scheduledBefore.set(activityId, cloneCoreActivity(current));
+    if (!journal) return;
+    const beforeImage = cloneCoreActivity(current);
+    if (!journal.scheduledBefore.has(activityId)) {
+      journal.scheduledBefore.set(activityId, beforeImage);
+    }
+    if (!journal.before.has(activityId)) {
+      journal.before.set(activityId, beforeImage);
+    }
+    journal.dirty.add(activityId);
   }
   /** Field write on a link — pre-mutation clone on first write per link id. */
   noteLinkField(linkId, current) {
@@ -15900,20 +16183,6 @@ var WriteCapture = class {
     });
   }
 };
-function cloneCoreActivity(activity) {
-  return {
-    ...activity,
-    startDate: new Date(activity.startDate),
-    endDate: new Date(activity.endDate),
-    constraintDate: activity.constraintDate ? new Date(activity.constraintDate) : null,
-    dateOrigin: activity.dateOrigin ? new Date(activity.dateOrigin) : null,
-    newActivityIds: [...activity.newActivityIds],
-    pendingRequestIds: [...activity.pendingRequestIds],
-    responsableIds: [...activity.responsableIds],
-    tagIds: [...activity.tagIds],
-    baselinePoints: [...activity.baselinePoints]
-  };
-}
 function cloneLink(link) {
   return { ...link };
 }
@@ -16167,6 +16436,13 @@ var ScheduleState = class {
   // whether a soft constraint repositioned the activity. Never persisted,
   // never in the ChangeSet — not domain data on CoreActivity.
   _lastStartDate = /* @__PURE__ */ new Map();
+  // Transient gesture state: what a leaf looked like right before it gained its
+  // first child and became a summary. Read by the demotion to give the activity
+  // its own values back instead of the aggregate its children left behind. Not
+  // persisted and not in the ChangeSet: it only makes sense inside the session
+  // that performed the promotion. Kept (not consumed) so undo/redo of a
+  // demotion restores identically every time.
+  _promotionSnapshot = /* @__PURE__ */ new Map();
   _links = /* @__PURE__ */ new Map();
   _outgoing = /* @__PURE__ */ new Map();
   _incoming = /* @__PURE__ */ new Map();
@@ -16182,6 +16458,7 @@ var ScheduleState = class {
   _viewState = new ViewStateStore();
   _viewStateBefore = null;
   _lastStartDateBefore = null;
+  _promotionSnapshotBefore = null;
   // Calendar arithmetic + in-dispatch memoization. Assigned in the
   // constructor once the calendar reader is built. See `CalendarCalculator`.
   _calendar;
@@ -16266,6 +16543,19 @@ var ScheduleState = class {
     this._captureLastStartDateOnce();
     this._lastStartDate.set(String(activityId), startDate);
   }
+  getPromotionSnapshot(activityId) {
+    return this._promotionSnapshot.get(String(activityId)) ?? null;
+  }
+  setPromotionSnapshot(activityId, snapshot) {
+    this._capturePromotionSnapshotOnce();
+    this._promotionSnapshot.set(String(activityId), snapshot);
+  }
+  _capturePromotionSnapshotOnce() {
+    if (this._writeCapture.peek() === null) return;
+    if (this._promotionSnapshotBefore === null) {
+      this._promotionSnapshotBefore = new Map(this._promotionSnapshot);
+    }
+  }
   _captureLastStartDateOnce() {
     if (this._writeCapture.peek() === null) return;
     if (this._lastStartDateBefore === null) {
@@ -16382,6 +16672,7 @@ var ScheduleState = class {
     this._writeCapture.begin();
     this._viewStateBefore = null;
     this._lastStartDateBefore = null;
+    this._promotionSnapshotBefore = null;
   }
   /** The live journal, or null when no capture is active. */
   peekWriteCapture() {
@@ -16392,6 +16683,7 @@ var ScheduleState = class {
     this._writeCapture.end();
     this._viewStateBefore = null;
     this._lastStartDateBefore = null;
+    this._promotionSnapshotBefore = null;
   }
   // -- Replay-specific mutators --------------------------------------------
   setActivityField(activityId, field, value) {
@@ -16543,6 +16835,9 @@ var ScheduleState = class {
     if (this._viewStateBefore !== null) {
       this._viewState.restore(this._viewStateBefore);
     }
+    if (this._promotionSnapshotBefore !== null) {
+      this._promotionSnapshot = this._promotionSnapshotBefore;
+    }
     if (this._lastStartDateBefore !== null) {
       this._lastStartDate = this._lastStartDateBefore;
     }
@@ -16675,6 +16970,13 @@ function readSelectedActivityIds(state) {
   return state.checkedIds().map(String);
 }
 function readHasChild(state, parentId) {
+  if (parentId === ROOT_PARENT_ID) {
+    let hasRoot = false;
+    state.forEachActivity((activity) => {
+      hasRoot ||= isRootParent(activity.parentId);
+    });
+    return hasRoot;
+  }
   return state.getChildren(parentId).length > 0;
 }
 function readLink(state, id) {
@@ -16817,6 +17119,7 @@ function buildInverseChangeSet(state, entry, side) {
       activities.push({
         id: activityId,
         kind: "updated",
+        fields: historyFields(change.fields, side),
         after: snapshot ? structuredCloneActivity(snapshot) : null
       });
     } else if (change.kind === "deleted") {
@@ -16850,6 +17153,7 @@ function buildInverseChangeSet(state, entry, side) {
       links.push({
         id: linkId,
         kind: "updated",
+        fields: historyFields(change.fields, side),
         after: lk ? snapshotToLink(lk) : null
       });
     } else if (change.kind === "deleted") {
@@ -16889,6 +17193,21 @@ function buildInverseChangeSet(state, entry, side) {
     viewState
   };
 }
+function historyFields(fields, side) {
+  if (fields == null) return void 0;
+  return Object.fromEntries(
+    Object.entries(fields).map(([field, values]) => [
+      field,
+      side === "before" ? {
+        before: cloneDomainValue(values.after),
+        after: cloneDomainValue(values.before)
+      } : {
+        before: cloneDomainValue(values.before),
+        after: cloneDomainValue(values.after)
+      }
+    ])
+  );
+}
 function invertViewStateChange(change) {
   return {
     activityId: change.activityId,
@@ -17427,8 +17746,7 @@ function parseActivity(raw, context) {
     expectedProgress: null,
     expectedProgressBaseline: null,
     status: null,
-    criticalPath: null,
-    promotionRestore: null
+    criticalPath: null
   };
 }
 function forceRootProjectToRoot(activities) {
@@ -18864,9 +19182,11 @@ var ScheduleCore = class {
    * ineligible to commit.
    */
   recomputeCriticalPath() {
-    return this._enqueue(async () => ({
+    const operation = this._enqueue(async () => ({
       job: this._startCriticalPathForCurrentRevision()
     })).then(({ job }) => job);
+    this._criticalPathReady = operation;
+    return operation;
   }
   isCriticalPathSettled() {
     return this._criticalPathRevision === this._scheduleRevision && this._activeCriticalPath === null;
@@ -19000,11 +19320,11 @@ var ScheduleCore = class {
     if (this.coreRuntime.clock) {
       const now = endOfLocalDay(this.coreRuntime.clock());
       applyExpectedProgressLive(state, now);
-      let hasActiveBaseline = false;
+      let hasActiveBaseline2 = false;
       state.forEachActivity((activity) => {
-        hasActiveBaseline ||= getActiveBaseline(activity) !== null;
+        hasActiveBaseline2 ||= getActiveBaseline(activity) !== null;
       });
-      if (hasActiveBaseline) {
+      if (hasActiveBaseline2) {
         runExpectedProgressBase(
           state,
           now,