@outbuild-company/schedule-core 1.6.3 → 1.7.0

package/dist/index.js

@@ -132,13 +132,19 @@ var REJECTION_REASON = {
   ACTIVITY_NOT_FOUND: "activity_not_found",
   PARENT_NOT_FOUND: "parent_not_found",
   ACTIVITY_IDS_EMPTY: "activity_ids_empty",
+  NO_ACTIVITY_SELECTION: "no_activity_selection",
+  CLIPBOARD_EMPTY: "clipboard_empty",
+  ACTIVITY_PASTE_INVARIANT_FAILED: "activity_paste_invariant_failed",
   ANCHOR_SIBLING_CONFLICT: "anchor_sibling_conflict",
   ANCHOR_SIBLING_NOT_FOUND: "anchor_sibling_not_found",
   ANCHOR_SIBLING_WRONG_PARENT: "anchor_sibling_wrong_parent",
   PARENT_FROZEN_BY_SIR: "parent_frozen_by_sir",
+  SIR_REQUEST_NOT_PENDING: "sir_request_not_pending",
+  PREVIEW_UNSUPPORTED_ACTION: "preview_unsupported_action",
   CANNOT_MOVE_INTO_OWN_DESCENDANT: "cannot_move_into_own_descendant",
   INDENT_NO_ELIGIBLE_SIBLING: "indent_no_eligible_sibling",
   OUTDENT_ROOT_LEVEL_NOT_EDITABLE: "outdent_root_level_not_editable",
+  HIERARCHY_CYCLE: "hierarchy_cycle",
   INVALID_PROGRESS_VALUE: "invalid_progress_value_must_be_0_or_100"
 };
 
