From 42edbd9f70e955cdc0b34a639a62a607e9f19ec7 Mon Sep 17 00:00:00 2001 From: Vittorio Distefano Date: Tue, 17 Nov 2026 17:56:26 +0100 Subject: [PATCH 1/5] feat(scaffold): target SolverForge 0.31.1 Generated projects now depend on solverforge 0.31.1, so a scaffold builds against the release that carries list element groups, joint cascading groups, planning ids in constraint matches, the resolved phase plan in final telemetry and the list-shadow row rescoring. Hosts that link a generated project's domain and constraints into their own SolverForge build, such as the SolverForge Workbench, need the project on the same release; on 0.26.1 the project's Plan implements a different crate's traits and cannot be hosted. The neutral templates compile unchanged against 0.31.1; the scaffold assertions move to the new target. --- src/scaffold_target.rs | 12 ++++++------ tests/scaffold_test.rs | 40 ++++++++++++++++++++-------------------- 2 files changed, 26 insertions(+), 26 deletions(-) diff --git a/src/scaffold_target.rs b/src/scaffold_target.rs index 2b10004..09fbc0e 100644 --- a/src/scaffold_target.rs +++ b/src/scaffold_target.rs @@ -1,13 +1,13 @@ -pub const RUNTIME_CRATE_VERSION: &str = "0.26.1"; +pub const RUNTIME_CRATE_VERSION: &str = "0.31.1"; pub const UI_CRATE_VERSION: &str = "0.9.1"; pub const MAPS_CRATE_VERSION: &str = "2.3.3"; pub const MCP_CRATE_VERSION: &str = "3.9.0"; -pub const RUNTIME_TARGET_LABEL: &str = "solverforge 0.26.1"; +pub const RUNTIME_TARGET_LABEL: &str = "solverforge 0.31.1"; pub const UI_TARGET_LABEL: &str = "solverforge-ui 0.9.1"; pub const MAPS_TARGET_LABEL: &str = "solverforge-maps 2.3.3"; -pub const RUNTIME_TARGET_DISPLAY: &str = "SolverForge crate target 0.26.1"; -pub const RUNTIME_SOURCE_PATH: &str = "crates.io: solverforge 0.26.1"; +pub const RUNTIME_TARGET_DISPLAY: &str = "SolverForge crate target 0.31.1"; +pub const RUNTIME_SOURCE_PATH: &str = "crates.io: solverforge 0.31.1"; pub const UI_SOURCE_PATH: &str = "crates.io: solverforge-ui 0.9.1"; pub const MAPS_SOURCE_PATH: &str = "crates.io: solverforge-maps 2.3.3"; pub const MCP_SOURCE_PATH: &str = "crates.io: rmcp 3.9.0"; @@ -18,12 +18,12 @@ pub const LONG_VERSION_TEXT: &str = concat!( env!("CARGO_PKG_VERSION"), "\nCLI version: ", env!("CARGO_PKG_VERSION"), - "\nScaffold runtime target: SolverForge crate target 0.26.1", + "\nScaffold runtime target: SolverForge crate target 0.31.1", "\nScaffold UI target: solverforge-ui 0.9.1", "\nScaffold maps target: solverforge-maps 2.3.3", "\nScaffold MCP target: rmcp 3.9.0", "\nRuntime source: ", - "crates.io: solverforge 0.26.1", + "crates.io: solverforge 0.31.1", "\nUI source: ", "crates.io: solverforge-ui 0.9.1", "\nMaps source: ", diff --git a/tests/scaffold_test.rs b/tests/scaffold_test.rs index e40a478..961e3d2 100644 --- a/tests/scaffold_test.rs +++ b/tests/scaffold_test.rs @@ -19,13 +19,13 @@ use dependency_overrides::{ use network_retry::cargo_with_network_retry; use scaffold_generated_app::ScaffoldGeneratedApp; -const RUNTIME_DEP_LABEL: &str = "crates.io: solverforge 0.26.1"; +const RUNTIME_DEP_LABEL: &str = "crates.io: solverforge 0.31.1"; const UI_DEP_LABEL: &str = "crates.io: solverforge-ui 0.9.1"; const MAPS_DEP_LABEL: &str = "crates.io: solverforge-maps 2.3.3"; const SOLVERFORGE_DEP_SPEC: &str = - r#"{ version = "0.26.1", features = ["serde", "console", "verbose-logging"] }"#; + r#"{ version = "0.31.1", features = ["serde", "console", "verbose-logging"] }"#; const SOLVERFORGE_UI_DEP_SPEC: &str = r#"{ version = "0.9.1" }"#; -const SOLVERFORGE_MCP_DEP_SPEC: &str = r#"{ version = "0.26.1", features = ["serde"] }"#; +const SOLVERFORGE_MCP_DEP_SPEC: &str = r#"{ version = "0.31.1", features = ["serde"] }"#; const RMCP_DEP_SPEC: &str = r#"{ version = "3.9.0", features = ["server", "macros", "transport-io", "transport-streamable-http-server", "transport-streamable-http-server-session"] }"#; const SOLVERFORGE_MAPS_DEP_SPEC: &str = r#"{ version = "2.3.3" }"#; const GENERATED_RUST_VERSION_SPEC: &str = r#"rust-version = "1.95""#; @@ -300,7 +300,7 @@ fn test_version_output_distinguishes_cli_from_runtime_target() { assert!( stdout.contains(&format!("solverforge-cli {}", CLI_VERSION)) && stdout.contains(&format!("CLI version: {}", CLI_VERSION)) - && stdout.contains("Scaffold runtime target: SolverForge crate target 0.26.1") + && stdout.contains("Scaffold runtime target: SolverForge crate target 0.31.1") && stdout.contains("Scaffold UI target: solverforge-ui 0.9.1") && stdout.contains("Scaffold maps target: solverforge-maps 2.3.3") && stdout.contains(RUNTIME_DEP_LABEL) @@ -435,8 +435,8 @@ fn test_new_creates_neutral_project_files() { assert!( app_spec.contains("starter = \"neutral-shell\"") && app_spec.contains("shell = \"web\"") - && app_spec.contains("target = \"solverforge 0.26.1\"") - && app_spec.contains("runtime_source = \"crates.io: solverforge 0.26.1\"") + && app_spec.contains("target = \"solverforge 0.31.1\"") + && app_spec.contains("runtime_source = \"crates.io: solverforge 0.31.1\"") && app_spec.contains("[demo]") && app_spec.contains("default_size = \"standard\"") && app_spec.contains("available_sizes = [\"small\", \"standard\", \"large\"]") @@ -486,7 +486,7 @@ fn test_new_creates_neutral_project_files() { ); assert!( cargo_toml.contains( - "solverforge = { version = \"0.26.1\", features = [\"serde\", \"console\", \"verbose-logging\"] }" + "solverforge = { version = \"0.31.1\", features = [\"serde\", \"console\", \"verbose-logging\"] }" ) && cargo_toml.contains("solverforge-ui = { version = \"0.9.1\" }") && cargo_toml.contains("solverforge-maps = { version = \"2.3.3\" }") && cargo_toml.contains(GENERATED_RUST_VERSION_SPEC) @@ -706,7 +706,7 @@ fn test_new_readme_records_cli_and_runtime_versions_separately() { readme.contains(&format!( "CLI version used to scaffold this project: `{}`", CLI_VERSION - )) && readme.contains("SolverForge runtime target for this scaffold: `solverforge 0.26.1`") + )) && readme.contains("SolverForge runtime target for this scaffold: `solverforge 0.31.1`") && readme.contains("SolverForge UI target for this scaffold: `solverforge-ui 0.9.1`") && readme .contains("SolverForge maps target for this scaffold: `solverforge-maps 2.3.3`") @@ -777,8 +777,8 @@ fn test_new_api_shell_excludes_frontend_assets() { assert!( app_spec.contains("shell = \"api\"") - && app_spec.contains("target = \"solverforge 0.26.1\"") - && app_spec.contains("runtime_source = \"crates.io: solverforge 0.26.1\"") + && app_spec.contains("target = \"solverforge 0.31.1\"") + && app_spec.contains("runtime_source = \"crates.io: solverforge 0.31.1\"") && !app_spec.contains("ui_source"), "api shell should be recorded in solverforge.app.toml: {app_spec}" ); @@ -813,9 +813,9 @@ fn test_new_api_shell_excludes_frontend_assets() { std::fs::read_to_string(project_dir.join("solverforge.app.toml")).unwrap(); assert!( app_spec_after_generate.contains("shell = \"api\"") - && app_spec_after_generate.contains("target = \"solverforge 0.26.1\"") + && app_spec_after_generate.contains("target = \"solverforge 0.31.1\"") && app_spec_after_generate - .contains("runtime_source = \"crates.io: solverforge 0.26.1\"") + .contains("runtime_source = \"crates.io: solverforge 0.31.1\"") && !app_spec_after_generate.contains("ui_source"), "api shell should preserve runtime metadata without reintroducing ui_source after domain mutations: {app_spec_after_generate}" ); @@ -865,8 +865,8 @@ fn test_new_cli_shell_excludes_axum_frontend_and_compiles() { assert!( app_spec.contains("shell = \"cli\"") - && app_spec.contains("target = \"solverforge 0.26.1\"") - && app_spec.contains("runtime_source = \"crates.io: solverforge 0.26.1\"") + && app_spec.contains("target = \"solverforge 0.31.1\"") + && app_spec.contains("runtime_source = \"crates.io: solverforge 0.31.1\"") && !app_spec.contains("ui_source"), "cli shell should be recorded in solverforge.app.toml: {app_spec}" ); @@ -1006,9 +1006,9 @@ fn test_new_cli_shell_excludes_axum_frontend_and_compiles() { std::fs::read_to_string(project_dir.join("solverforge.app.toml")).unwrap(); assert!( app_spec_after_generate.contains("shell = \"cli\"") - && app_spec_after_generate.contains("target = \"solverforge 0.26.1\"") + && app_spec_after_generate.contains("target = \"solverforge 0.31.1\"") && app_spec_after_generate - .contains("runtime_source = \"crates.io: solverforge 0.26.1\"") + .contains("runtime_source = \"crates.io: solverforge 0.31.1\"") && !app_spec_after_generate.contains("ui_source"), "cli shell should preserve runtime metadata without reintroducing ui_source after domain mutations: {app_spec_after_generate}" ); @@ -1088,8 +1088,8 @@ fn test_new_mcp_shell_exposes_mcp_surface_and_compiles() { assert!( app_spec.contains("shell = \"mcp\"") - && app_spec.contains("target = \"solverforge 0.26.1\"") - && app_spec.contains("runtime_source = \"crates.io: solverforge 0.26.1\"") + && app_spec.contains("target = \"solverforge 0.31.1\"") + && app_spec.contains("runtime_source = \"crates.io: solverforge 0.31.1\"") && !app_spec.contains("ui_source"), "mcp shell should be recorded in solverforge.app.toml: {app_spec}" ); @@ -1276,9 +1276,9 @@ fn test_new_mcp_shell_exposes_mcp_surface_and_compiles() { std::fs::read_to_string(project_dir.join("solverforge.app.toml")).unwrap(); assert!( app_spec_after_generate.contains("shell = \"mcp\"") - && app_spec_after_generate.contains("target = \"solverforge 0.26.1\"") + && app_spec_after_generate.contains("target = \"solverforge 0.31.1\"") && app_spec_after_generate - .contains("runtime_source = \"crates.io: solverforge 0.26.1\"") + .contains("runtime_source = \"crates.io: solverforge 0.31.1\"") && !app_spec_after_generate.contains("ui_source"), "mcp shell should preserve runtime metadata without reintroducing ui_source after domain mutations: {app_spec_after_generate}" ); From df0afcc19234ae1c1a2d6f96f6ea6f43a74c3cb4 Mon Sep 17 00:00:00 2001 From: Vittorio Distefano Date: Tue, 17 Nov 2026 17:59:32 +0100 Subject: [PATCH 2/5] feat(telemetry): report the phase plan a solve ran Status, snapshot, SSE and telemetry payloads now carry resolvedPhasePlan, projected from the runtime's final telemetry since SolverForge 0.28.0: every phase the solve ran, the construction chosen for each default stage and why, the move families and their limits, the acceptor and the forager. It is null while the job solves and set once it ends, so a client reads the policy that actually produced a result instead of reconstructing it from solver.toml defaults. The scaffold contract asserts the projection, and the scalar runtime pipeline asserts it is null while solving and populated once the job completes. --- README.md | 7 +++++-- WIREFRAME.md | 2 ++ templates/list/generic/src/api/telemetry.rs | 5 +++++ templates/scalar/generic/src/api/telemetry.rs | 5 +++++ tests/runtime_pipeline_test.rs | 9 +++++++++ tests/scaffold_test.rs | 2 ++ 6 files changed, 28 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 5d7ab81..e51f2f3 100644 --- a/README.md +++ b/README.md @@ -325,8 +325,11 @@ then from `~/.solverforgerc`. Recognized preferences are intentionally narrow: Generated web/API apps expose every compact `SolverTelemetry` aggregate, including applied/not-doable/rejected moves, hard-score direction counts, construction counters, one record per started phase (`phases`, in execution -order), per-selector and per-move breakdowns, and the bounded applied-move -trace. The six `conflictRepair*` counters are run-level totals; selector +order), per-selector and per-move breakdowns, the bounded applied-move +trace, and `resolvedPhasePlan`: the policy the solve actually ran (every phase, +the construction chosen for each default stage, the move families and their +limits, acceptor and forager), `null` until the solve ends. The six +`conflictRepair*` counters are run-level totals; selector records do not carry them because SolverForge `0.26.1` `SelectorTelemetry` has no such fields. These fields are carried consistently by status, snapshot, and typed SSE payloads. Constraint analysis reports each diff --git a/WIREFRAME.md b/WIREFRAME.md index 8293c76..98f6686 100644 --- a/WIREFRAME.md +++ b/WIREFRAME.md @@ -281,6 +281,8 @@ Generated apps should behave like production references: aggregate and phase/selector/move/applied-move breakdown; the six `conflictRepair*` counters are run-level only, because SolverForge `0.26.1` `SelectorTelemetry` does not carry them +- telemetry carries `resolvedPhasePlan`, the phase plan the solve resolved and + ran, once the solve ends (`null` before that) - constraint analysis carries `name`, `weightMultiplier` (the bound constraint weight), `score`, and `matchCount` per constraint - `GET /jobs/{id}/telemetry` exposes the atomically paired retained status and diff --git a/templates/list/generic/src/api/telemetry.rs b/templates/list/generic/src/api/telemetry.rs index fe9cc86..219529d 100644 --- a/templates/list/generic/src/api/telemetry.rs +++ b/templates/list/generic/src/api/telemetry.rs @@ -122,6 +122,7 @@ pub struct TelemetryDto { pub selector_telemetry: Vec, pub move_telemetry: Vec, pub applied_move_trace: Vec, + pub resolved_phase_plan: Option, } impl TelemetryDto { @@ -180,6 +181,10 @@ impl TelemetryDto { .iter() .map(AppliedMoveTelemetryDto::from_runtime) .collect(), + resolved_phase_plan: telemetry + .resolved_phase_plan + .as_ref() + .map(CandidateTracePhasePlanDto::from_runtime), } } } diff --git a/templates/scalar/generic/src/api/telemetry.rs b/templates/scalar/generic/src/api/telemetry.rs index 3b78066..3974d7d 100644 --- a/templates/scalar/generic/src/api/telemetry.rs +++ b/templates/scalar/generic/src/api/telemetry.rs @@ -127,6 +127,7 @@ pub struct TelemetryDto { pub selector_telemetry: Vec, pub move_telemetry: Vec, pub applied_move_trace: Vec, + pub resolved_phase_plan: Option, } impl TelemetryDto { @@ -185,6 +186,10 @@ impl TelemetryDto { .iter() .map(AppliedMoveTelemetryDto::from_runtime) .collect(), + resolved_phase_plan: telemetry + .resolved_phase_plan + .as_ref() + .map(CandidateTracePhasePlanDto::from_runtime), } } } diff --git a/tests/runtime_pipeline_test.rs b/tests/runtime_pipeline_test.rs index e1c2d5f..ddd3524 100644 --- a/tests/runtime_pipeline_test.rs +++ b/tests/runtime_pipeline_test.rs @@ -491,6 +491,7 @@ fn scalar_solver_pipeline() { assert!(solving["telemetry"]["appliedMoveTrace"].is_array()); assert_eq!(solving["telemetry"]["movesSpeculative"], 0); assert!(solving["telemetry"]["phases"].is_array()); + assert!(solving["telemetry"]["resolvedPhasePlan"].is_null()); let latest_snapshot = client .get(format!("{base_url}/jobs/{live_job_id}/snapshot")) @@ -680,6 +681,14 @@ fn scalar_solver_pipeline() { completed["terminalReason"].as_str(), Some("completed" | "terminated_by_config") )); + // The policy the solve ran is reported once it ends. + assert!( + completed["telemetry"]["resolvedPhasePlan"]["children"] + .as_array() + .is_some_and(|phases| !phases.is_empty()), + "a completed job should report the phase plan it ran: {}", + completed["telemetry"] + ); let completed_snapshot = client .get(format!("{base_url}/jobs/{completed_job_id}/snapshot")) diff --git a/tests/scaffold_test.rs b/tests/scaffold_test.rs index 961e3d2..ef878b5 100644 --- a/tests/scaffold_test.rs +++ b/tests/scaffold_test.rs @@ -604,6 +604,8 @@ fn test_new_creates_neutral_project_files() { && telemetry_rs.contains("pub selector_telemetry: Vec") && telemetry_rs.contains("pub move_telemetry: Vec") && telemetry_rs.contains("pub applied_move_trace: Vec") + && telemetry_rs + .contains("pub resolved_phase_plan: Option") && telemetry_rs.contains("pub struct CandidateTraceDto") && telemetry_rs.contains("pub qualified_run_provenance") && telemetry_rs.contains("CandidateTraceSource::ListClarkeWrightCompletionInsertion") From 634ff9bae7ca7f44aab1eae711acdfcaaddb957a Mon Sep 17 00:00:00 2001 From: Vittorio Distefano Date: Tue, 17 Nov 2026 17:59:42 +0100 Subject: [PATCH 3/5] docs(scaffold): align the runtime contract with SolverForge 0.31.1 The README, wireframe, agent guide and modeling skill name the runtime the scaffold now targets. Each statement that rests on the runtime was rechecked against the 0.31.1 sources before moving it: BendableScore still has no ParseableScore, there is still no for_each_unique_pair, and SelectorTelemetry still carries no conflict-repair counters. --- AGENTS.md | 4 ++-- README.md | 8 ++++---- WIREFRAME.md | 10 +++++----- skills/solverforge-modeling/SKILL.md | 4 ++-- .../references/constraint-patterns.md | 2 +- skills/solverforge-modeling/references/gotchas.md | 2 +- skills/solverforge-modeling/references/verification.md | 2 +- 7 files changed, 16 insertions(+), 16 deletions(-) diff --git a/AGENTS.md b/AGENTS.md index cb67d73..0c84d2e 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -9,7 +9,7 @@ Current scaffold policy: - current CLI package version is `4.0.4` - minimum supported Rust version is `1.95`, matching the current SolverForge runtime crates -- generated projects currently target `solverforge 0.26.1`; the default web shell additionally targets `solverforge-ui 0.9.1` and `solverforge-maps 2.3.3`; the MCP shell additionally targets `rmcp 3.9.0` +- generated projects currently target `solverforge 0.31.1`; the default web shell additionally targets `solverforge-ui 0.9.1` and `solverforge-maps 2.3.3`; the MCP shell additionally targets `rmcp 3.9.0` - `solverforge new ` is the only public scaffold path and produces a neutral app shell - `--shell web|api|cli|mcp` is the current public shell selector; `web` is the default, `api` omits frontend assets, `cli` omits Axum/SSE routes and frontend assets, and `mcp` delivers the solver as an MCP server over stdio and stateless Streamable HTTP - API/CLI/MCP app specs omit `ui_source`, and subsequent CLI mutations must preserve that absence @@ -80,7 +80,7 @@ Current end-to-end scenario policy: - the scalar-only runtime scenario covers full compact telemetry, bounded candidate detail, and qualified trace provenance - the MCP scenario models a mixed scalar-plus-list problem, generates the sample data, and drives both stdio and stateless Streamable HTTP through the real `rmcp` client: annotated tool surface, task-backed solve to a terminal snapshot with scalar assignment and complete list placement, retained lifecycle via a legacy client, and byte-level stdio stdout purity during a solve, all with parallel evaluation enabled on a pinned Rayon pool -SolverForge `0.26.1` uses list variables as the sequence and route model. The +SolverForge `0.31.1` uses list variables as the sequence and route model. The generated-app runtime and browser scenarios must continue to start and observe a real mixed scalar/list solve. diff --git a/README.md b/README.md index e51f2f3..8215f63 100644 --- a/README.md +++ b/README.md @@ -16,7 +16,7 @@ Required Rust version: `1.95` or later. New projects currently target these crate versions: -- `solverforge 0.26.1` +- `solverforge 0.31.1` - `solverforge-ui 0.9.1` for the default web shell - `solverforge-maps 2.3.3` for the default web shell - `rmcp 3.9.0` for the MCP shell @@ -199,7 +199,7 @@ Core commands: - `generate score` and `generate solution --score` accept `HardSoftScore`, `HardSoftDecimalScore`, `HardMediumSoftScore`, and `SoftScore`. `BendableScore` is rejected because `#[planning_solution]` requires a - `ParseableScore`, which SolverForge `0.26.1` does not implement for it. + `ParseableScore`, which SolverForge `0.31.1` does not implement for it. - `solverforge generate scalar-group|conflict-repair` wires opt-in model resources by exact ID. - `solverforge destroy fact|entity|variable|constraint|solution|scalar-group|conflict-repair` @@ -330,7 +330,7 @@ trace, and `resolvedPhasePlan`: the policy the solve actually ran (every phase, the construction chosen for each default stage, the move families and their limits, acceptor and forager), `null` until the solve ends. The six `conflictRepair*` counters are run-level totals; selector -records do not carry them because SolverForge `0.26.1` `SelectorTelemetry` +records do not carry them because SolverForge `0.31.1` `SelectorTelemetry` has no such fields. These fields are carried consistently by status, snapshot, and typed SSE payloads. Constraint analysis reports each constraint's `name`, `weightMultiplier` (the bound constraint weight, a @@ -463,7 +463,7 @@ Current scenario coverage: byte-level stdio check that the transport channel stays pure JSON-RPC; every MCP phase runs with parallel evaluation enabled -SolverForge `0.26.1` supports mixed scalar/list construction, canonical mixed +SolverForge `0.31.1` supports mixed scalar/list construction, canonical mixed local-search defaults, and list-based sequence modeling. The CLI suite proves the mixed path in both runtime and browser pipelines; the scalar-only scenario keeps the deeper pause/resume, analysis, reconnect, and qualified-trace checks. diff --git a/WIREFRAME.md b/WIREFRAME.md index 98f6686..142aaa1 100644 --- a/WIREFRAME.md +++ b/WIREFRAME.md @@ -21,7 +21,7 @@ Required Rust version: `1.95` or later. Current generated projects target: -- `solverforge 0.26.1` +- `solverforge 0.31.1` - `solverforge-ui 0.9.1` for the web shell - `solverforge-maps 2.3.3` for the web shell - `rmcp 3.9.0` for the MCP shell @@ -279,7 +279,7 @@ Generated apps should behave like production references: snapshot revision - status, snapshot, and SSE payloads expose every compact SolverForge telemetry aggregate and phase/selector/move/applied-move breakdown; the six - `conflictRepair*` counters are run-level only, because SolverForge `0.26.1` + `conflictRepair*` counters are run-level only, because SolverForge `0.31.1` `SelectorTelemetry` does not carry them - telemetry carries `resolvedPhasePlan`, the phase plan the solve resolved and ran, once the solve ends (`null` before that) @@ -335,7 +335,7 @@ warning, not an error, so the user can define it afterward. `generate score` and `generate solution --score` accept `HardSoftScore`, `HardSoftDecimalScore`, `HardMediumSoftScore`, and `SoftScore`. `BendableScore` is rejected: `#[planning_solution]` requires a -`ParseableScore`, and SolverForge `0.26.1` does not implement it for +`ParseableScore`, and SolverForge `0.31.1` does not implement it for `BendableScore`. Score rewrites change only the bare type name inside `use` items. @@ -350,7 +350,7 @@ functions that panic with the function name and the - `--reward`: `for_each` + `filter(reward_condition)` + `reward` - `--pair`: `for_each` + `filter` (variable assigned) + `join(joiner::equal(key))` self-join, which yields each unordered pair once, + `filter(pair_condition)` - + `penalize`; SolverForge `0.26.1` has no `for_each_unique_pair` + + `penalize`; SolverForge `0.31.1` has no `for_each_unique_pair` Weight helpers return the unit penalty or reward. A solve that reaches a placeholder fails: the job ends `FAILED` and the panic names the file and @@ -448,7 +448,7 @@ Current scenario policy: legacy client, and byte-level stdio stdout purity during a solve, all with parallel evaluation enabled -SolverForge `0.26.1` uses list variables for ordered sequences and routes. Both +SolverForge `0.31.1` uses list variables for ordered sequences and routes. Both generated-app end-to-end suites start and observe the real mixed scalar/list path. diff --git a/skills/solverforge-modeling/SKILL.md b/skills/solverforge-modeling/SKILL.md index 203e9cc..cc04a28 100644 --- a/skills/solverforge-modeling/SKILL.md +++ b/skills/solverforge-modeling/SKILL.md @@ -25,7 +25,7 @@ required source/collector rules for the grouped patterns. `solverforge --version`, `solverforge new --help`, `solverforge generate variable --help`. -This skill describes CLI `4.0.4` (scaffold runtime target `solverforge 0.26.1`, +This skill describes CLI `4.0.4` (scaffold runtime target `solverforge 0.31.1`, UI `solverforge-ui 0.9.1`, maps `solverforge-maps 2.3.3`, MCP `rmcp 3.9.0`). Re-derive specifics from the CLI if the version differs. @@ -221,7 +221,7 @@ from a hand-written extractor. The common skeletons are `--unary` = `for_each` + `filter` + `penalize` (hard or soft), `--reward` = `for_each` + `filter` + `reward`, and `--pair` = `for_each` + `filter` (variable assigned) + `joiner::equal` self-join + -`filter` + `penalize`. SolverForge `0.26.1` has no `for_each_unique_pair`; +`filter` + `penalize`. SolverForge `0.31.1` has no `for_each_unique_pair`; the self-join already yields each unordered pair once. `#[planning_solution]` generates a public associated accessor for each diff --git a/skills/solverforge-modeling/references/constraint-patterns.md b/skills/solverforge-modeling/references/constraint-patterns.md index c44f625..65daf25 100644 --- a/skills/solverforge-modeling/references/constraint-patterns.md +++ b/skills/solverforge-modeling/references/constraint-patterns.md @@ -182,7 +182,7 @@ fn pair_weight(_left: &Task, _right: &Task) -> HardSoftScore { } ``` -SolverForge `0.26.1` has no `for_each_unique_pair`; this self-join is the pair +SolverForge `0.31.1` has no `for_each_unique_pair`; this self-join is the pair pattern. A self-join visits each unordered pair **exactly once** and never pairs an entity with itself, so one match is one violation. Do not add a self-pair guard and do not halve the weight. Keep the assigned filter before the join: an diff --git a/skills/solverforge-modeling/references/gotchas.md b/skills/solverforge-modeling/references/gotchas.md index e656ce3..cf326ea 100644 --- a/skills/solverforge-modeling/references/gotchas.md +++ b/skills/solverforge-modeling/references/gotchas.md @@ -153,7 +153,7 @@ construction phase covers the group. - `SoftScore` has no hard level: only `--soft` constraints are allowed. - `generate score ` must name a supported type, or the CLI rejects it. - `BendableScore` is rejected: SolverForge `0.26.1` has no + `BendableScore` is rejected: SolverForge `0.31.1` has no `ParseableScore` for it, which `#[planning_solution]` requires. ## `solverforge.app.toml` is a projection, not an input diff --git a/skills/solverforge-modeling/references/verification.md b/skills/solverforge-modeling/references/verification.md index a3e8f19..3624031 100644 --- a/skills/solverforge-modeling/references/verification.md +++ b/skills/solverforge-modeling/references/verification.md @@ -23,7 +23,7 @@ cargo check Catches wrong field names, missing imports, wrong score types, and closure signature mismatches. It will **not** catch the runtime localizing-source panic (that is a runtime assertion, not a compile error). The generated scaffolds -target `solverforge 0.26.1`; the first build downloads and compiles the runtime +target `solverforge 0.31.1`; the first build downloads and compiles the runtime and web dependencies, which can take a few minutes. `SF_USE_LOCAL_PATCHES=1` exists in the CLI's own test harness for prerelease targets — do not set it for ordinary app builds. From acd00bb11f080a9bfae5ed65e7a42b167d85fbbd Mon Sep 17 00:00:00 2001 From: Vittorio Distefano Date: Tue, 17 Nov 2026 17:59:43 +0100 Subject: [PATCH 4/5] docs(audit): refresh the audit to SolverForge 0.31.1 The published gate, checkout baseline, coverage and release-state lines move to 0.31.1, and each release from 0.27.0 to 0.31.1 gets a line saying what reaches generated apps: the 0.28.0 resolved phase plan, now projected in telemetry, and the opt-in 0.31.0 element groups and joint cascading groups the neutral scaffold leaves out. The rest needs no template change and arrives through the version pin. --- UPSTREAM_FEATURE_AUDIT.md | 66 ++++++++++++++++++++++++++++++--------- 1 file changed, 51 insertions(+), 15 deletions(-) diff --git a/UPSTREAM_FEATURE_AUDIT.md b/UPSTREAM_FEATURE_AUDIT.md index 697a7a2..31ce705 100644 --- a/UPSTREAM_FEATURE_AUDIT.md +++ b/UPSTREAM_FEATURE_AUDIT.md @@ -1,11 +1,11 @@ # SolverForge Upstream Feature Audit -Audit date: 2026-11-11 +Audit date: 2026-11-17 This audit compares the current `solverforge-cli` scaffold surface against the live SolverForge upstream checkout at `/srv/lab/dev/solverforge/solverforge` and the crates.io release state. Generated projects now target the published -SolverForge `0.26.1` release. Registry-only generated-app validation is the +SolverForge `0.31.1` release. Registry-only generated-app validation is the release gate; `SF_USE_LOCAL_PATCHES=1` remains reserved for explicit future prerelease checks against sibling checkouts. @@ -15,13 +15,13 @@ without turning the neutral scaffold into a domain-specific demo. ## Source Evidence -- Published gate: `cargo info solverforge@0.26.1` resolves the published crate - on 2026-11-10, with Rust `1.95` and the `serde`, `console`, and +- Published gate: `cargo info solverforge@0.31.1` resolves the published crate + on 2026-11-17, with Rust `1.95` and the `serde`, `console`, and `verbose-logging` features; `verbose-logging` is `[console, solverforge-console/verbose-logging]`, so the web, API, and CLI shells keep all three and the MCP shell enables only `serde`. - Upstream local checkout: the workspace and inter-crate dependency baseline is - `0.26.1`, with `v0.26.1` (`f3b41788`) at the checked-out release commit. The `0.19.0` + `0.31.1`, with `v0.31.1` (`ff945a3b`) at the checked-out release commit. The `0.19.0` release made list variables the sole sequence and route model; the published `0.19.1` through `0.19.7` patch line carries the subsequent solver fixes. - Upstream `0.19.7..0.22.0` release surface: `0.19.8` through `0.19.14` are @@ -201,6 +201,38 @@ without turning the neutral scaffold into a domain-specific demo. permutation. No public API or configuration change; generated apps pick it up through the version pin, and their late-acceptance searches accept the worsening moves the algorithm is meant to accept. +- Upstream `0.26.1..0.27.0` release surface: the CVRP crate reads leg + distances through a pluggable `RouteMetric` (breaking for `ProblemData` and + `VrpSolution`), Clarke-Wright savings are bounded to nearest neighbours, and + Clarke-Wright owner admission and the scalar swap cursor open faster. + Generated apps use neither the CVRP crate nor its types, so the scaffold + needs no template change. +- Upstream `0.27.0..0.28.0` release surface: constraint analysis describes + matched entities by type name and `Debug` text without copying them, grouped + and complemented constraints report their matches, and final telemetry + carries `resolved_phase_plan`, the policy the solve actually ran. Generated + apps never construct `EntityRef`; the status, snapshot, SSE and telemetry + payloads project `resolvedPhasePlan`, `null` until the solve ends. +- Upstream `0.28.0..0.29.0` release surface: constraint matches report each + entity's planning id. Generated analysis reports per-constraint totals and + needs no template change. +- Upstream `0.29.0..0.30.0` release surface: cascading list shadows propagate + across list owners, `ComplementedConstraintStream` gains a filter type + parameter, and uni grouped complements apply the stream filter. Generated + code names none of these types. +- Upstream `0.30.0..0.30.1` release surface: a cascading list arrival is + retracted before its structure shadows change. No public API change. +- Upstream `0.30.1..0.31.0` release surface: list element groups move, + construct, ruin and recreate as units (`element_group_fn`, the + `list_group_change_move_selector` and `list_group_swap_move_selector`, and + `max_member_distance`/`max_group_owners` on ruin and construction), and + joint groups of cascading elements compute together (`cascading_peers`). + Opt-in model surfaces; the neutral scaffold declares none of them. +- Upstream `0.31.0..0.31.1` release surface: scoring rescores only the + list-shadow rows a cascading move changes, and grouped ruins recreate in one + pass with shared trial prefixes, through a new defaulted + `PlanningSolution::list_structure_unchanged` hook the macros generate. No + configuration change; generated apps pick it up through the version pin. - Upstream `0.24.0..0.25.0` release surface (source-carrying, breaking): configuration semantics made literal and validated, partitioned search run by the framework, the `auto` parallel-evaluation policy, and construction and @@ -234,13 +266,13 @@ without turning the neutral scaffold into a domain-specific demo. `scalar_groups`, `ScalarGroup::assignment`, grouped scalar construction with `group_name`, `construction_obligation = "assign_when_candidate_exists"`, and `grouped_scalar_move_selector`. -- CLI coverage today: the scaffold targets `solverforge 0.26.1`, exposes the +- CLI coverage today: the scaffold targets `solverforge 0.31.1`, exposes the `web`, `api`, `cli`, and `mcp` shells, and includes the retained `SolverManager` lifecycle, typed SSE, snapshots, analysis, pause/resume/cancel/delete, generated `solverforge.app.toml`, scalar/list variable generation, complete executable scalar/list metadata projection, - countable scalar ranges, full compact telemetry (including per-phase records - and speculative counts), bounded candidate-detail retrieval, qualified trace + countable scalar ranges, full compact telemetry (including per-phase records, + speculative counts and the resolved phase plan), bounded candidate-detail retrieval, qualified trace jobs, validated opt-in parallel evaluation, and a neutral `solver.toml` that defers to the runtime default pipeline. - Neutral solve gate: the neutral runtime pipeline solves the untouched @@ -358,7 +390,7 @@ without turning the neutral scaffold into a domain-specific demo. ## Recommended Follow-Up Implementation Slice -The current starter-safe 0.26.1 surface is implemented, apart from the +The current starter-safe 0.31.1 surface is implemented, apart from the unknown-key `solver.toml` validation gap recorded in the matrix. The next high-value slice is domain-specific documentation and executable examples, not more neutral scaffold defaults. @@ -375,17 +407,21 @@ scaffold defaults. ## Implementation Status -- Release state: `solverforge 0.26.1` is published on crates.io and matches +- Release state: `solverforge 0.31.1` is published on crates.io and matches the live upstream release checkout and this generated target. The - `0.19.8..0.26.1` line is source-carrying (grouped-scalar search/perf work, + `0.19.8..0.31.1` line is source-carrying (grouped-scalar search/perf work, the `0.20.3` search-order hooks, the `0.21.0` scoring `group_by` joins, the `0.21.2` selector-subgraph edge rebase fix, the `0.21.3` precedence route delta fix, the `0.22.0` grouped-stream accumulator-kernel rework, the `0.23.0` parallel local-search evaluation, the `0.24.0` constraint weights and API cleanup, the `0.25.0` configuration audit, framework partitioned search and `auto` evaluation policy, the `0.25.1` bounded nearby list - candidate buffer, the `0.26.0` compact generic type names, and the `0.26.1` - late-acceptance history fix), and the published crate, the `v0.26.1` tag, + candidate buffer, the `0.26.0` compact generic type names, the `0.26.1` + late-acceptance history fix, the `0.27.0` route metric, the `0.28.0` resolved + phase plan and match descriptions, the `0.29.0` planning ids in matches, the + `0.30.0` cross-owner cascading shadows, the `0.31.0` list element groups and + joint cascading groups, and the `0.31.1` list-shadow row rescoring), and the + published crate, the `v0.31.1` tag, and this generated target are the same code. Registry-only validation is therefore authoritative. `SF_USE_LOCAL_PATCHES=1` is only for an explicit future coordinated prerelease @@ -486,7 +522,7 @@ scaffold defaults. help says: unary is `for_each` + `filter` + `penalize` for both hardness levels, reward is `for_each` + `filter` + `reward`, and pair filters out unassigned entities before a `joiner::equal` self-join (each unordered pair - once; `0.26.1` has no `for_each_unique_pair`) and selects conflicts with a + once; `0.31.1` has no `for_each_unique_pair`) and selects conflicts with a filter. - Changed: the neutral `solver.toml` declares no `[[phases]]` and defers to the runtime's model-aware default pipeline; its explicit phases remain as a @@ -516,7 +552,7 @@ Any implementation from this audit should pass: - focused parser/generator/app-spec tests for the new metadata; - scaffold contract tests proving fresh generated projects include only the opt-in scalar-group surface requested by the user; -- generated app `cargo check` against the published `0.26.1` registry target; +- generated app `cargo check` against the published `0.31.1` registry target; - runtime pipeline coverage only if the new command claims actual solving behavior; - `SF_USE_LOCAL_PATCHES=1` only for an explicit future sibling-checkout From eda3b3393bf716766985d3a581f085b5e127fd62 Mon Sep 17 00:00:00 2001 From: Vittorio Distefano Date: Tue, 17 Nov 2026 18:46:07 +0100 Subject: [PATCH 5/5] chore(e2e): update Playwright to 1.65.1 GitHub's ubuntu-latest image is now ubuntu-26.04. Playwright 1.59.1 has no Chromium build for it, so `make install-e2e` aborted the Integration Tests job before pre-commit and the integration suites ran. Chromium downloads for ubuntu26.04-x64 start at 1.61.0. --- package-lock.json | 48 +++++++++++++++-------------------------------- package.json | 2 +- 2 files changed, 16 insertions(+), 34 deletions(-) diff --git a/package-lock.json b/package-lock.json index f5207c3..c115b1f 100644 --- a/package-lock.json +++ b/package-lock.json @@ -8,70 +8,52 @@ "name": "solverforge-cli-e2e", "version": "4.0.4", "devDependencies": { - "@playwright/test": "^1.59.1" + "@playwright/test": "^1.65.1" } }, "node_modules/@playwright/test": { - "version": "1.59.1", - "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.59.1.tgz", - "integrity": "sha512-PG6q63nQg5c9rIi4/Z5lR5IVF7yU5MqmKaPOe0HSc0O2cX1fPi96sUQu5j7eo4gKCkB2AnNGoWt7y4/Xx3Kcqg==", + "version": "1.65.1", + "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.65.1.tgz", + "integrity": "sha512-y+NCIRm2LvY4slUVWvGh1nujJ8RF/hEisIsq2mtUPgdQC4L701bq5hZGMhrpeXjACvwvO9tj5dJqhvM6TP9lbw==", "dev": true, "license": "Apache-2.0", "dependencies": { - "playwright": "1.59.1" + "playwright": "1.65.1" }, "bin": { "playwright": "cli.js" }, "engines": { - "node": ">=18" - } - }, - "node_modules/fsevents": { - "version": "2.3.2", - "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz", - "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==", - "dev": true, - "hasInstallScript": true, - "license": "MIT", - "optional": true, - "os": [ - "darwin" - ], - "engines": { - "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + "node": ">=20" } }, "node_modules/playwright": { - "version": "1.59.1", - "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.59.1.tgz", - "integrity": "sha512-C8oWjPR3F81yljW9o5OxcWzfh6avkVwDD2VYdwIGqTkl+OGFISgypqzfu7dOe4QNLL2aqcWBmI3PMtLIK233lw==", + "version": "1.65.1", + "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.65.1.tgz", + "integrity": "sha512-vJ1FuoOrNwOKHUIVEvSt3jT1L+wjjDpwhwIstKtfvTh8XIG4FG4bIFuvNdMxi81LGfAhUgUZleVFaOLY4RIUUw==", "dev": true, "license": "Apache-2.0", "dependencies": { - "playwright-core": "1.59.1" + "playwright-core": "1.65.1" }, "bin": { "playwright": "cli.js" }, "engines": { - "node": ">=18" - }, - "optionalDependencies": { - "fsevents": "2.3.2" + "node": ">=20" } }, "node_modules/playwright-core": { - "version": "1.59.1", - "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.59.1.tgz", - "integrity": "sha512-HBV/RJg81z5BiiZ9yPzIiClYV/QMsDCKUyogwH9p3MCP6IYjUFu/MActgYAvK0oWyV9NlwM3GLBjADyWgydVyg==", + "version": "1.65.1", + "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.65.1.tgz", + "integrity": "sha512-hqPpz7blSMPxWVdoeE1yiBSzXsKiVOd2k+kjCvmUywD2GPO2Dd9HfcWnq9NN0GHbNZDFgZ9JfBFr+X5/BLo0qw==", "dev": true, "license": "Apache-2.0", "bin": { "playwright-core": "cli.js" }, "engines": { - "node": ">=18" + "node": ">=20" } } } diff --git a/package.json b/package.json index 0c5ce1a..c0af41b 100644 --- a/package.json +++ b/package.json @@ -8,7 +8,7 @@ "install:e2e": "playwright install chromium" }, "devDependencies": { - "@playwright/test": "^1.59.1" + "@playwright/test": "^1.65.1" }, "version": "4.0.4" }