diff --git a/editor/CMakeLists.txt b/editor/CMakeLists.txt index 88b046c..4525772 100644 --- a/editor/CMakeLists.txt +++ b/editor/CMakeLists.txt @@ -4216,4 +4216,13 @@ target_link_libraries(step592_test PRIVATE tree_sitter_javascript tree_sitter_typescript tree_sitter_java tree_sitter_rust tree_sitter_go) +add_executable(step593_test tests/step593_test.cpp) +target_include_directories(step593_test PRIVATE src) +target_link_libraries(step593_test PRIVATE + nlohmann_json::nlohmann_json + unofficial::tree-sitter::tree-sitter + tree_sitter_python tree_sitter_cpp tree_sitter_elisp + tree_sitter_javascript tree_sitter_typescript + tree_sitter_java tree_sitter_rust tree_sitter_go) + # Step 12: Dear ImGui shell scaffolding created (main.cpp exists but not built due to dependencies) diff --git a/editor/src/Sprint33IntegrationSummary.h b/editor/src/Sprint33IntegrationSummary.h new file mode 100644 index 0000000..be3c5a8 --- /dev/null +++ b/editor/src/Sprint33IntegrationSummary.h @@ -0,0 +1,70 @@ +#pragma once +// Step 593: Sprint 33 Integration + Program Summary + +#include +#include + +struct Sprint33Signals { + bool onboardingFlow = false; // 584 + bool workflowVisualization = false; // 585 + bool capabilityDiscovery = false; // 586 + bool guidedDemoMode = false; // 587 + bool phase33aIntegration = false; // 588 + bool releaseReadinessPack = false; // 589 + bool crashRecoverySweep = false; // 590 + bool benchmarkHarness = false; // 591 + bool docsPlaybooks = false; // 592 +}; + +struct Sprint33IntegrationResult { + bool phase33aPass = false; + bool phase33bPass = false; + bool sprint33Pass = false; + std::vector notes; +}; + +class Sprint33IntegrationSummary { +public: + static Sprint33IntegrationResult summarize(const Sprint33Signals& s) { + Sprint33IntegrationResult r; + r.phase33aPass = s.onboardingFlow && + s.workflowVisualization && + s.capabilityDiscovery && + s.guidedDemoMode && + s.phase33aIntegration; + + r.phase33bPass = s.releaseReadinessPack && + s.crashRecoverySweep && + s.benchmarkHarness && + s.docsPlaybooks; + + r.sprint33Pass = r.phase33aPass && r.phase33bPass; + r.notes = buildNotes(s, r); + return r; + } + +private: + static std::vector buildNotes(const Sprint33Signals& s, + const Sprint33IntegrationResult& r) { + std::vector notes; + if (!s.onboardingFlow) notes.push_back("fail:step584_onboarding_flow"); + if (!s.workflowVisualization) notes.push_back("fail:step585_workflow_visualization"); + if (!s.capabilityDiscovery) notes.push_back("fail:step586_capability_discovery"); + if (!s.guidedDemoMode) notes.push_back("fail:step587_guided_demo_mode"); + if (!s.phase33aIntegration) notes.push_back("fail:step588_phase33a_integration"); + if (!s.releaseReadinessPack) notes.push_back("fail:step589_release_readiness_pack"); + if (!s.crashRecoverySweep) notes.push_back("fail:step590_crash_recovery_sweep"); + if (!s.benchmarkHarness) notes.push_back("fail:step591_benchmark_harness"); + if (!s.docsPlaybooks) notes.push_back("fail:step592_docs_playbooks"); + + if (r.sprint33Pass) { + notes.push_back("sprint33:product_experience_clear"); + notes.push_back("sprint33:operational_hardening_ready"); + notes.push_back("sprint33:competitive_readiness_established"); + } else { + if (!r.phase33aPass) notes.push_back("phase33a:blocked"); + if (!r.phase33bPass) notes.push_back("phase33b:blocked"); + } + return notes; + } +}; diff --git a/editor/tests/step593_test.cpp b/editor/tests/step593_test.cpp new file mode 100644 index 0000000..72cee56 --- /dev/null +++ b/editor/tests/step593_test.cpp @@ -0,0 +1,128 @@ +// Step 593: Sprint 33 Integration + Program Summary (8 tests) + +#include "Sprint33IntegrationSummary.h" + +#include + +static int passed = 0, failed = 0; +#define TEST(name) { std::cout << " " << #name << "... "; } +#define PASS() { std::cout << "PASS\n"; ++passed; } +#define FAIL(msg) { std::cout << "FAIL: " << msg << "\n"; ++failed; } +#define CHECK(cond, msg) if (!(cond)) { FAIL(msg); return; } else {} + +static bool hasNote(const Sprint33IntegrationResult& r, const std::string& note) { + for (const auto& n : r.notes) if (n == note) return true; + return false; +} + +static Sprint33Signals allPass() { + Sprint33Signals s; + s.onboardingFlow = true; + s.workflowVisualization = true; + s.capabilityDiscovery = true; + s.guidedDemoMode = true; + s.phase33aIntegration = true; + s.releaseReadinessPack = true; + s.crashRecoverySweep = true; + s.benchmarkHarness = true; + s.docsPlaybooks = true; + return s; +} + +void test_all_signals_pass_sprint() { + TEST(all_signals_pass_sprint); + auto r = Sprint33IntegrationSummary::summarize(allPass()); + CHECK(r.phase33aPass, "phase33a should pass"); + CHECK(r.phase33bPass, "phase33b should pass"); + CHECK(r.sprint33Pass, "sprint33 should pass"); + PASS(); +} + +void test_phase33a_failure_blocks_sprint() { + TEST(phase33a_failure_blocks_sprint); + auto s = allPass(); + s.guidedDemoMode = false; + auto r = Sprint33IntegrationSummary::summarize(s); + CHECK(!r.phase33aPass, "phase33a should fail"); + CHECK(!r.sprint33Pass, "sprint should fail"); + CHECK(hasNote(r, "fail:step587_guided_demo_mode"), "step587 note expected"); + PASS(); +} + +void test_phase33b_failure_blocks_sprint() { + TEST(phase33b_failure_blocks_sprint); + auto s = allPass(); + s.benchmarkHarness = false; + auto r = Sprint33IntegrationSummary::summarize(s); + CHECK(!r.phase33bPass, "phase33b should fail"); + CHECK(!r.sprint33Pass, "sprint should fail"); + CHECK(hasNote(r, "fail:step591_benchmark_harness"), "step591 note expected"); + PASS(); +} + +void test_success_notes_emitted_on_full_pass() { + TEST(success_notes_emitted_on_full_pass); + auto r = Sprint33IntegrationSummary::summarize(allPass()); + CHECK(hasNote(r, "sprint33:product_experience_clear"), "success note missing"); + CHECK(hasNote(r, "sprint33:operational_hardening_ready"), "success note missing"); + CHECK(hasNote(r, "sprint33:competitive_readiness_established"), "success note missing"); + PASS(); +} + +void test_blocked_phase_notes_emitted_on_failure() { + TEST(blocked_phase_notes_emitted_on_failure); + auto s = allPass(); + s.onboardingFlow = false; + s.releaseReadinessPack = false; + auto r = Sprint33IntegrationSummary::summarize(s); + CHECK(hasNote(r, "phase33a:blocked"), "phase33a blocked expected"); + CHECK(hasNote(r, "phase33b:blocked"), "phase33b blocked expected"); + PASS(); +} + +void test_multiple_failure_notes_aggregate() { + TEST(multiple_failure_notes_aggregate); + auto s = allPass(); + s.workflowVisualization = false; + s.phase33aIntegration = false; + s.docsPlaybooks = false; + auto r = Sprint33IntegrationSummary::summarize(s); + CHECK(hasNote(r, "fail:step585_workflow_visualization"), "step585 note missing"); + CHECK(hasNote(r, "fail:step588_phase33a_integration"), "step588 note missing"); + CHECK(hasNote(r, "fail:step592_docs_playbooks"), "step592 note missing"); + PASS(); +} + +void test_all_false_signals_fail_all_phases() { + TEST(all_false_signals_fail_all_phases); + Sprint33Signals s; + auto r = Sprint33IntegrationSummary::summarize(s); + CHECK(!r.phase33aPass && !r.phase33bPass && !r.sprint33Pass, "all should fail"); + PASS(); +} + +void test_single_phase33b_failure_keeps_phase33a_passed() { + TEST(single_phase33b_failure_keeps_phase33a_passed); + auto s = allPass(); + s.crashRecoverySweep = false; + auto r = Sprint33IntegrationSummary::summarize(s); + CHECK(r.phase33aPass, "phase33a should pass"); + CHECK(!r.phase33bPass, "phase33b should fail"); + PASS(); +} + +int main() { + std::cout << "Step 593: Sprint 33 Integration + Program Summary\n"; + + test_all_signals_pass_sprint(); // 1 + test_phase33a_failure_blocks_sprint(); // 2 + test_phase33b_failure_blocks_sprint(); // 3 + test_success_notes_emitted_on_full_pass(); // 4 + test_blocked_phase_notes_emitted_on_failure(); // 5 + test_multiple_failure_notes_aggregate(); // 6 + test_all_false_signals_fail_all_phases(); // 7 + test_single_phase33b_failure_keeps_phase33a_passed();// 8 + + std::cout << "\nResults: " << passed << "/" << (passed + failed) << " passed\n"; + return failed == 0 ? 0 : 1; +} diff --git a/progress.md b/progress.md index 1f56412..2d4025f 100644 --- a/progress.md +++ b/progress.md @@ -11260,3 +11260,47 @@ including section/check coverage and readiness scoring. - `editor/src/DocumentationOperatorPlaybooks.h` within header-size limit (`99` <= `600`) - `editor/tests/step592_test.cpp` within test-file size guidance (`154` lines) - Header-only architecture and naming conventions remain aligned with `ARCHITECTURE.md` + +### Step 593: Sprint 33 Integration + Program Summary +**Status:** PASS (8/8 tests) + +Completes Sprint 33 integration by aggregating product-experience and +operational-hardening readiness into final program-level outcome signals. + +**Files added:** +- `editor/src/Sprint33IntegrationSummary.h` - sprint integration module: + - aggregates Phase 33a and 33b gate signals + - computes phase pass flags and Sprint 33 pass flag + - emits per-step failure notes and blocked phase notes + - emits sprint-level completion notes on full pass +- `editor/tests/step593_test.cpp` - 8 tests covering: + - full sprint pass path + - phase-specific failure blocking behavior + - success/failure note emission behavior + - multi-failure aggregation behavior + - all-false boundary behavior + - phase isolation behavior on single 33b failure + +**Files modified:** +- `editor/CMakeLists.txt` - `step593_test` target + +**Verification run:** +- `cmake -S editor -B editor/build-native` - PASS +- `cmake --build editor/build-native --target step593_test step592_test` - PASS +- `./editor/build-native/step593_test` - PASS (8/8) +- `./editor/build-native/step592_test` - PASS (12/12) regression coverage + +**Architecture gate check:** +- `editor/src/Sprint33IntegrationSummary.h` within header-size limit (`70` <= `600`) +- `editor/tests/step593_test.cpp` within test-file size guidance (`128` lines) +- Header-only architecture and naming conventions remain aligned with `ARCHITECTURE.md` + +**Phase 33b totals (589-593):** +- **Steps completed:** 5 +- **New tests in this phase plan:** 56/56 passing + +**Sprint 33 totals (584-593):** +- **Steps completed:** 10 +- **New tests in this sprint plan:** 112/112 passing +- **Phase 33a (584-588):** 56/56 passing +- **Phase 33b (589-593):** 56/56 passing