diff --git a/editor/CMakeLists.txt b/editor/CMakeLists.txt index a02f86d..3eb2922 100644 --- a/editor/CMakeLists.txt +++ b/editor/CMakeLists.txt @@ -4099,4 +4099,13 @@ target_link_libraries(step579_test PRIVATE tree_sitter_javascript tree_sitter_typescript tree_sitter_java tree_sitter_rust tree_sitter_go) +add_executable(step580_test tests/step580_test.cpp) +target_include_directories(step580_test PRIVATE src) +target_link_libraries(step580_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/TaskitemConfidenceAmbiguity.h b/editor/src/TaskitemConfidenceAmbiguity.h new file mode 100644 index 0000000..8aa42f7 --- /dev/null +++ b/editor/src/TaskitemConfidenceAmbiguity.h @@ -0,0 +1,85 @@ +#pragma once +// Step 580: Taskitem Confidence + Ambiguity Annotation + +#include "RequirementNormalizationConflictDetector.h" +#include "TaskitemGeneratorV2.h" + +#include +#include +#include +#include + +struct AnnotatedTaskitem { + GeneratedTaskitem base; + int confidence = 0; // 0..100 + int ambiguityCount = 0; + bool escalate = false; + std::vector reasons; +}; + +class TaskitemConfidenceAmbiguity { +public: + static bool annotate(const std::vector& tasks, + const RequirementNormalizationResult& normalized, + std::vector* out, + std::string* error) { + if (!out || !error) return false; + error->clear(); + out->clear(); + if (tasks.empty()) { + *error = "tasks_empty"; + return false; + } + + const int ambiguousRequirements = countAmbiguous(normalized.requirements); + const int conflictCount = static_cast(normalized.conflicts.size()); + + for (const auto& task : tasks) { + AnnotatedTaskitem item; + item.base = task; + item.ambiguityCount = ambiguousRequirements; + item.confidence = computeConfidence(task, ambiguousRequirements, conflictCount); + item.reasons = deriveReasons(task, ambiguousRequirements, conflictCount, item.confidence); + item.escalate = shouldEscalate(item); + out->push_back(item); + } + return true; + } + +private: + static int countAmbiguous(const std::vector& requirements) { + int count = 0; + for (const auto& req : requirements) if (req.ambiguous) ++count; + return count; + } + + static int computeConfidence(const GeneratedTaskitem& task, + int ambiguityCount, + int conflictCount) { + int confidence = 85; + if (!task.queueReady) confidence -= 25; + confidence -= ambiguityCount * 10; + confidence -= conflictCount * 8; + if (task.prerequisiteOps.size() > 2) confidence -= 5; + if (!task.dependencyTaskIds.empty()) confidence -= 4; + return std::max(0, std::min(100, confidence)); + } + + static std::vector deriveReasons(const GeneratedTaskitem& task, + int ambiguityCount, + int conflictCount, + int confidence) { + std::vector reasons; + if (!task.queueReady) reasons.push_back("queue_not_ready"); + if (ambiguityCount > 0) reasons.push_back("ambiguous_requirements:" + std::to_string(ambiguityCount)); + if (conflictCount > 0) reasons.push_back("conflicts_detected:" + std::to_string(conflictCount)); + if (!task.dependencyTaskIds.empty()) reasons.push_back("depends_on_prior_tasks"); + if (confidence < 60) reasons.push_back("low_confidence"); + if (reasons.empty()) reasons.push_back("high_confidence_clear_path"); + return reasons; + } + + static bool shouldEscalate(const AnnotatedTaskitem& item) { + return item.confidence < 60 || item.ambiguityCount > 0 || !item.base.queueReady; + } +}; diff --git a/editor/tests/step580_test.cpp b/editor/tests/step580_test.cpp new file mode 100644 index 0000000..0099889 --- /dev/null +++ b/editor/tests/step580_test.cpp @@ -0,0 +1,189 @@ +// Step 580: Taskitem Confidence + Ambiguity Annotation (12 tests) + +#include "TaskitemConfidenceAmbiguity.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 GeneratedTaskitem task(const std::string& id, bool queueReady) { + GeneratedTaskitem t; + t.taskId = id; + t.title = "title"; + t.milestoneId = "m1"; + t.queueReady = queueReady; + t.prerequisiteOps = {"validate-intake"}; + return t; +} + +static NormalizedRequirement req(const std::string& id, bool ambiguous) { + NormalizedRequirement r; + r.requirementId = id; + r.kind = NormalizedRequirementKind::Constraint; + r.normalizedText = "text"; + r.anchor = "constraints"; + r.sourceLine = 1; + r.ambiguous = ambiguous; + return r; +} + +void test_annotate_success() { + TEST(annotate_success); + std::vector out; + RequirementNormalizationResult normalized; + std::string error; + CHECK(TaskitemConfidenceAmbiguity::annotate({task("task-1", true)}, normalized, &out, &error), "annotate should succeed"); + CHECK(out.size() == 1, "annotated task count mismatch"); + PASS(); +} + +void test_annotate_fails_for_empty_tasks() { + TEST(annotate_fails_for_empty_tasks); + std::vector out; + RequirementNormalizationResult normalized; + std::string error; + CHECK(!TaskitemConfidenceAmbiguity::annotate({}, normalized, &out, &error), "annotate should fail"); + CHECK(error == "tasks_empty", "wrong error"); + PASS(); +} + +void test_queue_not_ready_reduces_confidence() { + TEST(queue_not_ready_reduces_confidence); + std::vector out; + RequirementNormalizationResult normalized; + std::string error; + CHECK(TaskitemConfidenceAmbiguity::annotate({task("task-1", false)}, normalized, &out, &error), "annotate should succeed"); + CHECK(out[0].confidence < 80, "confidence should be reduced"); + PASS(); +} + +void test_ambiguous_requirements_reduce_confidence() { + TEST(ambiguous_requirements_reduce_confidence); + std::vector out; + RequirementNormalizationResult normalized; + normalized.requirements.push_back(req("r1", true)); + std::string error; + CHECK(TaskitemConfidenceAmbiguity::annotate({task("task-1", true)}, normalized, &out, &error), "annotate should succeed"); + CHECK(out[0].ambiguityCount == 1, "ambiguity count mismatch"); + CHECK(out[0].confidence <= 75, "confidence should be reduced by ambiguity"); + PASS(); +} + +void test_conflicts_reduce_confidence() { + TEST(conflicts_reduce_confidence); + std::vector out; + RequirementNormalizationResult normalized; + normalized.conflicts.push_back({"a", "b", "constraint_contradiction", "detail"}); + std::string error; + CHECK(TaskitemConfidenceAmbiguity::annotate({task("task-1", true)}, normalized, &out, &error), "annotate should succeed"); + CHECK(out[0].confidence <= 77, "confidence should be reduced by conflicts"); + PASS(); +} + +void test_dependency_presence_adds_reason() { + TEST(dependency_presence_adds_reason); + std::vector out; + RequirementNormalizationResult normalized; + auto t = task("task-1", true); + t.dependencyTaskIds.push_back("task-0"); + std::string error; + CHECK(TaskitemConfidenceAmbiguity::annotate({t}, normalized, &out, &error), "annotate should succeed"); + bool found = false; + for (const auto& r : out[0].reasons) if (r == "depends_on_prior_tasks") found = true; + CHECK(found, "dependency reason expected"); + PASS(); +} + +void test_low_confidence_adds_reason() { + TEST(low_confidence_adds_reason); + std::vector out; + RequirementNormalizationResult normalized; + normalized.requirements.push_back(req("r1", true)); + normalized.requirements.push_back(req("r2", true)); + normalized.requirements.push_back(req("r3", true)); + normalized.conflicts.push_back({"a", "b", "constraint_contradiction", "detail"}); + auto t = task("task-1", false); + std::string error; + CHECK(TaskitemConfidenceAmbiguity::annotate({t}, normalized, &out, &error), "annotate should succeed"); + bool found = false; + for (const auto& r : out[0].reasons) if (r == "low_confidence") found = true; + CHECK(found, "low confidence reason expected"); + PASS(); +} + +void test_high_confidence_adds_clear_path_reason() { + TEST(high_confidence_adds_clear_path_reason); + std::vector out; + RequirementNormalizationResult normalized; + auto t = task("task-1", true); + std::string error; + CHECK(TaskitemConfidenceAmbiguity::annotate({t}, normalized, &out, &error), "annotate should succeed"); + CHECK(out[0].reasons[0] == "high_confidence_clear_path", "clear-path reason expected"); + PASS(); +} + +void test_escalate_when_queue_not_ready() { + TEST(escalate_when_queue_not_ready); + std::vector out; + RequirementNormalizationResult normalized; + std::string error; + CHECK(TaskitemConfidenceAmbiguity::annotate({task("task-1", false)}, normalized, &out, &error), "annotate should succeed"); + CHECK(out[0].escalate, "should escalate when queue not ready"); + PASS(); +} + +void test_escalate_when_ambiguous() { + TEST(escalate_when_ambiguous); + std::vector out; + RequirementNormalizationResult normalized; + normalized.requirements.push_back(req("r1", true)); + std::string error; + CHECK(TaskitemConfidenceAmbiguity::annotate({task("task-1", true)}, normalized, &out, &error), "annotate should succeed"); + CHECK(out[0].escalate, "should escalate when ambiguous"); + PASS(); +} + +void test_no_escalation_for_high_confidence_clear_item() { + TEST(no_escalation_for_high_confidence_clear_item); + std::vector out; + RequirementNormalizationResult normalized; + std::string error; + CHECK(TaskitemConfidenceAmbiguity::annotate({task("task-1", true)}, normalized, &out, &error), "annotate should succeed"); + CHECK(!out[0].escalate, "should not escalate"); + PASS(); +} + +void test_multiple_tasks_all_annotated() { + TEST(multiple_tasks_all_annotated); + std::vector out; + RequirementNormalizationResult normalized; + std::string error; + CHECK(TaskitemConfidenceAmbiguity::annotate({task("task-1", true), task("task-2", false)}, normalized, &out, &error), "annotate should succeed"); + CHECK(out.size() == 2, "two annotations expected"); + CHECK(out[1].escalate, "second should escalate"); + PASS(); +} + +int main() { + std::cout << "Step 580: Taskitem Confidence + Ambiguity Annotation\n"; + + test_annotate_success(); // 1 + test_annotate_fails_for_empty_tasks(); // 2 + test_queue_not_ready_reduces_confidence(); // 3 + test_ambiguous_requirements_reduce_confidence();// 4 + test_conflicts_reduce_confidence(); // 5 + test_dependency_presence_adds_reason(); // 6 + test_low_confidence_adds_reason(); // 7 + test_high_confidence_adds_clear_path_reason(); // 8 + test_escalate_when_queue_not_ready(); // 9 + test_escalate_when_ambiguous(); // 10 + test_no_escalation_for_high_confidence_clear_item(); // 11 + test_multiple_tasks_all_annotated(); // 12 + + std::cout << "\nResults: " << passed << "/" << (passed + failed) << " passed\n"; + return failed == 0 ? 0 : 1; +} diff --git a/progress.md b/progress.md index 4285438..8ffa06c 100644 --- a/progress.md +++ b/progress.md @@ -10768,3 +10768,36 @@ queue-readiness metadata, prerequisite operations, and dependency hints. - `editor/src/TaskitemGeneratorV2.h` within header-size limit (`65` <= `600`) - `editor/tests/step579_test.cpp` within test-file size guidance (`225` lines) - Header-only architecture and naming conventions remain aligned with `ARCHITECTURE.md` + +### Step 580: Taskitem Confidence + Ambiguity Annotation +**Status:** PASS (12/12 tests) + +Implements confidence and ambiguity annotation for generated taskitems to drive +routing/escalation behavior in constrained execution pipelines. + +**Files added:** +- `editor/src/TaskitemConfidenceAmbiguity.h` - annotation module: + - per-task confidence scoring from queue-readiness, ambiguity, conflicts, dependencies + - ambiguity/conflict reason synthesis for operator visibility + - escalation flag computation for low-confidence or ambiguous tasks + - stable bounded confidence outputs (`0..100`) +- `editor/tests/step580_test.cpp` - 12 tests covering: + - annotation success/failure behavior + - confidence reductions from queue/ambiguity/conflict signals + - reason generation behavior + - escalation/no-escalation behavior + - multi-task annotation behavior + +**Files modified:** +- `editor/CMakeLists.txt` - `step580_test` target + +**Verification run:** +- `cmake -S editor -B editor/build-native` - PASS +- `cmake --build editor/build-native --target step580_test step579_test` - PASS +- `./editor/build-native/step580_test` - PASS (12/12) +- `./editor/build-native/step579_test` - PASS (12/12) regression coverage + +**Architecture gate check:** +- `editor/src/TaskitemConfidenceAmbiguity.h` within header-size limit (`85` <= `600`) +- `editor/tests/step580_test.cpp` within test-file size guidance (`189` lines) +- Header-only architecture and naming conventions remain aligned with `ARCHITECTURE.md`