fix: SNET/FNET constraints on non-working days round forward

When a "Start No Earlier Than" or "Finish No Earlier Than" constraint
date falls on a non-working day (weekend/holiday), the scheduler was
rounding BACKWARD to the previous working day instead of FORWARD to
the next working day.

Example: SNET = 2018-06-03 (Sunday)
- Before: task scheduled on 2018-06-01 (Friday) - WRONG
- After:  task scheduled on 2018-06-04 (Monday) - CORRECT

Root cause: `date_to_working_days()` counts working days up to (but not
including) the target date. For floor constraints, if the target is a
non-working day, we need to advance to the next working day first.

Fix:
- Add `advance_to_working_day()` helper function
- Apply it to SNET, FNET, MustStartOn, and MustFinishOn constraints
- Ceiling constraints (SNLT, FNLT) correctly round backward (unchanged)

Fixes the CTL PIII milestone scheduling bug where task_24 "[7.6] TTG
Release" was scheduled 2 days early.

Tests: 3 new tests for SNET on non-working days (task, milestone, nested)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: alanbld

Cargo.toml

@@ -14,7 +14,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.9.1"
+version = "0.9.2"
 edition = "2021"
 rust-version = "1.75"
 license = "MIT OR Apache-2.0"
@@ -24,10 +24,10 @@ categories = ["command-line-utilities", "development-tools"]
 
 [workspace.dependencies]
 # Internal crates (version required for crates.io publishing)
-utf8proj-core = { version = "0.9.1", path = "crates/utf8proj-core" }
-utf8proj-parser = { version = "0.9.1", path = "crates/utf8proj-parser" }
-utf8proj-solver = { version = "0.9.1", path = "crates/utf8proj-solver" }
-utf8proj-render = { version = "0.9.1", path = "crates/utf8proj-render" }
+utf8proj-core = { version = "0.9.2", path = "crates/utf8proj-core" }
+utf8proj-parser = { version = "0.9.2", path = "crates/utf8proj-parser" }
+utf8proj-solver = { version = "0.9.2", path = "crates/utf8proj-solver" }
+utf8proj-render = { version = "0.9.2", path = "crates/utf8proj-render" }
 
 # Date/Time
 chrono = { version = "0.4", features = ["serde"] }

crates/utf8proj-solver/src/lib.rs

@@ -701,6 +701,16 @@ fn date_to_working_days(project_start: NaiveDate, target: NaiveDate, calendar: &
     working_days
 }
 