@@ -267,8 +273,17 @@ function toDays(hours, hoursPerDay) {
   return hours / hoursPerDay;
 }
 function calendarDaySpan(startDate, endDate) {
-  const elapsed = endDate.getTime() - startDate.getTime();
-  return Math.floor(elapsed / MILLISECONDS_PER_DAY) + 1;
+  const startDay = Date.UTC(
+    startDate.getUTCFullYear(),
+    startDate.getUTCMonth(),
+    startDate.getUTCDate()
+  );
+  const endDay = Date.UTC(
+    endDate.getUTCFullYear(),
+    endDate.getUTCMonth(),
+    endDate.getUTCDate()
+  );
+  return Math.floor((endDay - startDay) / MILLISECONDS_PER_DAY) + 1;
 }
 var FIELD_REGISTRY = {
   name: { valueKind: "string", extract: (activity) => activity.name },
@@ -283,7 +298,10 @@ var FIELD_REGISTRY = {
   },
   uniqueCorrelativeId: {
     valueKind: "number",
-    extract: (activity) => Number(activity.uniqueCorrelativeId)
+    extract: (activity) => {
+      const value = Number(activity.uniqueCorrelativeId);
+      return Number.isFinite(value) ? value : null;
+    }
   },
   progress: { valueKind: "number", extract: (activity) => activity.progress },
   durationDays: {
@@ -292,7 +310,7 @@ var FIELD_REGISTRY = {
   },
   calendarDuration: {
     valueKind: "number",
-    extract: (activity) => calendarDaySpan(activity.startDate, activity.endDate)
+    extract: (activity) => activity.type === "milestone" ? 0 : calendarDaySpan(activity.startDate, activity.endDate)
   },
   cost: { valueKind: "number", extract: (activity) => activity.cost },
   usedCost: { valueKind: "number", extract: (activity) => activity.usedCost },
@@ -658,34 +676,102 @@ var OPERATORS_BY_KIND = {
   boolean: /* @__PURE__ */ new Set(["someOf", "notSomeOf"]),
   reference: /* @__PURE__ */ new Set(["someOf", "notSomeOf"])
 };
-function validateCriterion(criterion) {
+function normalizeDateRange(value) {
+  if (value === void 0) return { ok: true, dateRange: void 0 };
+  if (typeof value !== "object" || value === null) {
+    return { ok: false, reason: "invalid_value" };
+  }
+  const { start, end } = value;
+  if (!(start instanceof Date) || !(end instanceof Date)) {
+    return { ok: false, reason: "invalid_value" };
+  }
+  const startTime = start.getTime();
+  const endTime = end.getTime();
+  if (!Number.isFinite(startTime) || !Number.isFinite(endTime) || startTime > endTime) {
+    return { ok: false, reason: "invalid_value" };
+  }
+  return {
+    ok: true,
+    dateRange: { start: new Date(startTime), end: new Date(endTime) }
+  };
+}
+function normalizeCriterion(criterion) {
   const descriptor = getFieldDescriptor(criterion.field);
-  if (descriptor === null) return "unknown_field";
+  if (descriptor === null) return { ok: false, reason: "unknown_field" };
   if (!OPERATORS_BY_KIND[descriptor.valueKind].has(criterion.operator)) {
-    return "unknown_operator";
+    return { ok: false, reason: "unknown_operator" };
+  }
+  if (descriptor.valueKind === "number") {
+    const value = normalizeNumberValue(criterion.value);
+    return value === null ? { ok: false, reason: "invalid_value" } : {
+      ok: true,
+      criterion: { ...criterion, value }
+    };
+  }
+  if (descriptor.valueKind === "date") {
+    const value = normalizeDateValue(criterion.value);
+    return value === null ? { ok: false, reason: "invalid_value" } : {
+      ok: true,
+      criterion: { ...criterion, value }
+    };
+  }
+  const rejection = validateValueForKind(criterion, descriptor.valueKind);
+  if (rejection !== null) return { ok: false, reason: rejection };
+  if (descriptor.valueKind === "boolean") {
+    return {
+      ok: true,
+      criterion: {
+        ...criterion,
+        value: [...new Set(criterion.value)]
+      }
+    };
+  }
+  if (descriptor.valueKind === "id-array" || descriptor.valueKind === "enum" || descriptor.valueKind === "reference") {
+    return {
+      ok: true,
+      criterion: {
+        ...criterion,
+        value: [
+          ...new Set(
+            criterion.value.map(String)
+          )
+        ]
+      }
+    };
   }
-  return validateValueForKind(criterion, descriptor.valueKind);
+  return { ok: true, criterion };
 }
 function validateValueForKind(criterion, valueKind) {
   const { value } = criterion;
-  if (valueKind === "id-array" || valueKind === "enum") {
-    return Array.isArray(value) ? null : "invalid_value";
-  }
-  if (Array.isArray(value)) return "invalid_value";
-  if (valueKind === "number") {
-    return Number.isFinite(Number(value)) ? null : "invalid_value";
+  if (valueKind === "boolean") {
+    return Array.isArray(value) && value.every((item) => typeof item === "boolean") ? null : "invalid_value";
   }
-  if (valueKind === "date") {
-    return isValidDateValue(value) ? null : "invalid_value";
+  if (valueKind === "id-array" || valueKind === "enum" || valueKind === "reference") {
+    return Array.isArray(value) && value.every(
+      (item) => typeof item === "string" || typeof item === "number"
+    ) ? null : "invalid_value";
   }
+  if (Array.isArray(value)) return "invalid_value";
   return null;
 }
-function isValidDateValue(value) {
-  if (value instanceof Date) return true;
-  if (typeof value === "string" || typeof value === "number") {
-    return !Number.isNaN(new Date(value).getTime());
-  }
-  return false;
+function normalizeNumberValue(value) {
+  if (typeof value === "string" && value.trim() === "") return null;
+  if (typeof value !== "string" && typeof value !== "number") return null;
+  const parsed2 = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(parsed2) ? parsed2 : null;
+}
+function normalizeDateValue(value) {
+  let date2;
+  if (value instanceof Date) date2 = new Date(value.getTime());
+  else if (typeof value === "string") date2 = new Date(value);
+  else if (typeof value === "number") date2 = new Date(value);
+  else return null;
+  return Number.isFinite(date2.getTime()) ? date2 : null;
+}
+
+// src/shared/clone-domain-value.ts
+function cloneDomainValue(value) {
+  return structuredClone(value);
 }
 
 // src/dispatch/filter.ts
@@ -715,15 +801,21 @@ function resolveFilter(adapter, filter, hoursPerDay) {
 }
 function dispatchFilterSet(action, deps) {
   const { adapter, hoursPerDay } = deps;
+  const criteria = [];
   for (const criterion of action.criteria) {
-    const rejection = validateCriterion(criterion);
-    if (rejection !== null) return { ok: false, reason: rejection };
-  }
-  const filter = action.dateRange === void 0 ? { criteria: action.criteria, logic: action.logic } : {
-    criteria: action.criteria,
-    logic: action.logic,
-    dateRange: action.dateRange
-  };
+    const result = normalizeCriterion(criterion);
+    if (!result.ok) return { ok: false, reason: result.reason };
+    criteria.push(result.criterion);
+  }
+  const rangeResult = normalizeDateRange(action.dateRange);
+  if (!rangeResult.ok) return { ok: false, reason: rangeResult.reason };
+  const filter = cloneDomainValue(
+    rangeResult.dateRange === void 0 ? { criteria, logic: action.logic } : {
+      criteria,
+      logic: action.logic,
+      dateRange: rangeResult.dateRange
+    }
+  );
   adapter.setActiveFilter(isEmptyFilter(filter) ? null : filter);
   const { visibleIds, projection } = resolveFilter(
     adapter,
@@ -868,7 +960,7 @@ function dispatchSortSet(action, deps) {
     const rejection = validateRule(rule);
     if (rejection !== null) return { ok: false, reason: rejection };
   }
-  const order = action.rules.length === 0 ? null : { rules: action.rules };
+  const order = action.rules.length === 0 ? null : cloneDomainValue({ rules: action.rules });
   adapter.setActiveOrder(order);
   const changes = {
     source: action,
@@ -1436,6 +1528,11 @@ function isDescendantOf(childId, ancestorId, adapter) {
   }
   return false;
 }
+function isSummaryHierarchyLink(source, target, adapter) {
+  const sourceIsSummary = isSummary2(source, adapter);
+  const targetIsSummary = isSummary2(target, adapter);
+  return targetIsSummary && isDescendantOf(source, target, adapter) || sourceIsSummary && isDescendantOf(target, source, adapter);
+}
 function getLeafDescendants(parentId, adapter) {
   const leaves = [];
   const stack = [parentId];
@@ -2373,6 +2470,18 @@ var noopReporter = {
   }
 };
 
+// src/internal/state/calendar-duration.ts
+var CALENDAR_DAY_MS = 864e5;
+function computeCalendarDuration(activity) {
+  if (activity.type === "milestone") return 0;
+  const start = activity.startDate?.getTime();
+  const end = activity.endDate?.getTime();
+  if (start == null || end == null || Number.isNaN(start) || Number.isNaN(end)) {
+    return null;
+  }
+  return Math.floor((end - start) / CALENDAR_DAY_MS) + 1;
+}
+
 // src/autoscheduler/integration/apply-results.ts
 function applyResults(adapter, result) {
   if (result.cancelled || result.updatedIds.length === 0) return;
@@ -2384,6 +2493,7 @@ function applyResults(adapter, result) {
       if (!liveActivity) continue;
       liveActivity.startDate = plan.startDate;
       liveActivity.endDate = plan.endDate;
+      liveActivity.calendarDuration = computeCalendarDuration(liveActivity);
       adapter.updateActivity(id);
     }
   });
@@ -2450,13 +2560,253 @@ function hasPath(adjacency, from, to) {
   return false;
 }
 
+// src/internal/dependency-graph/strongly-connected-components.ts
+function circularComponents(edges) {
+  const walk = buildWalkState(edges);
+  for (const node of walk.adjacency.keys()) {
+    if (!walk.records.has(node)) collectFromRoot(node, walk);
+  }
+  return walk.components;
+}
+function buildWalkState(edges) {
+  const adjacency = /* @__PURE__ */ new Map();
+  const selfLooped = /* @__PURE__ */ new Set();
+  for (const edge of edges) {
+    const source = String(edge.source);
+    const target = String(edge.target);
+    const sourceNeighbors = neighborsOf(adjacency, source);
+    neighborsOf(adjacency, target);
+    if (source === target) {
+      selfLooped.add(source);
+      continue;
+    }
+    sourceNeighbors.push(target);
+  }
+  return {
+    adjacency,
+    selfLooped,
+    records: /* @__PURE__ */ new Map(),
+    componentStack: [],
+    nextIndex: 0,
+    components: []
+  };
+}
+function neighborsOf(adjacency, node) {
+  const existing = adjacency.get(node);
+  if (existing) return existing;
+  const created = [];
+  adjacency.set(node, created);
+  return created;
+}
+function collectFromRoot(root, walk) {
+  const frames = [];
+  frames.push({ node: root, record: enterNode(root, walk), neighborCursor: 0 });
+  while (frames.length > 0) {
+    const frame = frames[frames.length - 1];
+    if (frame === void 0) break;
+    const neighbors = walk.adjacency.get(frame.node) ?? [];
+    if (frame.neighborCursor < neighbors.length) {
+      const neighbor = neighbors[frame.neighborCursor];
+      frame.neighborCursor += 1;
+      if (neighbor === void 0) continue;
+      visitNeighbor(frame, neighbor, frames, walk);
+      continue;
+    }
+    frames.pop();
+    const parentFrame = frames[frames.length - 1];
+    if (parentFrame && frame.record.lowLink < parentFrame.record.lowLink) {
+      parentFrame.record.lowLink = frame.record.lowLink;
+    }
+    const isComponentRoot = frame.record.lowLink === frame.record.visitIndex;
+    if (isComponentRoot) emitComponent(frame.node, walk);
+  }
+}
+function visitNeighbor(frame, neighbor, frames, walk) {
+  const neighborRecord = walk.records.get(neighbor);
+  if (!neighborRecord) {
+    frames.push({
+      node: neighbor,
+      record: enterNode(neighbor, walk),
+      neighborCursor: 0
+    });
+    return;
+  }
+  const lowersCurrent = neighborRecord.onStack && neighborRecord.visitIndex < frame.record.lowLink;
+  if (lowersCurrent) frame.record.lowLink = neighborRecord.visitIndex;
+}
+function enterNode(node, walk) {
+  const record = {
+    visitIndex: walk.nextIndex,
+    lowLink: walk.nextIndex,
+    onStack: true
+  };
+  walk.nextIndex += 1;
+  walk.records.set(node, record);
+  walk.componentStack.push({ node, record });
+  return record;
+}
+function emitComponent(rootNode, walk) {
+  const component = [];
+  for (; ; ) {
+    const entry = walk.componentStack.pop();
+    if (entry === void 0) break;
+    entry.record.onStack = false;
+    component.push(entry.node);
+    if (entry.node === rootNode) break;
+  }
+  const firstMember = component[0];
+  const isSingleSelfLoop = component.length === 1 && firstMember !== void 0 && walk.selfLooped.has(firstMember);
+  const isCircular = component.length > 1 || isSingleSelfLoop;
+  if (isCircular) walk.components.push(component);
+}
+
+// src/internal/dependency-graph/effective-graph.ts
+function projectEffectiveEdges(port, links, proposal) {
+  const projectionPort = proposal ? new ReparentedPort(port, proposal) : port;
+  return expandParentLinks([...links], projectionPort);
+}
+var ReparentedPort = class {
+  constructor(base, proposal) {
+    this.base = base;
+    for (const [childId, proposedParent] of proposal.reparented) {
+      const childKey = String(childId);
+      const newParent = proposedParent === null || isRootParent(proposedParent) ? null : proposedParent;
+      const oldParent = base.getActivity(childId)?.parentId ?? null;
+      const oldKey = oldParent === null || isRootParent(oldParent) ? null : String(oldParent);
+      const newKey = newParent === null ? null : String(newParent);
+      if (oldKey === newKey) continue;
+      this.reparented.set(childKey, newParent);
+      if (oldKey !== null) {
+        const removed = this.movedOutByParent.get(oldKey) ?? /* @__PURE__ */ new Set();
+        removed.add(childKey);
+        this.movedOutByParent.set(oldKey, removed);
+      }
+      if (newKey !== null) {
+        const gained = this.movedInByParent.get(newKey) ?? [];
+        gained.push(childId);
+        this.movedInByParent.set(newKey, gained);
+      }
+    }
+  }
+  base;
+  reparented = /* @__PURE__ */ new Map();
+  movedOutByParent = /* @__PURE__ */ new Map();
+  movedInByParent = /* @__PURE__ */ new Map();
+  withOverride(activity) {
+    if (!activity) return null;
+    const override = this.reparented.get(String(activity.id));
+    if (override === void 0) return activity;
+    return { ...activity, parentId: override };
+  }
+  getActivity(activityId) {
+    return this.withOverride(this.base.getActivity(activityId));
+  }
+  getLiveActivity(activityId) {
+    return this.withOverride(this.base.getLiveActivity(activityId));
+  }
+  getAllActivities() {
+    return this.base.getAllActivities().map((activity) => this.withOverride(activity) ?? activity);
+  }
+  getChildren(parentId) {
+    const parentKey = String(parentId);
+    const removed = this.movedOutByParent.get(parentKey);
+    const baseChildren = this.base.getChildren(parentId);
+    const kept = removed ? baseChildren.filter((childId) => !removed.has(String(childId))) : [...baseChildren];
+    const gained = this.movedInByParent.get(parentKey);
+    if (gained) kept.push(...gained);
+    return kept;
+  }
+  getParent(activityId) {
+    const override = this.reparented.get(String(activityId));
+    if (override === void 0) return this.base.getParent(activityId);
+    if (override === null) return null;
+    return this.getActivity(override);
+  }
+  isChildOf(childId, parentId) {
+    const targetKey = String(parentId);
+    const visited = /* @__PURE__ */ new Set();
+    let current = this.getActivity(childId);
+    while (current) {
+      const parent = current.parentId;
+      if (parent === null || isRootParent(parent)) return false;
+      const parentKey = String(parent);
+      if (parentKey === targetKey) return true;
+      if (visited.has(parentKey)) return false;
+      visited.add(parentKey);
+      current = this.getActivity(parent);
+    }
+    return false;
+  }
+  getAllLinks() {
+    return this.base.getAllLinks();
+  }
+  getAllIds() {
+    return this.base.getAllIds();
+  }
+  getLink(linkId) {
+    return this.base.getLink(linkId);
+  }
+  activityExists(activityId) {
+    return this.base.activityExists(activityId);
+  }
+  getOutgoingLinkIds(activityId) {
+    return this.base.getOutgoingLinkIds(activityId);
+  }
+  getIncomingLinkIds(activityId) {
+    return this.base.getIncomingLinkIds(activityId);
+  }
+  getClosestWorkTime(params) {
+    return this.base.getClosestWorkTime(params);
+  }
+  calculateEndDate(params) {
+    return this.base.calculateEndDate(params);
+  }
+  calculateDuration(params) {
+    return this.base.calculateDuration(params);
+  }
+  batchUpdate(runBatch) {
+    this.base.batchUpdate(runBatch);
+  }
+  updateActivity(activityId) {
+    this.base.updateActivity(activityId);
+  }
+  getFlags() {
+    return this.base.getFlags();
+  }
+  getProjectEnd() {
+    return this.base.getProjectEnd();
+  }
+};
+
+// src/internal/dependency-graph/effective-graph-validation.ts
+function validateTopologyCommit(input) {
+  const { port, currentLinks, proposedLinks, proposal } = input;
+  const proposedEdges = projectEffectiveEdges(port, proposedLinks, proposal);
+  if (!hasDirectedCycle(proposedEdges)) return { ok: true };
+  const currentEdges = projectEffectiveEdges(port, currentLinks);
+  const corruptBefore = corruptActivityIds(currentEdges);
+  const corruptAfter = corruptActivityIds(proposedEdges);
+  const newlyCyclicActivityIds = [...corruptAfter].filter(
+    (activityId) => !corruptBefore.has(activityId)
+  );
+  if (newlyCyclicActivityIds.length === 0) return { ok: true };
+  return { ok: false, newlyCyclicActivityIds };
+}
+function corruptActivityIds(edges) {
+  const corrupt = /* @__PURE__ */ new Set();
+  for (const component of circularComponents(edges)) {
+    for (const activityId of component) corrupt.add(activityId);
+  }
+  return corrupt;
+}
+
 // src/autoscheduler/links/apply-link-operation.ts
 function applyLinkOperation(op, deps) {
   switch (op.kind) {
     case "create":
       return applyCreate(op, deps);
     case "update":
-      return applyUpdate(op, deps);
+      return applyLinkUpdate(op, deps.port);
     case "delete":
       return applyDelete(op, deps);
   }
@@ -2482,6 +2832,10 @@ function applyLinkCreates(links, deps) {
       rejected = { applied: false, rejected: "activity-missing" };
       break;
     }
+    if (isSummaryHierarchyLink(operation.source, operation.target, deps.port)) {
+      rejected = { applied: false, rejected: "hierarchy-link" };
+      break;
+    }
     const key = linkKey(operation);
     const duplicateId = duplicateKeys.get(key);
     if (duplicateId !== void 0) {
@@ -2507,6 +2861,24 @@ function applyLinkCreates(links, deps) {
     return { applied: false, rejected: "cycle" };
   }
   if (rejected) return rejected;
+  const proposedLinks = [
+    ...existingLinks,
+    ...links.map(({ operation, linkId }) => ({
+      id: linkId,
+      source: operation.source,
+      target: operation.target,
+      type: operation.type,
+      lag: operation.lag
+    }))
+  ];
+  const effectiveVerdict = validateTopologyCommit({
+    port: deps.port,
+    currentLinks: existingLinks,
+    proposedLinks
+  });
+  if (!effectiveVerdict.ok) {
+    return { applied: false, rejected: "cycle" };
+  }
   for (const { operation, linkId } of links) {
     const preserved = deps.preserved?.get(linkId);
     deps.port.addLink({
@@ -2535,6 +2907,9 @@ function applyCreate(op, deps) {
   if (!src || !tgt) {
     return { applied: false, rejected: "activity-missing" };
   }
+  if (isSummaryHierarchyLink(op.source, op.target, port)) {
+    return { applied: false, rejected: "hierarchy-link" };
+  }
   const existingLinks = port.getAllLinks();
   for (const l of existingLinks) {
     if (String(l.source) === String(op.source) && String(l.target) === String(op.target) && l.type === op.type) {
@@ -2556,11 +2931,18 @@ function applyCreate(op, deps) {
     type: op.type,
     lag: op.lag
   };
+  const effectiveVerdict = validateTopologyCommit({
+    port,
+    currentLinks: existingLinks,
+    proposedLinks: [...existingLinks, link]
+  });
+  if (!effectiveVerdict.ok) {
+    return { applied: false, rejected: "cycle" };
+  }
   port.addLink(link);
   return { applied: true, linkId: id };
 }
-function applyUpdate(op, deps) {
-  const { port } = deps;
+function applyLinkUpdate(op, port) {
   const link = port.getLink(op.linkId);
   if (!link) return { applied: false, rejected: "link-missing" };
   if (op.lag !== void 0) port.setLinkField(op.linkId, "lag", op.lag);
@@ -2731,6 +3113,10 @@ function diffOutgoingLinks(input) {
 }
 
 // src/autoscheduler/links/lag-units.ts
+function roundLagDays(lagDays) {
+  const rounded = Math.sign(lagDays) * Math.round(Math.abs(lagDays));
+  return Object.is(rounded, -0) ? 0 : rounded;
+}
 function lagDaysToHours(lagDays, hoursPerDay) {
   return Math.sign(lagDays) * Math.round(Math.abs(lagDays) * hoursPerDay);
 }
@@ -2993,10 +3379,7 @@ function adjustLinkLagOnTaskMove(targetId, adapter, preEditTarget) {
       calendarApi
     );
     if (newLag === link.lag) continue;
-    applyLinkOperation(
-      { kind: "update", linkId: link.id, lag: newLag },
-      { port: adapter }
-    );
+    applyLinkUpdate({ linkId: link.id, lag: newLag }, adapter);
   }
 }
 
@@ -3296,6 +3679,19 @@ function durationToHours(durationDays, hoursPerDay) {
   return Math.round(Math.ceil(durationDays * hoursPerDay * 60) / 60);
 }
 
+// src/columns/shared/error-codes.ts
+var PARSE_ERROR = {
+  NOT_A_NUMBER: "not_a_number",
+  // ISSUE-057 (CP6): la unidad de una duración se declara, no se adivina.
+  MISSING_INPUT_UNIT: "missing_input_unit",
+  // D-OWNER-5: una duración en días es entera; una fracción se rechaza sin
+  // redondear (el redondeo silencioso era la puerta del bug de las 320 horas).
+  FRACTIONAL_DAYS: "fractional_days"
+};
+var VALIDATION_REASON = {
+  UNCHANGED: "unchanged",
+  NEGATIVE_DURATION: "negative_duration"};
+
 // src/columns/end-date/setter.ts
 var setEndDate = (value) => ({
   endDate: value
@@ -3303,7 +3699,7 @@ var setEndDate = (value) => ({
 
 // src/columns/shared/date-normalize.ts
 function truncateToUtcDay(date2, tz) {
-  if (tz) {
+  {
     const parts = new Intl.DateTimeFormat("en-CA", {
       timeZone: tz,
       year: "numeric",
@@ -3313,9 +3709,6 @@ function truncateToUtcDay(date2, tz) {
     const get = (kind) => Number(parts.find((p) => p.type === kind)?.value);
     return new Date(Date.UTC(get("year"), get("month") - 1, get("day")));
   }
-  return new Date(
-    Date.UTC(date2.getFullYear(), date2.getMonth(), date2.getDate())
-  );
 }
 function endOfLocalDay(date2, tz) {
   {
@@ -3325,11 +3718,11 @@ function endOfLocalDay(date2, tz) {
   }
 }
 function nextWorkingDay(calendar, domainDay) {
-  let cursor = truncateToUtcDay(domainDay);
+  let cursor = truncateToUtcDay(domainDay, "UTC");
   while (!calendar.isWorkTime(cursor, CALENDAR_UNIT.DAY)) {
     cursor = new Date(cursor);
     cursor.setUTCDate(cursor.getUTCDate() + 1);
-    cursor = truncateToUtcDay(cursor);
+    cursor = truncateToUtcDay(cursor, "UTC");
   }
   return cursor;
 }
@@ -3367,11 +3760,12 @@ var DATELESS_CONSTRAINTS = /* @__PURE__ */ new Set([
 ]);
 var IMPLIED_CONSTRAINT_ON_DATE_EDIT = "snet";
 function normalizeConstraintDate(typedDay, calendar, constraintType) {
+  const constraintDay = truncateToUtcDay(typedDay, "UTC");
   if (!START_BASED_CONSTRAINTS2.has(constraintType) && !END_BASED_CONSTRAINTS.has(constraintType)) {
-    return typedDay;
+    return constraintDay;
   }
-  const reference = START_BASED_CONSTRAINTS2.has(constraintType) ? shiftStart(calendar, typedDay) : shiftEnd(calendar, typedDay);
-  const result = new Date(typedDay);
+  const reference = START_BASED_CONSTRAINTS2.has(constraintType) ? shiftStart(calendar, constraintDay) : shiftEnd(calendar, constraintDay);
+  const result = new Date(constraintDay);
   result.setUTCHours(
     reference.getUTCHours(),
     reference.getUTCMinutes(),
@@ -3399,10 +3793,6 @@ var POST_PROCESSOR = {
   RECORD_LAST_START_DATE: "recordLastStartDate"
 };
 
-// src/columns/shared/error-codes.ts
-var VALIDATION_REASON = {
-  NEGATIVE_DURATION: "negative_duration"};
-
 // src/columns/shared/constraint-validation.ts
 function checkConstraintViolation2(constraintType, constraintDate, projectedDate) {
   return checkConstraintViolation(constraintType, constraintDate, projectedDate);
@@ -3427,10 +3817,19 @@ var durationPipeline = {
   },
   parseInput(rawValue, _activity, ctx) {
     const numericValue = parseFloat(String(rawValue));
-    if (Number.isNaN(numericValue)) return parseError("not_a_number");
-    return parsed(
-      ctx.inputUnit === "hours" ? numericValue : durationToHours(numericValue, ctx.hoursPerDay)
-    );
+    if (!Number.isFinite(numericValue)) {
+      return parseError(PARSE_ERROR.NOT_A_NUMBER);
+    }
+    if (ctx.inputUnit === void 0) {
+      return parseError(PARSE_ERROR.MISSING_INPUT_UNIT);
+    }
+    if (ctx.inputUnit === "hours") {
+      return parsed(numericValue);
+    }
+    if (!Number.isInteger(numericValue)) {
+      return parseError(PARSE_ERROR.FRACTIONAL_DAYS);
+    }
+    return parsed(durationToHours(numericValue, ctx.hoursPerDay));
   },
   validate(_activity, oldValue, newValue) {
     if (isNegativeDuration(newValue)) {
@@ -3879,17 +4278,7 @@ var startDatePipeline = {
   transform(activity, newValue, ctx) {
     const calendar = ctx.calendars.getCalendar(activity.calendarId);
     if (!calendar) {
-      return fieldChanges(
-        {
-          startDate: newValue,
-          ...setConstraintTypeImplied(),
-          ...setConstraintDate(newValue)
-        },
-        {
-          autoSchedule: true,
-          postProcessors: ["adjustLinkLagOnTaskMove"]
-        }
-      );
+      throw new Error("startDatePipeline: no calendar resolved (integrity)");
     }
     const finalStart = shiftStart(calendar, newValue);
     const milestoneActivity = activity.type === "milestone";
@@ -3919,7 +4308,7 @@ function checkParentStartConstraint(activity, newDate, ctx) {
     activity.id
   );
   if (!parentStartDate) return null;
-  const parentDay = truncateToUtcDay(parentStartDate);
+  const parentDay = truncateToUtcDay(parentStartDate, "UTC");
   if (newDate.getTime() < parentDay.getTime()) {
     return invalid("before_parent_start");
   }
@@ -3967,7 +4356,6 @@ var endDatePipeline = {
     const calendar = ctx.calendars.getCalendar(activity.calendarId);
     if (!calendar) return parsed(day);
     if (!calendar.isWorkTime(day, CALENDAR_UNIT.DAY)) {
-      if (ctx.dateFormat.split(" ").length > 1) return parsed(day);
       return parsed(
         calendar.getClosestWorkTime({
           direction: "past",
@@ -4150,7 +4538,12 @@ var constraintDatePipeline = {
   transform(activity, newValue, ctx) {
     const finalType = isUnconstrained(activity) ? IMPLIED_CONSTRAINT_ON_DATE_EDIT : effectiveConstraintType(activity);
     const calendar = ctx.calendars.getCalendar(activity.calendarId);
-    const storedDate = calendar ? normalizeConstraintDate(newValue, calendar, finalType) : newValue;
+    if (!calendar) {
+      throw new Error(
+        "constraintDatePipeline: no calendar resolved (integrity)"
+      );
+    }
+    const storedDate = normalizeConstraintDate(newValue, calendar, finalType);
     const patch = buildConstraintDateExtraFields(activity, storedDate);
     return fieldChanges(patch, {
       autoSchedule: true
@@ -4450,6 +4843,29 @@ var COLUMN_WRITABLE_FIELDS = new Set(
   COLUMN_WRITABLE_FIELD_LIST
 );
 
+// src/constants/activity-properties.ts
+var ACTIVITY_PROPERTY = {
+  PARENT: "parentId",
+  TYPE: "type",
+  START_DATE: "startDate",
+  END_DATE: "endDate",
+  CONSTRAINT_TYPE: "constraintType",
+  CONSTRAINT_DATE: "constraintDate",
+  PROGRESS: "progress",
+  COST: "cost",
+  USED_COST: "usedCost",
+  REAL_COST: "realCost",
+  WORK_HOURS: "workHours",
+  REAL_WORK_HOURS: "realWorkHours",
+  CORRELATIVE_ID: "correlativeId",
+  CUSTOM_ID: "customId",
+  NEW_ACTIVITIES_ARRAY: "newActivityIds",
+  HAS_NEW_ACTIVITIES: "hasNewActivities",
+  CALENDAR_DURATION: "calendarDuration"};
+var LINK_PROPERTY = {
+  TYPE: "type",
+  LAG: "lag"};
+
 // src/internal/state/dynamic-writes.ts
 function setActivityFieldDynamic(state, activityId, field, value) {
   state.setActivityFieldDynamic(activityId, field, value);
@@ -4501,11 +4917,6 @@ function cloneCriticalPath(value) {
   };
 }
 
-// src/shared/clone-domain-value.ts
-function cloneDomainValue(value) {
-  return structuredClone(value);
-}
-
 // src/dispatch/shared/snapshots.ts
 var YIELD_EVERY_N_ENTRIES = 200;
 function collectTouchedIds(primary, changes) {
@@ -4617,6 +5028,7 @@ function diffActivity(before, after) {
   const beforeRec = before ?? {};
   const afterRec = after;
   const keys = /* @__PURE__ */ new Set([...Object.keys(beforeRec), ...Object.keys(afterRec)]);
+  keys.delete(ACTIVITY_PROPERTY.CALENDAR_DURATION);
   for (const k of keys) {
     if (Object.hasOwn(beforeRec, k) !== Object.hasOwn(afterRec, k) || !fieldValueEqual(beforeRec[k], afterRec[k])) {
       fields[k] = {
@@ -9291,28 +9703,6 @@ async function applyCriticalPath(state, hoursPerDay, isCurrent = () => true) {
   return true;
 }
 
-// src/constants/activity-properties.ts
-var ACTIVITY_PROPERTY = {
-  PARENT: "parentId",
-  TYPE: "type",
-  START_DATE: "startDate",
-  END_DATE: "endDate",
-  CONSTRAINT_TYPE: "constraintType",
-  CONSTRAINT_DATE: "constraintDate",
-  PROGRESS: "progress",
-  COST: "cost",
-  USED_COST: "usedCost",
-  REAL_COST: "realCost",
-  WORK_HOURS: "workHours",
-  REAL_WORK_HOURS: "realWorkHours",
-  CORRELATIVE_ID: "correlativeId",
-  CUSTOM_ID: "customId",
-  NEW_ACTIVITIES_ARRAY: "newActivityIds",
-  HAS_NEW_ACTIVITIES: "hasNewActivities"};
-var LINK_PROPERTY = {
-  TYPE: "type",
-  LAG: "lag"};
-
 // src/propagations/upward/real-cost.ts
 function emitRealCost(state) {
   const rootIds = [];
@@ -9365,6 +9755,8 @@ var NON_SCHEDULING_INLINE_COLUMNS = /* @__PURE__ */ new Set([
   COLUMN.TAGS
 ]);
 var NON_SCHEDULING_KINDS = /* @__PURE__ */ new Set([
+  "activity-clipboard-clear",
+  "activity-copy",
   "selection-toggle",
   "selection-replace",
   "visibility-set",
@@ -9378,6 +9770,8 @@ var NON_SCHEDULING_KINDS = /* @__PURE__ */ new Set([
   "status-criteria-set"
 ]);
 var PURE_VIEW_STATE_KINDS = /* @__PURE__ */ new Set([
+  "activity-clipboard-clear",
+  "activity-copy",
   "selection-toggle",
   "selection-replace",
   "visibility-set",
@@ -9703,7 +10097,8 @@ async function assembleChangeSet(adapter, args) {
     const insertedIds = collectInsertedIds(captured);
     mergeDirtyBeforeImages(adapter, captured, insertedIds, before, allTouched);
   }
-  const beforeDiffEffects = args.sirDetection === "before-diff" ? detectSirAutoReject(before, adapter, allTouched) : [];
+  const sirDetection = args.preview === true ? void 0 : args.sirDetection;
+  const beforeDiffEffects = sirDetection === "before-diff" ? detectSirAutoReject(before, adapter, allTouched) : [];
   const correlativeBefore = buildCorrelativeBeforeMap(
     args.correlativeShifts,
     allTouched
@@ -9714,7 +10109,7 @@ async function assembleChangeSet(adapter, args) {
     allTouched,
     correlativeBefore
   );
-  const effects = args.sirDetection === "after-diff" ? detectSirAutoReject(before, adapter, allTouched) : beforeDiffEffects;
+  const effects = sirDetection === "after-diff" ? detectSirAutoReject(before, adapter, allTouched) : beforeDiffEffects;
   const warnings = args.warnings ?? [];
   return {
     source: args.source,
@@ -10043,6 +10438,7 @@ async function dispatchInlineEdit(action, options, deps) {
       touchedIds,
       scheduledIds,
       sirDetection: "before-diff",
+      preview: options.preview,
       links: linkChanges,
       trackingEvents,
       ...constraintWarning ? { warnings: [constraintWarning] } : {},
@@ -10249,7 +10645,7 @@ async function dispatchInlineEditLinks(action, options, deps) {
   const { specs: specsInDays } = parsePredecessorString(action.newValue);
   const specs = specsInDays.map((spec) => ({
     ...spec,
-    lag: lagDaysToHours(spec.lag, sector.hoursPerDay)
+    lag: lagDaysToHours(roundLagDays(spec.lag), sector.hoursPerDay)
   }));
   const byCorrelative = /* @__PURE__ */ new Map();
   adapter.forEachActivity((a) => {
@@ -10586,6 +10982,11 @@ function buildNewActivity(input, adapter) {
     ...base,
     startDate,
     endDate,
+    calendarDuration: computeCalendarDuration({
+      type: base.type,
+      startDate,
+      endDate
+    }),
     newActivityIds: [...base.newActivityIds],
     pendingRequestIds: [...base.pendingRequestIds],
     responsableIds: [...base.responsableIds],
@@ -11211,6 +11612,7 @@ async function dispatchActivityDelete(action, options, deps) {
     touchedIds,
     scheduledIds,
     sirDetection: "after-diff",
+    preview: options.preview,
     links: buildLinkDeletions(beforeLinks),
     trackingEvents: [trackingEvent],
     hoursPerDay: sector.hoursPerDay,
@@ -11371,6 +11773,7 @@ async function dispatchActivityBatch(action, options, deps) {
     links: buildLinkChangesForBatch(appliedLinks, beforeLinks, deps.adapter),
     hoursPerDay: deps.sector.hoursPerDay,
     correlativeShifts: existingCorrelativeShifts,
+    preview: options.preview,
     ...action.mode === "replace" ? { sirDetection: "after-diff" } : {}
   });
   return {
@@ -11668,184 +12071,331 @@ function stringKeyedLinks(links) {
   return new Map(Array.from(links, ([linkId, link]) => [String(linkId), link]));
 }
 
-// src/dispatch/handlers/activity-paste.ts
-function resolvePasteRootDestination(destination, adapter) {
-  if ("afterSiblingId" in destination) {
-    const sibling = adapter.getActivity(destination.afterSiblingId);
-    if (!sibling) {
-      return { ok: false, reason: REJECTION_REASON.ANCHOR_SIBLING_NOT_FOUND };
-    }
-    const parentId2 = sibling.parentId == null ? ROOT_PARENT_ID : String(sibling.parentId);
-    return { ok: true, parentId: parentId2, firstAfter: destination.afterSiblingId };
+// src/dispatch/handlers/sir-sync.ts
+function dispatchSirSync(action, deps) {
+  const { adapter } = deps;
+  const id = action.activityId;
+  const snapshot = adapter.getActivity(id);
+  if (!snapshot) {
+    return { ok: false, reason: REJECTION_REASON.ACTIVITY_NOT_FOUND };
   }
-  const parentId = destination.parentId;
-  const siblings = collectSiblings(adapter, parentId).sort(
-    (a, b) => readCorrelativeId(a) - readCorrelativeId(b)
-  );
-  const before = siblings[destination.index]?.id;
-  return { ok: true, parentId, firstBefore: before };
-}
-function applyPasteDomainSemantics(overrides) {
-  const { customId: _customId, ...content } = overrides;
+  const before = snapshot.pendingRequestIds ?? [];
+  const after = action.pendingRequests.map((r) => r.id);
+  adapter.setActivityField(action.activityId, "pendingRequestIds", after);
+  const updated = adapter.getActivity(id);
+  if (!updated) {
+    return { ok: false, reason: REJECTION_REASON.ACTIVITY_NOT_FOUND };
+  }
+  const change = {
+    id,
+    kind: "updated",
+    fields: { pendingRequestIds: { before, after } },
+    // ISSUE-025: `after` must be the COMPLETE post-change entity; a partial
+    // object crashes any consumer that projects the full snapshot.
+    after: structuredCloneActivity(updated)
+  };
   return {
-    ...content,
-    progress: 0,
-    ponderator: 0,
-    usedCost: 0,
-    workHours: 0,
-    isLookahead: false
+    ok: true,
+    changes: {
+      source: action,
+      activities: [change],
+      links: [],
+      calendars: [],
+      trackingEvents: []
+    }
   };
 }
-async function dispatchActivityPaste(action, options, deps) {
+
+// src/dispatch/handlers/bulk-edit.ts
+var CUSTOM_ID_COLUMN = COLUMN.CUSTOM_ID;
+async function dispatchBulkEdit(action, options, deps) {
   const { adapter, scheduler, sector } = deps;
-  const rootDest = resolvePasteRootDestination(action.destination, adapter);
-  if (!rootDest.ok) return rootDest;
-  const beforeSnap = await snapshotActivities(adapter, /* @__PURE__ */ new Set());
-  const touched = /* @__PURE__ */ new Set();
-  const originalToNew = /* @__PURE__ */ new Map();
-  const createdIds = [];
-  let prevRootId;
-  for (const input of action.activities) {
-    const mappedParent = originalToNew.get(input.originalParentId);
-    let parentId;
-    let afterSiblingId;
-    let beforeSiblingId;
-    if (mappedParent !== void 0) {
-      parentId = mappedParent;
-    } else {
-      parentId = rootDest.parentId;
-      if (prevRootId === void 0) {
-        afterSiblingId = rootDest.firstAfter;
-        beforeSiblingId = rootDest.firstBefore;
-      } else {
-        afterSiblingId = prevRootId;
-      }
-    }
-    const core = await createActivityCore(
-      {
-        parentId,
-        afterSiblingId,
-        beforeSiblingId,
-        ...input.activityId ? { activityId: input.activityId } : {},
-        overrides: applyPasteDomainSemantics(input.overrides),
-        eventSource: action.eventSource
-      },
-      deps,
-      {
-        skipCorrelativeRecompute: true,
-        skipBeforeSnap: true,
-        customIdReferenceId: action.referenceActivityId
-      }
+  const editsIncludeDuration = action.edits.some(
+    (edit) => edit.column === COLUMN.DURATION
+  );
+  if (editsIncludeDuration) {
+    scheduler.invalidateExpandedLinksCache();
+  }
+  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 = [];
+  const warnings = [];
+  let needsAutoSchedule = false;
+  for (const edit of action.edits) {
+    const outcome = applyOneEdit(edit, deps);
+    verdicts.push(outcome.verdict);
+    if (!outcome.verdict.ok || !outcome.changes) continue;
+    const constraintWarning = toConstraintWarning(
+      edit.activityId,
+      outcome.changes.constraintWarning
     );
-    if (!core.ok) return core;
-    if (input.baselineSnapshot !== void 0) {
-      const snapshot = input.baselineSnapshot;
-      adapter.setActivityField(
-        core.newId,
-        "baselineSnapshot",
-        snapshot ? {
-          ...snapshot,
-          startDate: snapshot.startDate ? new Date(snapshot.startDate) : null,
-          endDate: snapshot.endDate ? new Date(snapshot.endDate) : null
-        } : null
-      );
+    if (constraintWarning) warnings.push(constraintWarning);
+    const editTouched = collectTouchedIds(edit.activityId, outcome.changes);
+    mergeBeforeSnapshots(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 = snapshotSingleActivity(
+      adapter,
+      String(edit.activityId)
+    );
+    const customIdBeforeApply = readLiveCustomId(edit, deps);
+    const changes = outcome.changes;
+    applyFieldChanges(adapter, edit.activityId, changes);
+    runPostProcessorsOnAdapter(
+      edit.activityId,
+      outcome.changes.postProcessors ?? [],
+      adapter,
+      preEditSnapshot
+    );
+    syncCustomIdTracker(edit, customIdBeforeApply, deps);
+    linkChanges.push(
+      ...diffIncomingLinkLagChanges(beforeLinkLags, adapter, edit.activityId)
+    );
+    needsAutoSchedule ||= Boolean(outcome.changes.needsAutoSchedule);
+    for (const trackingEvent of outcome.changes.trackingEvents ?? []) {
+      trackingEvents.push({
+        name: trackingEvent.name,
+        properties: trackingEvent.properties ?? {}
+      });
     }
-    originalToNew.set(input.originalId, core.newId);
-    createdIds.push(core.newId);
-    if (mappedParent === void 0) prevRootId = core.newId;
-  }
-  const correlativeShifts = recomputeCorrelativeIds(adapter);
-  const createdIdSet = new Set(createdIds.map(String));
-  foldCorrelativeShifts(
-    adapter,
-    correlativeShifts,
-    createdIdSet,
-    beforeSnap,
-    touched
-  );
-  for (const createdId of createdIds) touched.add(String(createdId));
-  const appliedLinks = [];
-  for (const link of action.links) {
-    const newSource = originalToNew.get(link.source);
-    const newTarget = originalToNew.get(link.target);
-    if (newSource === void 0 || newTarget === void 0) continue;
-    const op = {
-      kind: "create",
-      source: newSource,
-      target: newTarget,
-      type: link.type,
-      lag: lagDaysToHours(link.lag, sector.hoursPerDay)
-    };
-    const res = applyLinkOperation(op, {
-      port: adapter,
-      newLinkId: link.linkId ? () => link.linkId : deps.linkIdGen.next
-    });
-    appliedLinks.push({
-      op,
-      finalLinkId: res.applied ? res.linkId : null,
-      rejected: res.applied ? null : res.rejected ?? "link_op_rejected"
-    });
   }
-  const { scheduledIds } = await runPostMutation(
+  const postMutationArgs = {
+    action,
+    autoscheduleFrom: needsAutoSchedule ? "roots" : null,
+    recomputeParentsFrom: touchedIds,
+    now: deps.now,
+    options
+  };
+  const batchHasConstraintEdits = constraintPriorsByActivity.size > 0;
+  const { scheduledIds } = await (batchHasConstraintEdits ? settleConstraintEdits(
     {
       adapter,
       scheduler,
-      sector: deps.sector,
+      sector,
       defaultBaseCalendarId: deps.defaultBaseCalendarId
     },
     {
-      action,
-      autoscheduleFrom: createdIds[0] ?? null,
-      recomputeParentsFrom: createdIds,
-      now: deps.now,
-      options
+      postMutationArgs,
+      revertTargets: [...constraintPriorsByActivity].filter(
+        ([activityId]) => !explicitDateEditActivities.has(activityId)
+      ).map(([activityId, priorConstraintDate]) => ({
+        activityId,
+        priorConstraintDate
+      })),
+      revert: (activityId, priorConstraintDate) => revertNoOpConstraintEdit(
+        activityId,
+        priorConstraintDate,
+        adapter,
+        deps.ctx.calendars
+      )
     }
-  );
-  const linkChanges = buildLinkChangesForBatch(
-    appliedLinks,
-    /* @__PURE__ */ new Map(),
-    adapter
-  );
+  ) : runPostMutation(
+    {
+      adapter,
+      scheduler,
+      sector,
+      defaultBaseCalendarId: deps.defaultBaseCalendarId
+    },
+    postMutationArgs
+  ));
   return {
     ok: true,
+    verdicts,
     changes: await assembleChangeSet(adapter, {
       source: action,
       beforeSnap,
-      touchedIds: touched,
+      touchedIds,
       scheduledIds,
+      sirDetection: "before-diff",
+      preview: options.preview,
       links: linkChanges,
+      trackingEvents,
+      warnings,
       hoursPerDay: sector.hoursPerDay
     })
   };
 }
+function applyOneEdit(edit, deps) {
+  const { ctx } = deps;
+  const activityId = edit.activityId;
+  const pipeline = findPipelineForColumn(edit.column);
+  if (!pipeline) {
+    return {
+      verdict: {
+        activityId,
+        ok: false,
+        reason: REJECTION_REASON.NO_PIPELINE_FOR_COLUMN
+      },
+      changes: null
+    };
+  }
+  const activitySnap = ctx.activityReader.getActivity(edit.activityId);
+  if (!activitySnap) {
+    return {
+      verdict: {
+        activityId,
+        ok: false,
+        reason: REJECTION_REASON.ACTIVITY_NOT_FOUND
+      },
+      changes: null
+    };
+  }
+  const editGate = pipeline.canEdit(activitySnap, ctx.hierarchy);
+  if (!editGate.allowed) {
+    return {
+      verdict: {
+        activityId,
+        ok: false,
+        reason: editGate.reason ?? REJECTION_REASON.CANNOT_EDIT,
+        ...editGate.alertKey ? { alertKey: editGate.alertKey } : {}
+      },
+      changes: null
+    };
+  }
+  const parsed2 = pipeline.parseInput(edit.newValue, activitySnap, ctx);
+  if (!parsed2.ok) {
+    return {
+      verdict: {
+        activityId,
+        ok: false,
+        reason: parsed2.reason ?? REJECTION_REASON.PARSE_ERROR
+      },
+      changes: null
+    };
+  }
+  const oldValue = Reflect.get(activitySnap, pipeline.targetField);
+  const validation = pipeline.validate(
+    activitySnap,
+    oldValue,
+    parsed2.value,
+    ctx
+  );
+  if (!validation.valid) {
+    return {
+      verdict: {
+        activityId,
+        ok: false,
+        reason: validation.reason ?? REJECTION_REASON.INVALID,
+        ...validation.notification?.messageKey ? { alertKey: validation.notification.messageKey } : {}
+      },
+      changes: null
+    };
+  }
+  if (edit.column === CUSTOM_ID_COLUMN && parsed2.value !== null) {
+    const liveActivity = deps.adapter.getActivity(edit.activityId);
+    const oldCustomIdRaw = liveActivity ? liveActivity.customId : null;
+    const oldCustomId = typeof oldCustomIdRaw === "string" ? oldCustomIdRaw : null;
+    if (deps.customIdTracker.isCustomIdInUse(String(parsed2.value), oldCustomId)) {
+      return {
+        verdict: {
+          activityId,
+          ok: false,
+          reason: REJECTION_REASON.CUSTOM_ID_DUPLICATE
+        },
+        changes: null
+      };
+    }
+  }
+  const changes = pipeline.transform(
+    activitySnap,
+    parsed2.value,
+    ctx,
+    parsed2.raw
+  );
+  return { verdict: { activityId, ok: true }, changes };
+}
+function readLiveCustomId(edit, deps) {
+  if (edit.column !== CUSTOM_ID_COLUMN) return null;
+  const liveActivity = deps.adapter.getActivity(edit.activityId);
+  const rawValue = liveActivity ? liveActivity.customId : null;
+  return typeof rawValue === "string" ? rawValue : null;
+}
+function syncCustomIdTracker(edit, oldCustomId, deps) {
+  if (edit.column !== CUSTOM_ID_COLUMN) return;
+  const liveActivity = deps.adapter.getActivity(edit.activityId);
+  const rawValue = liveActivity ? liveActivity.customId : null;
+  const newCustomId = typeof rawValue === "string" ? rawValue : null;
+  if (oldCustomId !== newCustomId) {
+    deps.customIdTracker.trackCustomIdChange(oldCustomId, newCustomId);
+  }
+}
+function recordConstraintPrior(priors, edit, beforeSnap) {
+  if (!isConstraintEditColumn(edit.column)) return;
+  const activityKey = String(edit.activityId);
+  if (priors.has(activityKey)) return;
+  const preBatchSnapshot = beforeSnap.get(activityKey);
+  if (!preBatchSnapshot) return;
+  priors.set(activityKey, preBatchSnapshot.constraintDate ?? null);
+}
+function mergeBeforeSnapshots(beforeSnap, ids, deps) {
+  const missing = /* @__PURE__ */ new Set();
+  for (const candidateId of ids) {
+    if (!beforeSnap.has(candidateId)) missing.add(candidateId);
+  }
+  if (missing.size === 0) return;
+  for (const missingId of missing) {
+    const liveActivity = deps.adapter.getActivity(missingId);
+    if (liveActivity) {
+      beforeSnap.set(missingId, structuredCloneActivity(liveActivity));
+    }
+  }
+}
 
-// src/dispatch/handlers/sir-sync.ts
-function dispatchSirSync(action, deps) {
+// src/dispatch/handlers/sir-approve.ts
+async function dispatchSirApprove(action, options, deps) {
   const { adapter } = deps;
-  const id = action.activityId;
-  const snapshot = adapter.getActivity(id);
+  const snapshot = adapter.getActivity(action.activityId);
   if (!snapshot) {
     return { ok: false, reason: REJECTION_REASON.ACTIVITY_NOT_FOUND };
   }
-  const before = snapshot.pendingRequestIds ?? [];
-  const after = action.pendingRequests.map((r) => r.id);
-  adapter.setActivityField(action.activityId, "pendingRequestIds", after);
-  const change = {
-    id,
-    kind: "updated",
-    fields: { pendingRequestIds: { before, after } },
-    after: { id, pendingRequestIds: after }
-  };
-  return {
-    ok: true,
-    changes: {
-      source: action,
-      activities: [change],
-      links: [],
-      calendars: [],
-      trackingEvents: []
-    }
-  };
+  const pending = snapshot.pendingRequestIds ?? [];
+  if (!pending.includes(action.approvedRequestId)) {
+    return { ok: false, reason: REJECTION_REASON.SIR_REQUEST_NOT_PENDING };
+  }
+  const remaining = pending.filter((id) => id !== action.approvedRequestId);
+  adapter.setActivityField(action.activityId, "pendingRequestIds", remaining);
+  const result = await dispatchBulkEdit(
+    {
+      kind: "bulk-edit",
+      edits: [
+        {
+          activityId: action.activityId,
+          column: COLUMN.START_DATE,
+          newValue: action.startDate
+        },
+        {
+          activityId: action.activityId,
+          column: COLUMN.END_DATE,
+          newValue: action.endDate
+        },
+        // asap ÚLTIMO: gana al SNET implícito (paridad legacy).
+        {
+          activityId: action.activityId,
+          column: COLUMN.CONSTRAINT_TYPE,
+          newValue: "asap"
+        }
+      ],
+      eventSource: action.eventSource
+    },
+    options,
+    deps
+  );
+  if (!result.ok) return result;
+  const hardFailure = "verdicts" in result ? result.verdicts.find(
+    (verdict) => !verdict.ok && verdict.reason !== VALIDATION_REASON.UNCHANGED
+  ) : void 0;
+  if (hardFailure) {
+    return { ok: false, reason: hardFailure.reason };
+  }
+  return { ...result, changes: { ...result.changes, source: action } };
 }
 
 // src/dispatch/handlers/activity-lookahead-sync.ts
@@ -11931,7 +12481,38 @@ function isAncestor(descendantId, candidateAncestorId, adapter) {
     if (parentKey === candidateAncestorId) return true;
     cur = parentKey;
   }
-  return false;
+  return false;
+}
+
+// src/dispatch/shared/hierarchy-cycle-guard.ts
+function reparentClosesEffectiveCycle(adapter, reparented) {
+  const links = adapter.getAllLinks();
+  const verdict = validateTopologyCommit({
+    port: adapter,
+    currentLinks: links,
+    proposedLinks: links,
+    proposal: { reparented }
+  });
+  return !verdict.ok;
+}
+function collectCyclicReparents(planned, adapter) {
+  const cyclic = /* @__PURE__ */ new Set();
+  if (planned.length === 0) return cyclic;
+  const combined = new Map(
+    planned.map((reparent) => [reparent.activityId, reparent.newParentId])
+  );
+  if (!reparentClosesEffectiveCycle(adapter, combined)) return cyclic;
+  const accepted = /* @__PURE__ */ new Map();
+  for (const reparent of planned) {
+    const trial = new Map(accepted);
+    trial.set(reparent.activityId, reparent.newParentId);
+    if (reparentClosesEffectiveCycle(adapter, trial)) {
+      cyclic.add(reparent.activityId);
+      continue;
+    }
+    accepted.set(reparent.activityId, reparent.newParentId);
+  }
+  return cyclic;
 }
 
 // src/dispatch/handlers/activity-move.ts
@@ -11975,6 +12556,17 @@ async function dispatchActivityMove(action, options, deps) {
   const oldParentKey = normalizeParentKey(oldParent);
   const newParentKey = String(action.parentId);
   const parentChanged = oldParentKey !== newParentKey;
+  if (parentChanged) {
+    const reparented = /* @__PURE__ */ new Map([
+      [
+        action.activityId,
+        newParentIsRoot ? null : action.parentId
+      ]
+    ]);
+    if (reparentClosesEffectiveCycle(adapter, reparented)) {
+      return { ok: false, reason: REJECTION_REASON.HIERARCHY_CYCLE };
+    }
+  }
   const touched = /* @__PURE__ */ new Set([action.activityId]);
   if (parentChanged) {
     if (oldParentKey !== ROOT_PARENT_ID) touched.add(oldParentKey);
@@ -12126,27 +12718,21 @@ async function dispatchActivityMove(action, options, deps) {
       touchedIds: touched,
       scheduledIds,
       sirDetection: "before-diff",
+      preview: options.preview,
       trackingEvents: [trackingEvent],
       hoursPerDay: sector.hoursPerDay
     })
   };
 }
 
-// src/dispatch/handlers/activity-indent.ts
-async function dispatchActivityIndent(action, options, deps) {
-  const { adapter, scheduler, sector } = deps;
-  scheduler.invalidateAllCaches();
-  if (action.activityIds.length === 0) {
-    return { ok: false, reason: REJECTION_REASON.ACTIVITY_IDS_EMPTY };
-  }
-  const selectedSet = new Set(action.activityIds);
-  const touched = /* @__PURE__ */ new Set();
+// src/dispatch/shared/indent-planning.ts
+function planIndentMoves(activityIds, adapter) {
+  const selectedSet = new Set(activityIds);
   const failed = [];
-  const succeededIds = [];
   const moves = [];
   const plannedIds = /* @__PURE__ */ new Set();
   const blockingSet = new Set(selectedSet);
-  const sortedIds = [...action.activityIds].sort((a, b) => {
+  const sortedIds = [...activityIds].sort((a, b) => {
     const aSnap = adapter.getActivity(a);
     const bSnap = adapter.getActivity(b);
     const ac = aSnap ? readCorrelativeId(aSnap) : NOT_SET_SORT_VALUE2;
@@ -12181,12 +12767,43 @@ async function dispatchActivityIndent(action, options, deps) {
     const oldParentId = isRootParent(oldParentRaw) ? ROOT_PARENT_ID : String(oldParentRaw);
     moves.push({ activityId: id, newParentId: targetParentId, oldParentId });
     plannedIds.add(id);
-    touched.add(id);
-    touched.add(targetParentId);
-    if (oldParentId !== ROOT_PARENT_ID) touched.add(oldParentId);
   }
+  const cyclicMoveIds = collectCyclicReparents(moves, adapter);
+  for (const cyclicId of cyclicMoveIds) {
+    failed.push({
+      activityId: cyclicId,
+      reason: REJECTION_REASON.HIERARCHY_CYCLE
+    });
+  }
+  const allowedMoves = moves.filter(
+    (move) => !cyclicMoveIds.has(move.activityId)
+  );
+  return { moves, cyclicMoveIds, allowedMoves, failed };
+}
+
+// src/dispatch/handlers/activity-indent.ts
+async function dispatchActivityIndent(action, options, deps) {
+  const { adapter, scheduler, sector } = deps;
+  scheduler.invalidateAllCaches();
+  if (action.activityIds.length === 0) {
+    return { ok: false, reason: REJECTION_REASON.ACTIVITY_IDS_EMPTY };
+  }
+  const touched = /* @__PURE__ */ new Set();
+  const succeededIds = [];
+  const plan = planIndentMoves(action.activityIds, adapter);
+  const failed = [
+    ...plan.failed
+  ];
+  for (const move of plan.moves) {
+    touched.add(String(move.activityId));
+    touched.add(String(move.newParentId));
+    if (move.oldParentId !== ROOT_PARENT_ID) {
+      touched.add(String(move.oldParentId));
+    }
+  }
+  const allowedMoves = plan.allowedMoves;
   const beforeSnap = await snapshotActivities(adapter, touched);
-  for (const { activityId, newParentId } of moves) {
+  for (const { activityId, newParentId } of allowedMoves) {
     adapter.setActivityField(activityId, ACTIVITY_PROPERTY.PARENT, newParentId);
     adapter.setActivityField(
       activityId,
@@ -12196,7 +12813,7 @@ async function dispatchActivityIndent(action, options, deps) {
     succeededIds.push(activityId);
   }
   const promotedParents = /* @__PURE__ */ new Set();
-  for (const { activityId, newParentId } of moves) {
+  for (const { activityId, newParentId } of allowedMoves) {
     if (promotedParents.has(newParentId)) continue;
     promotedParents.add(newParentId);
     const newParent = adapter.getActivity(newParentId);
@@ -12248,7 +12865,7 @@ async function dispatchActivityIndent(action, options, deps) {
     releaseClearedCustomId(oldNewParentCustomId, deps.customIdTracker);
   }
   const indentAffectedParents = /* @__PURE__ */ new Set();
-  for (const m of moves) {
+  for (const m of allowedMoves) {
     if (m.oldParentId !== ROOT_PARENT_ID)
       indentAffectedParents.add(m.oldParentId);
     indentAffectedParents.add(m.newParentId);
@@ -12409,8 +13026,24 @@ async function dispatchActivityOutdent(action, options, deps) {
     if (grandparentKey !== ROOT_PARENT_ID) touched.add(String(grandparentKey));
     oldParents.add(oldParentKey);
   }
+  const cyclicPlanIds = collectCyclicReparents(
+    planned.map((plan) => ({
+      activityId: plan.activityId,
+      newParentId: plan.grandparentKey
+    })),
+    adapter
+  );
+  for (const cyclicId of cyclicPlanIds) {
+    failed.push({
+      activityId: cyclicId,
+      reason: REJECTION_REASON.HIERARCHY_CYCLE
+    });
+  }
+  const allowedPlans = planned.filter(
+    (plan) => !cyclicPlanIds.has(plan.activityId)
+  );
   const beforeSnap = await snapshotActivities(adapter, touched);
-  for (const plan of planned) {
+  for (const plan of allowedPlans) {
     adapter.setActivityField(
       plan.activityId,
       ACTIVITY_PROPERTY.PARENT,
@@ -12444,7 +13077,7 @@ async function dispatchActivityOutdent(action, options, deps) {
         task: parentActivity
       }),
       idsRemoved: new Set(
-        planned.filter((plan) => plan.oldParentKey === oldParentKey).map((plan) => plan.activityId)
+        allowedPlans.filter((plan) => plan.oldParentKey === oldParentKey).map((plan) => plan.activityId)
       )
     });
     if (!demotion) {
@@ -12470,7 +13103,7 @@ async function dispatchActivityOutdent(action, options, deps) {
   for (const oldParentKey of oldParents) {
     outdentAffectedParents.add(String(oldParentKey));
   }
-  for (const plan of planned) {
+  for (const plan of allowedPlans) {
     if (plan.grandparentKey !== ROOT_PARENT_ID) {
       outdentAffectedParents.add(String(plan.grandparentKey));
     }
@@ -12558,6 +13191,17 @@ async function dispatchActivitySetProgress(action, options, deps) {
       "[ScheduleCore] progressPipeline not registered \u2014 cannot dispatch activity-set-progress"
     );
   }
+  const editGate = pipeline.canEdit(activitySnap, ctx.hierarchy);
+  if (!editGate.allowed) {
+    const declaredButtonOverride = action.origin === "action-button" && (editGate.reason === "has_lookahead_tasks" || editGate.reason === "summary");
+    if (!declaredButtonOverride) {
+      return {
+        ok: false,
+        reason: editGate.reason,
+        ...editGate.alertKey ? { alertKey: editGate.alertKey } : {}
+      };
+    }
+  }
   const changes = pipeline.transform(
     activitySnap,
     action.newValue,
@@ -12616,11 +13260,11 @@ async function dispatchDatesBatch(action, options, deps) {
   const warnings = [];
   let needsAutoSchedule = false;
   for (const edit of action.edits) {
-    const outcome = applyOneEdit(edit, deps);
+    const outcome = applyOneEdit2(edit, deps);
     verdicts.push(outcome.verdict);
     if (!outcome.verdict.ok || !outcome.changes) continue;
     const editTouched = collectTouchedIds(edit.activityId, outcome.changes);
-    mergeBeforeSnapshots(beforeSnap, editTouched, deps);
+    mergeBeforeSnapshots2(beforeSnap, editTouched, deps);
     for (const id of editTouched) touchedIds.add(id);
     const beforeLinkLags = snapshotIncomingLinkLags(adapter, edit.activityId);
     const preEditSnapshot = snapshotSingleActivity(
@@ -12674,6 +13318,7 @@ async function dispatchDatesBatch(action, options, deps) {
       touchedIds,
       scheduledIds,
       sirDetection: "before-diff",
+      preview: options.preview,
       links: linkChanges,
       trackingEvents,
       warnings,
@@ -12681,222 +13326,18 @@ async function dispatchDatesBatch(action, options, deps) {
     })
   };
 }
-function applyOneEdit(edit, deps) {
+function applyOneEdit2(edit, deps) {
   const { ctx } = deps;
   const activityId = edit.activityId;
   const pipeline = findPipelineForColumn(edit.column);
   if (!pipeline) {
     throw new Error(
       `[ScheduleCore] no pipeline registered for column "${edit.column}"`
-    );
-  }
-  const activitySnap = ctx.activityReader.getActivity(edit.activityId);
-  if (!activitySnap) {
-    throw new Error(`[ScheduleCore] activity "${edit.activityId}" not found`);
-  }
-  const editGate = pipeline.canEdit(activitySnap, ctx.hierarchy);
-  if (!editGate.allowed) {
-    return {
-      verdict: {
-        activityId,
-        ok: false,
-        reason: editGate.reason ?? REJECTION_REASON.CANNOT_EDIT,
-        ...editGate.alertKey ? { alertKey: editGate.alertKey } : {}
-      },
-      changes: null
-    };
-  }
-  const parsed2 = pipeline.parseInput(edit.newValue, activitySnap, ctx);
-  if (!parsed2.ok) {
-    return {
-      verdict: {
-        activityId,
-        ok: false,
-        reason: parsed2.reason ?? REJECTION_REASON.PARSE_ERROR
-      },
-      changes: null
-    };
-  }
-  const oldValue = Reflect.get(activitySnap, pipeline.targetField);
-  const validation = pipeline.validate(
-    activitySnap,
-    oldValue,
-    parsed2.value,
-    ctx
-  );
-  if (!validation.valid) {
-    return {
-      verdict: {
-        activityId,
-        ok: false,
-        reason: validation.reason ?? REJECTION_REASON.INVALID,
-        ...validation.notification?.messageKey ? { alertKey: validation.notification.messageKey } : {}
-      },
-      changes: null
-    };
-  }
-  const changes = pipeline.transform(
-    activitySnap,
-    parsed2.value,
-    ctx,
-    parsed2.raw
-  );
-  return { verdict: { activityId, ok: true }, changes };
-}
-function mergeBeforeSnapshots(beforeSnap, ids, deps) {
-  const missing = /* @__PURE__ */ new Set();
-  for (const id of ids) {
-    if (!beforeSnap.has(id)) missing.add(id);
-  }
-  if (missing.size === 0) return;
-  for (const missingId of missing) {
-    const liveActivity = deps.adapter.getActivity(missingId);
-    if (liveActivity) {
-      beforeSnap.set(missingId, structuredCloneActivity(liveActivity));
-    }
-  }
-}
-
-// src/dispatch/handlers/bulk-edit.ts
-var CUSTOM_ID_COLUMN = COLUMN.CUSTOM_ID;
-async function dispatchBulkEdit(action, options, deps) {
-  const { adapter, scheduler, sector } = deps;
-  const editsIncludeDuration = action.edits.some(
-    (edit) => edit.column === COLUMN.DURATION
-  );
-  if (editsIncludeDuration) {
-    scheduler.invalidateExpandedLinksCache();
-  }
-  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 = [];
-  const warnings = [];
-  let needsAutoSchedule = false;
-  for (const edit of action.edits) {
-    const outcome = applyOneEdit2(edit, deps);
-    verdicts.push(outcome.verdict);
-    if (!outcome.verdict.ok || !outcome.changes) continue;
-    const constraintWarning = toConstraintWarning(
-      edit.activityId,
-      outcome.changes.constraintWarning
-    );
-    if (constraintWarning) warnings.push(constraintWarning);
-    const editTouched = collectTouchedIds(edit.activityId, outcome.changes);
-    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 = snapshotSingleActivity(
-      adapter,
-      String(edit.activityId)
-    );
-    const customIdBeforeApply = readLiveCustomId(edit, deps);
-    const changes = outcome.changes;
-    applyFieldChanges(adapter, edit.activityId, changes);
-    runPostProcessorsOnAdapter(
-      edit.activityId,
-      outcome.changes.postProcessors ?? [],
-      adapter,
-      preEditSnapshot
-    );
-    syncCustomIdTracker(edit, customIdBeforeApply, deps);
-    linkChanges.push(
-      ...diffIncomingLinkLagChanges(beforeLinkLags, adapter, edit.activityId)
-    );
-    needsAutoSchedule ||= Boolean(outcome.changes.needsAutoSchedule);
-    for (const trackingEvent of outcome.changes.trackingEvents ?? []) {
-      trackingEvents.push({
-        name: trackingEvent.name,
-        properties: trackingEvent.properties ?? {}
-      });
-    }
-  }
-  const postMutationArgs = {
-    action,
-    autoscheduleFrom: needsAutoSchedule ? "roots" : null,
-    recomputeParentsFrom: touchedIds,
-    now: deps.now,
-    options
-  };
-  const batchHasConstraintEdits = constraintPriorsByActivity.size > 0;
-  const { scheduledIds } = await (batchHasConstraintEdits ? settleConstraintEdits(
-    {
-      adapter,
-      scheduler,
-      sector,
-      defaultBaseCalendarId: deps.defaultBaseCalendarId
-    },
-    {
-      postMutationArgs,
-      revertTargets: [...constraintPriorsByActivity].filter(
-        ([activityId]) => !explicitDateEditActivities.has(activityId)
-      ).map(([activityId, priorConstraintDate]) => ({
-        activityId,
-        priorConstraintDate
-      })),
-      revert: (activityId, priorConstraintDate) => revertNoOpConstraintEdit(
-        activityId,
-        priorConstraintDate,
-        adapter,
-        deps.ctx.calendars
-      )
-    }
-  ) : runPostMutation(
-    {
-      adapter,
-      scheduler,
-      sector,
-      defaultBaseCalendarId: deps.defaultBaseCalendarId
-    },
-    postMutationArgs
-  ));
-  return {
-    ok: true,
-    verdicts,
-    changes: await assembleChangeSet(adapter, {
-      source: action,
-      beforeSnap,
-      touchedIds,
-      scheduledIds,
-      sirDetection: "before-diff",
-      links: linkChanges,
-      trackingEvents,
-      warnings,
-      hoursPerDay: sector.hoursPerDay
-    })
-  };
-}
-function applyOneEdit2(edit, deps) {
-  const { ctx } = deps;
-  const activityId = edit.activityId;
-  const pipeline = findPipelineForColumn(edit.column);
-  if (!pipeline) {
-    return {
-      verdict: {
-        activityId,
-        ok: false,
-        reason: REJECTION_REASON.NO_PIPELINE_FOR_COLUMN
-      },
-      changes: null
-    };
+    );
   }
   const activitySnap = ctx.activityReader.getActivity(edit.activityId);
   if (!activitySnap) {
-    return {
-      verdict: {
-        activityId,
-        ok: false,
-        reason: REJECTION_REASON.ACTIVITY_NOT_FOUND
-      },
-      changes: null
-    };
+    throw new Error(`[ScheduleCore] activity "${edit.activityId}" not found`);
   }
   const editGate = pipeline.canEdit(activitySnap, ctx.hierarchy);
   if (!editGate.allowed) {
@@ -12939,21 +13380,6 @@ function applyOneEdit2(edit, deps) {
       changes: null
     };
   }
-  if (edit.column === CUSTOM_ID_COLUMN && parsed2.value !== null) {
-    const liveActivity = deps.adapter.getActivity(edit.activityId);
-    const oldCustomIdRaw = liveActivity ? liveActivity.customId : null;
-    const oldCustomId = typeof oldCustomIdRaw === "string" ? oldCustomIdRaw : null;
-    if (deps.customIdTracker.isCustomIdInUse(String(parsed2.value), oldCustomId)) {
-      return {
-        verdict: {
-          activityId,
-          ok: false,
-          reason: REJECTION_REASON.CUSTOM_ID_DUPLICATE
-        },
-        changes: null
-      };
-    }
-  }
   const changes = pipeline.transform(
     activitySnap,
     parsed2.value,
@@ -12962,33 +13388,10 @@ function applyOneEdit2(edit, deps) {
   );
   return { verdict: { activityId, ok: true }, changes };
 }
-function readLiveCustomId(edit, deps) {
-  if (edit.column !== CUSTOM_ID_COLUMN) return null;
-  const liveActivity = deps.adapter.getActivity(edit.activityId);
-  const rawValue = liveActivity ? liveActivity.customId : null;
-  return typeof rawValue === "string" ? rawValue : null;
-}
-function syncCustomIdTracker(edit, oldCustomId, deps) {
-  if (edit.column !== CUSTOM_ID_COLUMN) return;
-  const liveActivity = deps.adapter.getActivity(edit.activityId);
-  const rawValue = liveActivity ? liveActivity.customId : null;
-  const newCustomId = typeof rawValue === "string" ? rawValue : null;
-  if (oldCustomId !== newCustomId) {
-    deps.customIdTracker.trackCustomIdChange(oldCustomId, newCustomId);
-  }
-}
-function recordConstraintPrior(priors, edit, beforeSnap) {
-  if (!isConstraintEditColumn(edit.column)) return;
-  const activityKey = String(edit.activityId);
-  if (priors.has(activityKey)) return;
-  const preBatchSnapshot = beforeSnap.get(activityKey);
-  if (!preBatchSnapshot) return;
-  priors.set(activityKey, preBatchSnapshot.constraintDate ?? null);
-}
 function mergeBeforeSnapshots2(beforeSnap, ids, deps) {
   const missing = /* @__PURE__ */ new Set();
-  for (const candidateId of ids) {
-    if (!beforeSnap.has(candidateId)) missing.add(candidateId);
+  for (const id of ids) {
+    if (!beforeSnap.has(id)) missing.add(id);
   }
   if (missing.size === 0) return;
   for (const missingId of missing) {
@@ -13051,9 +13454,33 @@ function assertValidAssignments(assignments, entityName, readCurrent, ownerByBac
     );
   }
 }
-function dispatchPersistenceAcknowledge(action, deps) {
+function assertValidReconciledProgress(entries, deps) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    const id = String(entry.activityId);
+    if (id.length === 0 || seen.has(id)) {
+      throw new Error(
+        `persistence-acknowledge: duplicate or empty reconciled activity id "${id}"`
+      );
+    }
+    if (!Number.isFinite(entry.progress) || entry.progress < 0 || entry.progress > 100) {
+      throw new Error(
+        `persistence-acknowledge: invalid reconciled progress ${String(entry.progress)} for "${id}"`
+      );
+    }
+    if (!deps.adapter.getActivity(id)) {
+      throw new Error(
+        `persistence-acknowledge: unknown reconciled activity id "${id}"`
+      );
+    }
+    seen.add(id);
+  }
+}
+async function dispatchPersistenceAcknowledge(action, deps) {
   const activities = action.activities ?? [];
   const links = action.links ?? [];
+  const reconciledProgress = action.reconciledProgress ?? [];
+  assertValidReconciledProgress(reconciledProgress, deps);
   const activityOwnerByBackendId = /* @__PURE__ */ new Map();
   for (const activity of deps.adapter.getAllActivities()) {
     if (activity.proplannerId != null) {
@@ -13089,7 +13516,49 @@ function dispatchPersistenceAcknowledge(action, deps) {
   );
   const activityChanges = [];
   const linkChanges = [];
+  const progressToApply = reconciledProgress.filter((entry) => {
+    const current = deps.adapter.getActivity(String(entry.activityId));
+    return current !== null && current.progress !== entry.progress;
+  });
+  const touchedForProgress = new Set(
+    progressToApply.map((entry) => String(entry.activityId))
+  );
+  const parentsToRollup = /* @__PURE__ */ new Set();
+  for (const entry of progressToApply) {
+    const activity = deps.adapter.getActivity(String(entry.activityId));
+    if (activity && !isRootParent(activity.parentId)) {
+      parentsToRollup.add(String(activity.parentId));
+      touchedForProgress.add(String(activity.parentId));
+    }
+  }
+  const beforeProgressSnap = await snapshotActivities(
+    deps.adapter,
+    touchedForProgress
+  );
   deps.adapter.batchUpdate(() => {
+    for (const entry of progressToApply) {
+      deps.adapter.setActivityField(
+        String(entry.activityId),
+        "progress",
+        entry.progress
+      );
+    }
+    for (const parentId of parentsToRollup) {
+      recomputeRollupCascadesForParent(parentId, deps.adapter);
+    }
+    for (const id of touchedForProgress) {
+      const before = beforeProgressSnap.get(id);
+      const after = deps.adapter.getActivity(id);
+      if (!before || !after || before.progress === after.progress) continue;
+      activityChanges.push({
+        id,
+        kind: "updated",
+        fields: {
+          progress: { before: before.progress, after: after.progress }
+        },
+        after: { ...after }
+      });
+    }
     for (const assignment of activities) {
       const before = deps.adapter.getActivity(assignment.id);
       if (!before || before.proplannerId === assignment.proplannerId) continue;
@@ -13496,8 +13965,218 @@ async function dispatchStatusCriteriaSet(action, deps) {
   };
 }
 
+// src/activity-copy-paste/policy.ts
+var ACTIVITY_COPY_FIELDS = [
+  "name",
+  "description",
+  "type",
+  "startDate",
+  "durationHours",
+  "constraintType",
+  "constraintDate",
+  "calendarId",
+  "cost",
+  "hasCustomPonderator",
+  "subcontractId",
+  "responsableIds",
+  "tagIds"
+];
+
+// src/activity-copy-paste/copy.ts
+function copyOverrides(activity) {
+  const overrides = {};
+  for (const field of ACTIVITY_COPY_FIELDS) {
+    Object.assign(overrides, { [field]: cloneDomainValue(activity[field]) });
+  }
+  return overrides;
+}
+function selectedInTreeOrder(adapter, selected) {
+  const ordered = [];
+  const visit = (id) => {
+    if (selected.has(String(id))) ordered.push(id);
+    for (const childId of adapter.getChildren(id)) visit(childId);
+  };
+  for (const rootId of adapter.getRootIds()) visit(rootId);
+  return ordered;
+}
+function dispatchActivityCopy(action, deps) {
+  const selected = new Set(deps.adapter.checkedIds().map(String));
+  if (selected.size === 0) {
+    return { ok: false, reason: REJECTION_REASON.NO_ACTIVITY_SELECTION };
+  }
+  const orderedIds = selectedInTreeOrder(deps.adapter, selected);
+  deps.clipboard.value = {
+    activities: orderedIds.map((id) => {
+      const activity = deps.adapter.getActivity(id);
+      if (activity === null)
+        throw new Error(`Selected activity ${id} is missing`);
+      return {
+        originalId: id,
+        originalParentId: activity.parentId ?? "0",
+        overrides: copyOverrides(activity)
+      };
+    }),
+    links: deps.adapter.getAllLinks().filter(
+      (link) => selected.has(String(link.source)) && selected.has(String(link.target))
+    ).map((link) => cloneDomainValue(link))
+  };
+  const selection = dispatchSelectionReplace(
+    { kind: "selection-replace", activityIds: [] },
+    { adapter: deps.adapter }
+  );
+  if (!selection.ok) return selection;
+  return { ...selection, changes: { ...selection.changes, source: action } };
+}
+function dispatchActivityClipboardClear(action, clipboard) {
+  clipboard.value = null;
+  return {
+    ok: true,
+    changes: {
+      source: action,
+      activities: [],
+      links: [],
+      calendars: [],
+      trackingEvents: []
+    }
+  };
+}
+
+// src/activity-copy-paste/paste.ts
+function resolveDestination(afterSiblingId, adapter) {
+  const sibling = adapter.getActivity(afterSiblingId);
+  if (!sibling) {
+    return { ok: false, reason: REJECTION_REASON.ANCHOR_SIBLING_NOT_FOUND };
+  }
+  return {
+    ok: true,
+    parentId: sibling.parentId == null ? ROOT_PARENT_ID : String(sibling.parentId)
+  };
+}
+var invariantFailure = () => ({
+  ok: false,
+  reason: REJECTION_REASON.ACTIVITY_PASTE_INVARIANT_FAILED
+});
+async function dispatchActivityPasteCopied(action, options, deps) {
+  const clipboard = deps.activityClipboard.value;
+  if (clipboard === null) {
+    return { ok: false, reason: REJECTION_REASON.CLIPBOARD_EMPTY };
+  }
+  const destination = resolveDestination(
+    action.destination.afterSiblingId,
+    deps.adapter
+  );
+  if (!destination.ok) return destination;
+  const beforeSnapshot = await snapshotActivities(
+    deps.adapter,
+    /* @__PURE__ */ new Set()
+  );
+  const touched = /* @__PURE__ */ new Set();
+  const originalToNew = /* @__PURE__ */ new Map();
+  const createdIds = [];
+  let previousRootId;
+  for (const copied of clipboard.activities) {
+    const mappedParent = originalToNew.get(copied.originalParentId);
+    const created = await createActivityCore(
+      {
+        parentId: mappedParent ?? destination.parentId,
+        ...mappedParent === void 0 ? {
+          afterSiblingId: previousRootId ?? action.destination.afterSiblingId
+        } : {},
+        overrides: cloneDomainValue(copied.overrides),
+        eventSource: action.eventSource
+      },
+      deps,
+      {
+        skipCorrelativeRecompute: true,
+        skipBeforeSnap: true,
+        customIdReferenceId: action.destination.afterSiblingId
+      }
+    );
+    if (!created.ok) return created;
+    originalToNew.set(copied.originalId, created.newId);
+    createdIds.push(created.newId);
+    if (mappedParent === void 0) previousRootId = created.newId;
+  }
+  const correlativeShifts = recomputeCorrelativeIds(deps.adapter);
+  const createdIdSet = new Set(createdIds.map(String));
+  foldCorrelativeShifts(
+    deps.adapter,
+    correlativeShifts,
+    createdIdSet,
+    beforeSnapshot,
+    touched
+  );
+  for (const createdId of createdIds) touched.add(String(createdId));
+  const appliedLinks = [];
+  for (const copiedLink of clipboard.links) {
+    const source = originalToNew.get(copiedLink.source);
+    const target = originalToNew.get(copiedLink.target);
+    if (source === void 0 || target === void 0) return invariantFailure();
+    const operation = {
+      kind: "create",
+      source,
+      target,
+      type: copiedLink.type,
+      lag: copiedLink.lag
+    };
+    const result = applyLinkOperation(operation, {
+      port: deps.adapter,
+      newLinkId: deps.linkIdGen.next
+    });
+    if (!result.applied) return invariantFailure();
+    appliedLinks.push({
+      op: operation,
+      finalLinkId: result.linkId,
+      rejected: null
+    });
+  }
+  const { scheduledIds } = await runPostMutation(
+    {
+      adapter: deps.adapter,
+      scheduler: deps.scheduler,
+      sector: deps.sector,
+      defaultBaseCalendarId: deps.defaultBaseCalendarId
+    },
+    {
+      action,
+      autoscheduleFrom: createdIds[0] ?? null,
+      recomputeParentsFrom: createdIds,
+      now: deps.now,
+      options
+    }
+  );
+  const linkChanges = buildLinkChangesForBatch(
+    appliedLinks,
+    /* @__PURE__ */ new Map(),
+    deps.adapter
+  );
+  return {
+    ok: true,
+    changes: await assembleChangeSet(deps.adapter, {
+      source: action,
+      beforeSnap: beforeSnapshot,
+      touchedIds: touched,
+      scheduledIds,
+      links: linkChanges,
+      hoursPerDay: deps.sector.hoursPerDay
+    })
+  };
+}
+
 // src/dispatch/dispatch.ts
 async function performDispatch(action, options, deps) {
+  if (action.kind === "activity-copy") {
+    return dispatchActivityCopy(action, {
+      adapter: deps.adapter,
+      clipboard: deps.activityClipboard
+    });
+  }
+  if (action.kind === "activity-clipboard-clear") {
+    return dispatchActivityClipboardClear(action, deps.activityClipboard);
+  }
+  if (action.kind === "activity-paste-copied") {
+    return dispatchActivityPasteCopied(action, options, deps);
+  }
   if (action.kind === "activity-batch") {
     return dispatchActivityBatch(action, options, deps);
   }
@@ -13522,9 +14201,6 @@ async function performDispatch(action, options, deps) {
   if (action.kind === "activity-create") {
     return dispatchActivityCreate(action, options, deps);
   }
-  if (action.kind === "activity-paste") {
-    return dispatchActivityPaste(action, options, deps);
-  }
   if (action.kind === "activity-delete") {
     return dispatchActivityDelete(action, options, deps);
   }
@@ -13567,6 +14243,9 @@ async function performDispatch(action, options, deps) {
   if (action.kind === "sir-sync") {
     return dispatchSirSync(action, deps);
   }
+  if (action.kind === "sir-approve") {
+    return dispatchSirApprove(action, options, deps);
+  }
   if (action.kind === "activity-lookahead-sync") {
     return dispatchActivityLookaheadSync(action, deps);
   }
@@ -16979,6 +17658,7 @@ var ScheduleState = class {
     if (!activity) return;
     this._writeCapture.note(String(activityId), activity);
     activity[field] = value;
+    refreshCalendarDurationIfDateBearing(activity, field);
     if (field === ACTIVITY_PROPERTY.PARENT) this._hierarchy.markDirty();
     if (fieldAffectsVisualOrder(field)) this._cache.visualOrderIds = null;
   }
@@ -16992,6 +17672,7 @@ var ScheduleState = class {
     }
     this._writeCapture.note(String(activityId), activity);
     Reflect.set(activity, field, coerceActivityFieldValue(field, value));
+    refreshCalendarDurationIfDateBearing(activity, field);
     if (field === ACTIVITY_PROPERTY.PARENT) this._hierarchy.markDirty();
     if (fieldAffectsVisualOrder(field)) this._cache.visualOrderIds = null;
   }
@@ -17002,6 +17683,7 @@ var ScheduleState = class {
     let reparented = false;
     for (const field of Object.keys(fields)) {
       Reflect.set(activity, field, Reflect.get(fields, field));
+      refreshCalendarDurationIfDateBearing(activity, field);
       if (field === ACTIVITY_PROPERTY.PARENT) reparented = true;
       if (fieldAffectsVisualOrder(field)) this._cache.visualOrderIds = null;
     }
@@ -17170,6 +17852,12 @@ function isMutableLinkField(field) {
 function fieldAffectsVisualOrder(field) {
   return field === ACTIVITY_PROPERTY.PARENT || field === ACTIVITY_PROPERTY.CORRELATIVE_ID;
 }
+function refreshCalendarDurationIfDateBearing(activity, field) {
+  if (field !== ACTIVITY_PROPERTY.START_DATE && field !== ACTIVITY_PROPERTY.END_DATE && field !== ACTIVITY_PROPERTY.TYPE) {
+    return;
+  }
+  activity.calendarDuration = computeCalendarDuration(activity);
+}
 function detachLinkRef(refs, linkId) {
   return refs.filter((ref) => String(ref) !== String(linkId));
 }
@@ -17217,15 +17905,7 @@ function readChildren(state, parentId) {
   return out;
 }
 function readChildrenIds(state, parentId) {
-  const key = parentId;
-  if (key === ROOT_PARENT_ID) {
-    const roots = [];
-    state.forEachActivity((activity, id) => {
-      if (isRootParent(activity.parentId)) roots.push(id);
-    });
-    return roots;
-  }
-  return getChildrenInVisualOrder(key, state);
+  return getChildrenInVisualOrder(parentId, state);
 }
 function readSelectedActivityIds(state) {
   return state.checkedIds().map(String);
@@ -17289,7 +17969,11 @@ function buildPipelineContext(adapter, options) {
     dateFormat: options.dateFormat ?? "YYYY-MM-DD",
     customHours: options.customHours ?? {},
     hoursPerDay: options.hoursPerDay,
-    inputUnit: options.inputUnit ?? "days"
+    // ISSUE-057 (CP6): sin default. Un comando de duración sin inputUnit se
+    // rechaza en el pipeline; el resto de columnas no lo leen. La clave se
+    // OMITE cuando no se declaró (exactOptionalPropertyTypes), no se pone a
+    // undefined.
+    ...options.inputUnit !== void 0 ? { inputUnit: options.inputUnit } : {}
   };
 }
 
@@ -17369,9 +18053,10 @@ function mergeCoalesced(top, next) {
   };
   return buildUndoEntry(changeSet);
 }
-function getDispatchHistoryPolicy(action) {
+function getDispatchHistoryPolicy(action, options) {
+  if (options?.preview === true) return "skip";
   if (action.kind === "persistence-acknowledge") return "clear-on-success";
-  if (action.kind === "sir-sync" || action.kind === "activity-lookahead-sync" || action.kind === "baseline-apply" || action.kind === "ponderator-criterion-set" || action.kind === "status-criteria-set" || action.kind === "selection-toggle" || action.kind === "selection-replace" || action.kind === "visibility-set" || action.kind === "filter-set" || action.kind === "sort-set") {
+  if (action.kind === "sir-sync" || action.kind === "activity-lookahead-sync" || action.kind === "baseline-apply" || action.kind === "ponderator-criterion-set" || action.kind === "status-criteria-set" || action.kind === "activity-clipboard-clear" || action.kind === "activity-copy" || action.kind === "selection-toggle" || action.kind === "selection-replace" || action.kind === "visibility-set" || action.kind === "filter-set" || action.kind === "sort-set") {
     return "skip";
   }
   return "record";
@@ -18155,6 +18840,11 @@ function parseActivity(raw, context) {
       Number(raw.sumOfDurationRecursively ?? 0),
       context.hoursPerDay
     ),
+    calendarDuration: computeCalendarDuration({
+      type: raw.type,
+      startDate,
+      endDate
+    }),
     isCritical: Boolean(raw.is_critical),
     freeSlackHours: null,
     expectedProgress: null,
@@ -18519,7 +19209,8 @@ function parseSector(sector) {
     ...customIdIncrement !== void 0 ? { customIdIncrement } : {},
     ...isPrimaveraEndDate ? { updateDurationForPrimaveraEndDate: true } : {},
     activityCreter: parseActivityCreter(sector.activity_creter),
-    statusCriteria: DEFAULT_STATUS_CRITERIA
+    statusCriteria: DEFAULT_STATUS_CRITERIA,
+    ganttId: null
   };
 }
 
@@ -19311,6 +20002,7 @@ function recomputeSkippedLeafEnds(state) {
       durationHours: activity.durationHours,
       task: activity
     });
+    activity.calendarDuration = computeCalendarDuration(activity);
   });
 }
 function recomputeDurationsFromDates(state) {
@@ -19382,6 +20074,7 @@ function initializeCore(input) {
   );
   const sector = parsed2.sector;
   sector.statusCriteria = resolveStatusCriteria(input.statusCriteria);
+  sector.ganttId = input.ganttId ?? null;
   const calendars = parsed2.calendars;
   const baseCalendars = parsed2.baseCalendars ?? [];
   const snapshot = buildStateSnapshot(
@@ -19588,6 +20281,7 @@ function evaluateEnd(formula, proposedEdgeTimeMs) {
 }
 
 // src/init/schedule-core.ts
+var PREVIEW_DISPATCH_KINDS = /* @__PURE__ */ new Set(["inline-edit", "bulk-edit", "dates-batch"]);
 function changesRequireFilterProjectionRebuild(changes) {
   for (const change of changes.activities) {
     if (change.kind === "deleted") return true;
@@ -19612,6 +20306,7 @@ function isCurrentFilterProjection(projection, filter, context) {
   return hasCurrentHours && hasCurrentLocale;
 }
 var ScheduleCore = class {
+  _activityClipboard = { value: null };
   _status = SCHEDULE_CORE_STATUS.READY;
   coreRuntime;
   _undo = new UndoRecorder();
@@ -19707,6 +20402,23 @@ var ScheduleCore = class {
     this.assertReady();
     return readAllActivities(this.coreRuntime.state);
   }
+  /**
+   * Read del plan de indent (ISSUE-080): los padres destino DISTINTOS bajo los
+   * que quedarían las actividades si se indentaran ahora. Es exactamente la
+   * planificación que ejecuta el handler (`planIndentMoves`, autoridad única),
+   * expuesta para que la frontera pueda correr el protocolo de conversión a
+   * madre (chequeo backend + modal) ANTES de despachar. Solo lecturas.
+   */
+  getIndentTargetParentIds(activityIds) {
+    this.assertReady();
+    const plan = planIndentMoves(
+      activityIds.map((id) => String(id)),
+      this.coreRuntime.state
+    );
+    return [
+      ...new Set(plan.allowedMoves.map((move) => String(move.newParentId)))
+    ];
+  }
   getChildrenView(parentId) {
     this.assertReady();
     return readChildren(this.coreRuntime.state, parentId);
@@ -19719,6 +20431,26 @@ var ScheduleCore = class {
     this.assertReady();
     return readAllLinks(this.coreRuntime.state);
   }
+  auditEffectiveGraph() {
+    this.assertReady();
+    const state = this.coreRuntime.state;
+    const logicalLinks = state.getAllLinks();
+    const effectiveEdges = projectEffectiveEdges(state, logicalLinks);
+    const components = circularComponents(effectiveEdges);
+    let largestComponentSize = 0;
+    for (const component of components) {
+      if (component.length > largestComponentSize) {
+        largestComponentSize = component.length;
+      }
+    }
+    return {
+      activityCount: state.getAllIds().length,
+      logicalLinkCount: logicalLinks.length,
+      effectiveEdgeCount: effectiveEdges.length,
+      circularComponents: components,
+      largestComponentSize
+    };
+  }
   getProperty(activityId, property) {
     this.assertReady();
     const snapshot = this.coreRuntime.state.getActivity(activityId);
@@ -19747,11 +20479,11 @@ var ScheduleCore = class {
   }
   getActiveFilter() {
     this.assertReady();
-    return this.coreRuntime.state.getActiveFilter();
+    return cloneDomainValue(this.coreRuntime.state.getActiveFilter());
   }
   getActiveOrder() {
     this.assertReady();
-    return this.coreRuntime.state.getActiveOrder();
+    return cloneDomainValue(this.coreRuntime.state.getActiveOrder());
   }
   getVisualOrderIds() {
     this.assertReady();
@@ -19802,6 +20534,74 @@ var ScheduleCore = class {
     this.assertReady();
     return this._saveTracker.hasUnsavedChanges();
   }
+  /**
+   * Read-only view of the internal schedule revision. It moves once per
+   * substantive CANONICAL mutation (dispatch, undo, redo). It does NOT move
+   * for a preview dispatch nor for `applyPreviewInverse`: comparing the value
+   * captured in `PreviewDispatchInfo.revision` against the current one
+   * answers "did the schedule change while the preview was open".
+   */
+  getScheduleRevision() {
+    return this._scheduleRevision;
+  }
+  /**
+   * Exit channel for a preview dispatch (`DispatchOptions.preview`): applies
+   * the inverse ChangeSet the preview returned, restoring the canonical
+   * state exactly. Like the preview itself it leaves no session trace: no
+   * save-tracker dirty, no undo entry, no effects, and the schedule revision
+   * does not move (see `getScheduleRevision`).
+   *
+   * Returns the ChangeSet to project to the view layer: the same changes as
+   * `inverse`, but with `after` images re-read from the restored state (the
+   * ones inside `inverse` were captured while the preview edit was applied).
+   */
+  applyPreviewInverse(inverse) {
+    return this._enqueue(async () => {
+      this.assertReady();
+      const state = this.coreRuntime.state;
+      const afterSnap = /* @__PURE__ */ new Map();
+      for (const change of inverse.activities) {
+        if (change.kind !== "deleted" && change.after) {
+          afterSnap.set(
+            String(change.id),
+            structuredCloneActivity(change.after)
+          );
+        }
+      }
+      const afterLinks = /* @__PURE__ */ new Map();
+      for (const change of inverse.links) {
+        if (change.kind !== "deleted" && change.after) {
+          afterLinks.set(String(change.id), { ...change.after });
+        }
+      }
+      const entry = buildUndoEntry(
+        inverse,
+        void 0,
+        void 0,
+        afterSnap,
+        afterLinks
+      );
+      applyRedo(state, entry);
+      if (needsResync(entry)) this._resyncCustomIdTrackerFromModel();
+      const restored = {
+        ...inverse,
+        activities: inverse.activities.map((change) => {
+          if (change.kind === "deleted") return { ...change, after: null };
+          const live = state.getActivity(String(change.id));
+          return {
+            ...change,
+            after: live ? structuredCloneActivity(live) : null
+          };
+        }),
+        links: inverse.links.map((change) => {
+          if (change.kind === "deleted") return { ...change, after: null };
+          const live = state.getLink(String(change.id));
+          return { ...change, after: live ? snapshotToLink(live) : null };
+        })
+      };
+      return this._reapplyViewState(restored) ?? restored;
+    });
+  }
   getDeletedActivitiesSinceLastSave() {
     this.assertReady();
     return this._saveTracker.deletedActivities(this.coreRuntime.state.getAllActivities()).map(cloneDomainValue);
@@ -19884,11 +20684,11 @@ var ScheduleCore = class {
     });
   }
   async dispatch(action, options = {}) {
-    const admitted = this._beginScheduleMutation(action);
+    const admitted = options.preview === true ? false : this._beginScheduleMutation(action);
     return this._enqueue(() => this._dispatchInner(action, options, admitted));
   }
   async applyActivityBatch(action, options = {}) {
-    const admitted = this._beginScheduleMutation(action);
+    const admitted = options.preview === true ? false : this._beginScheduleMutation(action);
     return this._enqueue(() => this._dispatchInner(action, options, admitted));
   }
   async _dispatchInner(action, options = {}, admitted = false) {
@@ -19903,12 +20703,23 @@ var ScheduleCore = class {
   }
   async _runDispatch(action, options) {
     this.assertReady();
+    if (options.preview === true && !PREVIEW_DISPATCH_KINDS.has(action.kind)) {
+      return {
+        result: {
+          ok: false,
+          reason: REJECTION_REASON.PREVIEW_UNSUPPORTED_ACTION
+        },
+        changedState: false
+      };
+    }
     const pipelineContext = buildPipelineContext(this.coreRuntime.state, {
       hoursPerDay: this.coreRuntime.sector.hoursPerDay,
       dateFormat: this.coreRuntime.sector.dateFormat,
-      inputUnit: options.inputUnit ?? "days"
+      // ISSUE-057 (CP6): sin default silencioso 'days'; la clave se omite si
+      // no se declaró (exactOptionalPropertyTypes).
+      ...options.inputUnit !== void 0 ? { inputUnit: options.inputUnit } : {}
     });
-    const historyPolicy = getDispatchHistoryPolicy(action);
+    const historyPolicy = getDispatchHistoryPolicy(action, options);
     const generatorSnapshot = [
       this.coreRuntime.activityIdGenerator.snapshot(),
       this.coreRuntime.linkIdGenerator.snapshot(),
@@ -19929,6 +20740,7 @@ var ScheduleCore = class {
         uidGen: this.coreRuntime.uniqueCorrelativeIdGenerator,
         customIdTracker: this.coreRuntime.customIdTracker,
         reporter: this.coreRuntime.reporter,
+        activityClipboard: this._activityClipboard,
         defaultBaseCalendarId: this.coreRuntime.baseCalendars.find(
           (calendar) => calendar.baseDefault
         )?.id ?? null,
@@ -19971,7 +20783,7 @@ var ScheduleCore = class {
           action.activityIds,
           (activityId) => this.coreRuntime.state.getActivity(activityId)
         );
-      } else {
+      } else if (options.preview !== true) {
         this._saveTracker.recordChanges(
           result.changes.activities,
           result.changes.links,
@@ -19982,6 +20794,20 @@ var ScheduleCore = class {
     }
     result = this._withReappliedViewState(action, result);
     if (!result.ok) return { result, changedState: false };
+    if (options.preview === true) {
+      const inverse = buildInverseChangeSet(
+        this.coreRuntime.state,
+        buildUndoEntry(buildHistoryChangeSet(result.changes)),
+        "before"
+      );
+      return {
+        result: {
+          ...toPublicDispatchResult(result),
+          preview: { inverse, revision: this._scheduleRevision }
+        },
+        changedState: false
+      };
+    }
     if (dispatchChangesSchedulingState(action) && changeSetIsSubstantive(result.changes)) {
       this._recordScheduleMutation(
         options.skipAutoSchedule !== true && options.skipCriticalPath !== true && resolveRunCriticalPath(action)
@@ -20496,6 +21322,9 @@ var DEFAULT_HOURS_PER_DAY = 8;
 
 // src/dispatch/action-kinds.ts
 var DISPATCH_ACTION_KIND = {
+  ACTIVITY_CLIPBOARD_CLEAR: "activity-clipboard-clear",
+  ACTIVITY_COPY: "activity-copy",
+  ACTIVITY_PASTE_COPIED: "activity-paste-copied",
   PERSISTENCE_ACKNOWLEDGE: "persistence-acknowledge",
   BASELINE_APPLY: "baseline-apply",
   PONDERATOR_CRITERION_SET: "ponderator-criterion-set",
@@ -20513,16 +21342,19 @@ var DISPATCH_ACTION_KIND = {
   ACTIVITY_INDENT: "activity-indent",
   ACTIVITY_OUTDENT: "activity-outdent",
   ACTIVITY_SET_PROGRESS: "activity-set-progress",
-  ACTIVITY_PASTE: "activity-paste",
   SELECTION_TOGGLE: "selection-toggle",
   SELECTION_REPLACE: "selection-replace",
   VISIBILITY_SET: "visibility-set",
   FILTER_SET: "filter-set",
   SORT_SET: "sort-set",
   SIR_SYNC: "sir-sync",
+  SIR_APPROVE: "sir-approve",
   ACTIVITY_LOOKAHEAD_SYNC: "activity-lookahead-sync"
 };
 var KIND_CATALOG_COVERS_UNION = {
+  [DISPATCH_ACTION_KIND.ACTIVITY_CLIPBOARD_CLEAR]: true,
+  [DISPATCH_ACTION_KIND.ACTIVITY_COPY]: true,
+  [DISPATCH_ACTION_KIND.ACTIVITY_PASTE_COPIED]: true,
   [DISPATCH_ACTION_KIND.PERSISTENCE_ACKNOWLEDGE]: true,
   [DISPATCH_ACTION_KIND.BASELINE_APPLY]: true,
   [DISPATCH_ACTION_KIND.PONDERATOR_CRITERION_SET]: true,
@@ -20540,13 +21372,13 @@ var KIND_CATALOG_COVERS_UNION = {
   [DISPATCH_ACTION_KIND.ACTIVITY_INDENT]: true,
   [DISPATCH_ACTION_KIND.ACTIVITY_OUTDENT]: true,
   [DISPATCH_ACTION_KIND.ACTIVITY_SET_PROGRESS]: true,
-  [DISPATCH_ACTION_KIND.ACTIVITY_PASTE]: true,
   [DISPATCH_ACTION_KIND.SELECTION_TOGGLE]: true,
   [DISPATCH_ACTION_KIND.SELECTION_REPLACE]: true,
   [DISPATCH_ACTION_KIND.VISIBILITY_SET]: true,
   [DISPATCH_ACTION_KIND.FILTER_SET]: true,
   [DISPATCH_ACTION_KIND.SORT_SET]: true,
   [DISPATCH_ACTION_KIND.SIR_SYNC]: true,
+  [DISPATCH_ACTION_KIND.SIR_APPROVE]: true,
   [DISPATCH_ACTION_KIND.ACTIVITY_LOOKAHEAD_SYNC]: true
 };
 var DISPATCH_ACTION_KINDS = Object.keys(KIND_CATALOG_COVERS_UNION);