+/// Advance a date to the next working day if it falls on a non-working day.
+/// Used for "no earlier than" constraints where we need to round forward.
+fn advance_to_working_day(date: NaiveDate, calendar: &Calendar) -> NaiveDate {
+    let mut current = date;
+    while !calendar.is_working_day(current) {
+        current = current + TimeDelta::days(1);
+    }
+    current
+}
+
 /// Result of topological sort including precomputed successor map
 struct TopoSortResult {
     /// Tasks in topological order
@@ -2830,16 +2840,36 @@ impl Scheduler for CpmSolver {
                         let mut min_finish: Option<i64> = None;
                         for constraint in &task.constraints {
                             match constraint {
-                                TaskConstraint::MustStartOn(date)
-                                | TaskConstraint::StartNoEarlierThan(date) => {
+                                TaskConstraint::MustStartOn(date) => {
+                                    // MustStartOn pins to exact date (or next working day if non-working)
+                                    let effective_date = advance_to_working_day(*date, &calendar);
+                                    let constraint_days =
+                                        date_to_working_days(project.start, effective_date, &calendar);
+                                    es = es.max(constraint_days);
+                                }
+                                TaskConstraint::StartNoEarlierThan(date) => {
+                                    // SNET: if constraint date is non-working, round FORWARD to next working day
+                                    // Example: SNET=Sunday → task starts Monday (not Friday)
+                                    let effective_date = advance_to_working_day(*date, &calendar);
                                     let constraint_days =
-                                        date_to_working_days(project.start, *date, &calendar);
+                                        date_to_working_days(project.start, effective_date, &calendar);
                                     es = es.max(constraint_days);
                                 }
-                                TaskConstraint::MustFinishOn(date)
-                                | TaskConstraint::FinishNoEarlierThan(date) => {
+                                TaskConstraint::MustFinishOn(date) => {
+                                    // MustFinishOn pins to exact date (or next working day if non-working)
+                                    let effective_date = advance_to_working_day(*date, &calendar);
+                                    let constraint_days =
+                                        date_to_working_days(project.start, effective_date, &calendar);
+                                    let exclusive_ef = constraint_days + 1;
+                                    min_finish = Some(
+                                        min_finish.map_or(exclusive_ef, |mf| mf.max(exclusive_ef)),
+                                    );
+                                }
+                                TaskConstraint::FinishNoEarlierThan(date) => {
+                                    // FNET: if constraint date is non-working, round FORWARD to next working day
+                                    let effective_date = advance_to_working_day(*date, &calendar);
                                     let constraint_days =
-                                        date_to_working_days(project.start, *date, &calendar);
+                                        date_to_working_days(project.start, effective_date, &calendar);
                                     let exclusive_ef = constraint_days + 1;
                                     min_finish = Some(
                                         min_finish.map_or(exclusive_ef, |mf| mf.max(exclusive_ef)),

crates/utf8proj-solver/tests/constraint_wiring.rs

@@ -364,3 +364,94 @@ fn feasible_window_fits() {
     assert_eq!(schedule.tasks["bounded"].finish, date(2025, 1, 17));
     assert_eq!(schedule.tasks["bounded"].slack, Duration::zero());
 }
+
+// =============================================================================
+// Non-Working Day Constraint Tests
+// =============================================================================
+
+#[test]
+fn snet_on_sunday_rounds_forward_to_monday() {
+    // Bug reproduction: SNET constraint on a non-working day should round FORWARD
+    // to the next working day, not backward to the previous working day.
+    //
+    // Example: SNET = 2025-01-12 (Sunday)
+    // Expected: task starts on 2025-01-13 (Monday)
+    // Bug: task was starting on 2025-01-10 (Friday)
+    let mut project = Project::new("SNET Sunday Test");
+    project.start = date(2025, 1, 6); // Monday
+
+    let mut task = Task::new("constrained").effort(Duration::days(5));
+    task.constraints
+        .push(TaskConstraint::StartNoEarlierThan(date(2025, 1, 12))); // Sunday!
+    project.tasks.push(task);
+
+    let solver = CpmSolver::new();
+    let schedule = solver.schedule(&project).unwrap();
+
+    // Task should start on Monday 2025-01-13 (next working day after Sunday)
+    // NOT Friday 2025-01-10 (previous working day)
+    assert_eq!(
+        schedule.tasks["constrained"].start,
+        date(2025, 1, 13),
+        "SNET on Sunday should round forward to Monday, not backward to Friday"
+    );
+}
+
+#[test]
+fn snet_milestone_on_weekend_rounds_forward() {
+    // Same bug for milestones (which have zero duration)
+    let mut project = Project::new("SNET Milestone Weekend");
+    project.start = date(2025, 1, 6); // Monday
+
+    let mut milestone = Task::new("milestone");
+    milestone.milestone = true;
+    milestone
+        .constraints
+        .push(TaskConstraint::StartNoEarlierThan(date(2025, 1, 11))); // Saturday!
+    project.tasks.push(milestone);
+
+    let solver = CpmSolver::new();
+    let schedule = solver.schedule(&project).unwrap();
+
+    // Milestone should be on Monday 2025-01-13 (next working day after weekend)
+    assert_eq!(
+        schedule.tasks["milestone"].start,
+        date(2025, 1, 13),
+        "SNET milestone on Saturday should round forward to Monday"
+    );
+}
+
+#[test]
+fn nested_milestone_snet_on_weekend() {
+    // Reproduce the exact bug from CTL PIII: nested milestone with SNET on weekend
+    let mut project = Project::new("Nested SNET");
+    project.start = date(2025, 1, 6); // Monday
+
+    // Container with a nested milestone
+    let mut container = Task::new("container");
+    container.name = "Container".to_string();
+
+    let mut child = Task::new("child").effort(Duration::days(3));
+    child.name = "Child".to_string();
+
+    let mut milestone = Task::new("release");
+    milestone.name = "Release".to_string();
+    milestone.milestone = true;
+    milestone
+        .constraints
+        .push(TaskConstraint::StartNoEarlierThan(date(2025, 1, 19))); // Sunday!
+
+    container.children.push(child);
+    container.children.push(milestone);
+    project.tasks.push(container);
+
+    let solver = CpmSolver::new();
+    let schedule = solver.schedule(&project).unwrap();
+
+    // Nested milestone should be on Monday 2025-01-20 (next working day)
+    assert_eq!(
+        schedule.tasks["container.release"].start,
+        date(2025, 1, 20),
+        "Nested milestone SNET on Sunday should round forward to Monday"
+    );
+}