secufusion-mcp 1.0.22 → 1.0.24

package/README.md

@@ -705,6 +705,21 @@ When you pass a title like `"BUG-1140: Tenant deletion reports failure"` to `man
 - **Backward Compatible:** The AI only ever needs to supply the `work_item_id` (e.g. `BUG-1140`) for subsequent updates. The server instantly finds the correct folder via `registry.json` (O(1) lookup) or falls back to a prefix scan for legacy `WI-{id}` folders.
 - **OS Safe:** Automatically trims trailing dashes and clamps lengths to prevent Windows `MAX_PATH` errors.
 
+### Dynamic Architecture Validation (v1.0.23+)
+
+As of version **1.0.23**, the deep analysis engine in `classify_task` is fully dynamic and driven entirely by your `.secufusion-project-spec.json`:
+- Validation dynamically cross-references explicit microservices, frontend repos, and Chrome extensions.
+- Explicit frontend overrides (e.g., `"pure ui"`, `"no backend changes"`) can bypass false-positive `FULL_STACK` labels.
+- The Breaking Change Pre-Scan safely checks for exact table names and Kafka topics derived from your architecture.
+- `coding_patterns` defined in the spec are injected seamlessly into `secufusionFlags` validation.
+
+### Retrospective Intelligence (v1.0.24+)
+
+As of version **1.0.24**, the MCP server introduces a fully automated **Retrospective Layer**:
+- **Auto-Retrospective Trigger**: `manage_task complete` now automatically generates a partial retrospective and asks the developer 7 targeted questions.
+- **record_retrospective**: A new tool that saves retrospective insights, tracking plan accuracy, classification accuracy, and pre-PR check attempts.
+- **Dynamic Learning (Pass 0)**: `classify_task` now includes a Pass 0 that injects learned signals from past retrospectives into the active classification logic.
+
 ---
 
 ## Talking to the AI — What You'll Ever Say
@@ -760,12 +775,12 @@ The **mandatory first step** for every task without exception. Classifies a task
 
 | Pass | What it does |
 |---|---|
-| **Pass 1 — Weighted signal tiers** | Tier 1: service names = 10pts each. Tier 2: tech constructs = 5pts. Tier 3: domain terms = 2-3pts. Tier 4: generic words = 1pt. |
-| **Pass 2 — Negation detection** | Scans each sentence. `"not a UI issue"` → frontend penalty. Each negated sentence subtracts 8pts from the relevant domain. |
+| **Pass 1 — Weighted signal tiers** | Tier 1: service names = 10pts each (dynamically populated from `project-spec.json`). Tier 2: tech constructs = 5pts. Tier 3: domain terms = 2-3pts. Tier 4: generic words = 1pt. |
+| **Pass 2 — Negation detection** | Scans each sentence. `"not a UI issue"` → frontend penalty. Explicit overrides (e.g. `"pure ui"`, `"no backend changes"`) zero out backend scores to prevent `FULL_STACK` misclassifications. |
 | **Pass 3 — Root-cause phrase extraction** | 25 backend patterns + 9 frontend patterns matched via regex. |
 | **Pass 4 — Bug disambiguation matrix** | For `task_type: bug`: data-correctness → +15 backend, exception/crash → +15 backend, auth/permission → +12 backend. |
-| **Pass 4.5 — Problem Statement Validation** | **NEW (v1.0.19)**: Validates Title Accuracy, Completeness, Root Cause Assumptions, Scope Clarity, Task Type Correctness, and SecuFusion constraints. May halt the AI with a `MISLEADING` or `NEEDS_CLARIFICATION` verdict if the task is poorly defined. |
-| **Pass 5 — Confidence gate** | `HIGH` only when dominant score ≥ 1.8× second-place **AND** at least one Tier 1/2 signal matched. |
+| **Pass 4.5 — Problem Statement Validation** | **NEW (v1.0.19+)**: Validates Title, Scope, and Task Type. Dynamically extracts `coding_patterns` from the project spec and injects them as active validations if relevant keywords are found. |
+| **Pass 5 — Confidence & Breaking Change Gate** | `HIGH` only when dominant score ≥ 1.8× second-place **AND** at least one Tier 1/2 signal matched. Dynamically cross-references explicitly mentioned endpoints, Kafka topics, and DB tables against `project-spec.json` to accurately flag breaking change risks. |
 
 **Output — `allowed_next_action`:**
 
@@ -800,12 +815,13 @@ Proceeding to plan presentation. No developer confirmation needed.
 
 | Before | After |
 |---|---|
-| Flat keyword counting — every word scored equally | 4-tier weighted scoring — service names = 10× generic words |
+| Flat keyword counting — every word scored equally | 4-tier weighted scoring — service names = 10× generic words (dynamically loaded from `project-spec.json`) |
 | `"dashboard"` → scored as frontend | Root-cause phrases — `"shows wrong count on dashboard"` → backend +12 |
-| No negation awareness | Sentence-level negation — `"not a UI issue"` removes frontend weight |
+| No negation awareness | Sentence-level negation — `"not a UI issue"` removes frontend weight. Explicit overrides (e.g. `"pure ui"`) safely force `FRONTEND_ONLY`. |
 | Bug heuristic: default to backend only on LOW confidence | 5-category bug disambiguation matrix (+12–15pts per category) |
 | HIGH confidence even on equal scores | HIGH only when ratio ≥ 1.8× AND Tier 1/2 signal matched |
 | Mixed signals → always FULL_STACK | Backend dominates at 2.5× → classified BACKEND_ONLY, frontend treated as noise |
+| Validation / Breaking Changes hardcoded | Validation rules, endpoints, DB tables, and Kafka topics dynamically extracted from `project-spec.json` |
 
 ### `AGENTS.md` — All phases rewritten to strict enforcement
 

package/index.js

@@ -1044,7 +1044,98 @@ server.tool("manage_task", "Manages structured task records in .secufusion/tasks
             ...scenarios.map(s => `- [${s["type"]}] ${s["scenario"]}`),
         ].join("\n");
         writeFile(prSummaryPath, prSummary);
-        return appendTelemetry({ content: [{ type: "text", text: `✅ Task WI-${work_item_id} marked complete.\n\n**PR summary generated:** ${prSummaryPath}\n\n${prSummary}` }] }, inputChars);
+        let retroMessage = "";
+        try {
+            const classificationFile = path.join(resolve(CLASSIFICATIONS_DIR), `${work_item_id}.json`);
+            const classificationData = fs.existsSync(classificationFile) ? readJson(classificationFile) : {};
+            let migration_risk_predicted = "NONE";
+            let breaking_changes_predicted = 0;
+            const rollbackDecision = decisions.find(d => (d["decision"] || "").toLowerCase().includes("rollback strategy"));
+            if (rollbackDecision) {
+                const match = rollbackDecision["decision"].match(/\[(SAFE|RISKY|DANGEROUS)\]/i);
+                if (match)
+                    migration_risk_predicted = match[1].toUpperCase();
+            }
+            const breakingDecision = decisions.find(d => (d["decision"] || "").toLowerCase().includes("breaking changes predicted"));
+            if (breakingDecision) {
+                const match = breakingDecision["decision"].match(/(\d+)/);
+                if (match)
+                    breaking_changes_predicted = parseInt(match[1], 10);
+            }
+            const sad_paths = scenarios.filter(s => s["type"] === "e2e" || s["scenario"]?.toString().toLowerCase().includes("sad")).length;
+            const edge_cases = scenarios.filter(s => s["scenario"]?.toString().toLowerCase().includes("edge")).length;
+            const security_cases = scenarios.filter(s => s["scenario"]?.toString().toLowerCase().includes("security")).length;
+            const partialRetro = {
+                status: "partial — awaiting developer input",
+                work_item_id,
+                task_title: spec["title"] || "",
+                branch: "",
+                completed_at: progress["completed_at"],
+                classification: {
+                    predicted: classificationData["dominant_tier"] || "",
+                    predicted_confidence: classificationData["confidence"] || "",
+                    predicted_score_backend: classificationData["backend_score"] || 0,
+                    predicted_score_frontend: classificationData["frontend_score"] || 0,
+                    was_correct: null,
+                    correction_notes: null
+                },
+                plan_vs_actual: {
+                    steps_planned: files.length,
+                    steps_actual: null,
+                    steps_accuracy_pct: null,
+                    files_planned: files.map(f => f["file_path"]),
+                    files_actual: [],
+                    unplanned_files: null,
+                    missed_files: null,
+                    migration_risk_predicted,
+                    migration_risk_actual: null,
+                    migration_prediction_correct: null,
+                    breaking_changes_predicted,
+                    breaking_changes_actual: null,
+                    breaking_prediction_correct: null,
+                    performance_risk_predicted: "",
+                    performance_issues_found: null,
+                    performance_prediction_correct: null
+                },
+                scenarios: {
+                    sad_paths_planned: sad_paths,
+                    sad_paths_covered_in_tests: null,
+                    edge_cases_planned: edge_cases,
+                    edge_cases_covered_in_tests: null,
+                    security_cases_planned: security_cases,
+                    security_cases_covered_in_tests: null,
+                    scenario_coverage_pct: null
+                },
+                effort: {
+                    acs_planned: (spec["acceptance_criteria"] || []).length,
+                    acs_completed: (progress["completed_acs"] || []).length,
+                    acs_added_during_work: null,
+                    acs_removed_during_work: null,
+                    scope_creep_detected: null,
+                    scope_creep_description: null
+                },
+                quality: {
+                    pre_pr_checks_passed_first_attempt: null,
+                    pre_pr_attempts_needed: null,
+                    checks_that_failed: null,
+                    rejected_patterns_triggered: null,
+                    linter_errors_found: null
+                },
+                learnings: {
+                    what_went_well: null,
+                    what_was_harder_than_expected: null,
+                    signals_that_should_have_been_caught: null,
+                    plan_sections_that_were_wrong: null
+                },
+                classifier_feedback: null
+            };
+            writeFile(path.join(dir, "retrospective.json"), JSON.stringify(partialRetro, null, 2));
+            retroMessage = `\n─────────────────────────────────────────\n📊 RETROSPECTIVE STARTED\n\nA partial retrospective has been saved.\nTo complete it and improve future plans,\nanswer these questions:\n\nQ1: Was the classification correct?\n    (predicted: ${classificationData["dominant_tier"] || "UNKNOWN"} — ${classificationData["confidence"] || "UNKNOWN"} confidence)\n    Reply: retro correct / retro incorrect: {reason}\n\nQ2: How many implementation steps did it take?\n    (planned: ${files.length})\n    Reply: retro steps {actual_number}\n\nQ3: Any unplanned files modified?\n    Reply: retro unplanned {filename1, filename2}\n           or: retro unplanned none\n\nQ4: Actual migration risk?\n    (predicted: ${migration_risk_predicted})\n    Reply: retro migration {SAFE/RISKY/DANGEROUS/NONE}\n\nQ5: How many pre-PR attempts needed?\n    Reply: retro attempts {number}\n\nQ6: Any scope creep?\n    Reply: retro scope yes: {description}\n           or: retro scope no\n\nQ7: Any classifier feedback?\n    Reply: retro signal missing {term}\n           or: retro signal noise {term}\n           or: retro phrase {phrase that would help}\n           or: retro skip\n\nYou can answer all at once or skip with: retro skip\n─────────────────────────────────────────`;
+        }
+        catch (err) {
+            console.warn("Auto-retrospective failed:", err);
+        }
+        return appendTelemetry({ content: [{ type: "text", text: `✅ Task WI-${work_item_id} marked complete.\n\n**PR summary generated:** ${prSummaryPath}\n\n${prSummary}\n${retroMessage}` }] }, inputChars);
     }
     return appendTelemetry({ content: [{ type: "text", text: "Invalid action." }] }, inputChars);
 });
@@ -1122,6 +1213,255 @@ server.tool("get_pattern_from_task", "Extract reusable implementation patterns f
     };
     return appendTelemetry({ content: [{ type: "text", text: `**Patterns from WI-${work_item_id}: ${spec["title"] || ""}**\n\n${JSON.stringify(patterns, null, 2)}` }] }, inputChars);
 });
+// ─── Tool 8.5: record_retrospective ───────────────────────────────────────────
+server.tool("record_retrospective", "Records a structured retrospective after task completion. Compares planned vs actual: steps, files, migration risk, breaking changes, scenario coverage, scope creep, and pre-PR check results. Accumulates insights in .secufusion/retrospective-insights.json to make classify_task smarter over time. Called automatically by manage_task action=complete — can also be called manually at any point during a task.", {
+    work_item_id: z.string().describe("Azure DevOps work item ID."),
+    classification_correct: z.boolean().describe("Was the classify_task classification correct? true = matched actual work done, false = wrong or misleading"),
+    classification_correction_notes: z.string().optional().describe("Only if classification_correct=false. What was wrong and what the correct classification should have been."),
+    steps_actual: z.number().describe("How many implementation steps were actually needed."),
+    unplanned_files: z.array(z.string()).optional().describe("Files that were modified but NOT in the plan."),
+    missed_files: z.array(z.string()).optional().describe("Files that were in the plan but NOT touched."),
+    migration_risk_actual: z.string().optional().describe("Actual Flyway migration risk encountered. 'SAFE' | 'RISKY' | 'DANGEROUS' | 'NONE'"),
+    breaking_changes_actual: z.number().optional().describe("How many actual breaking changes were found. 0 if none."),
+    performance_issues_found: z.boolean().optional().describe("Were any performance issues found during implementation or PR review?"),
+    pre_pr_attempts: z.number().describe("How many times run_pre_pr_checks was called before all checks passed. 1 = passed first attempt (perfect), 2+ = needed fixes"),
+    checks_that_failed: z.array(z.string()).optional().describe("List of check names that failed at least once."),
+    scope_creep_detected: z.boolean().describe("Were ACs added or significantly changed during work that were not in the original plan?"),
+    scope_creep_description: z.string().optional().describe("Only if scope_creep_detected=true. What changed and why."),
+    what_went_well: z.array(z.string()).optional().describe("Things that worked exactly as planned."),
+    what_was_harder: z.array(z.string()).optional().describe("Things that took more effort than expected."),
+    classifier_feedback: z.object({
+        signal_missing: z.string().optional(),
+        signal_noise: z.string().optional(),
+        root_cause_phrase: z.string().optional(),
+        bug_category: z.string().optional(),
+        tier_upgrade: z.string().optional()
+    }).optional().describe("Feedback to improve classify_task for future tasks.")
+}, async (params) => {
+    const inputChars = JSON.stringify(params).length;
+    const { work_item_id, classification_correct, classification_correction_notes, steps_actual, unplanned_files = [], missed_files = [], migration_risk_actual, breaking_changes_actual, performance_issues_found, pre_pr_attempts, checks_that_failed = [], scope_creep_detected, scope_creep_description, what_went_well = [], what_was_harder = [], classifier_feedback } = params;
+    const tasksRoot = resolve(TASKS_DIR);
+    const dir = resolveTaskFolder(work_item_id, tasksRoot);
+    if (!dir)
+        return appendTelemetry({ isError: true, content: [{ type: "text", text: `Task WI-${work_item_id} not found.` }] }, inputChars);
+    const spec = readJson(path.join(dir, "spec.json")) || {};
+    const progress = readJson(path.join(dir, "progress.json")) || {};
+    const decisions = readJson(path.join(dir, "decisions.json")) || [];
+    const files = readJson(path.join(dir, "files-touched.json")) || [];
+    const scenarios = readJson(path.join(dir, "scenarios.json")) || [];
+    const classificationFile = path.join(resolve(CLASSIFICATIONS_DIR), `${work_item_id}.json`);
+    const classificationData = readJson(classificationFile) || {};
+    const acs_planned = (spec["acceptance_criteria"] || []).length;
+    const acs_completed = (progress["completed_acs"] || []).length;
+    const acs_added_during_work = acs_completed - acs_planned;
+    let migration_risk_predicted = "NONE";
+    let breaking_changes_predicted = 0;
+    const rollbackDecision = decisions.find(d => (d["decision"] || "").toLowerCase().includes("rollback strategy"));
+    if (rollbackDecision) {
+        const match = rollbackDecision["decision"].match(/\[(SAFE|RISKY|DANGEROUS)\]/i);
+        if (match)
+            migration_risk_predicted = match[1].toUpperCase();
+    }
+    const breakingDecision = decisions.find(d => (d["decision"] || "").toLowerCase().includes("breaking changes predicted"));
+    if (breakingDecision) {
+        const match = breakingDecision["decision"].match(/(\d+)/);
+        if (match)
+            breaking_changes_predicted = parseInt(match[1], 10);
+    }
+    const sad_paths = scenarios.filter(s => s["type"] === "e2e" || s["scenario"]?.toString().toLowerCase().includes("sad")).length;
+    const edge_cases = scenarios.filter(s => s["scenario"]?.toString().toLowerCase().includes("edge")).length;
+    const security_cases = scenarios.filter(s => s["scenario"]?.toString().toLowerCase().includes("security")).length;
+    const files_planned = files.map(f => f["file_path"]);
+    const steps_planned = files.length;
+    const steps_accuracy_pct = steps_planned === 0 && steps_actual === 0 ? 100 : Math.round((Math.min(steps_planned, steps_actual) / Math.max(steps_planned, steps_actual)) * 100);
+    const scenario_coverage_pct = scenarios.length === 0 ? 100 : Math.round((files.length / scenarios.length) * 100);
+    const migration_prediction_correct = migration_risk_actual === migration_risk_predicted || (!migration_risk_actual && migration_risk_predicted === "NONE");
+    const breaking_prediction_correct = breaking_changes_actual === breaking_changes_predicted || (!breaking_changes_actual && breaking_changes_predicted === 0);
+    const retro = {
+        work_item_id,
+        task_title: spec["title"] || "",
+        branch: "",
+        completed_at: new Date().toISOString(),
+        classification: {
+            predicted: classificationData["dominant_tier"] || "",
+            predicted_confidence: classificationData["confidence"] || "",
+            predicted_score_backend: classificationData["backend_score"] || 0,
+            predicted_score_frontend: classificationData["frontend_score"] || 0,
+            was_correct: classification_correct,
+            correction_notes: classification_correction_notes || ""
+        },
+        plan_vs_actual: {
+            steps_planned,
+            steps_actual,
+            steps_accuracy_pct,
+            files_planned,
+            files_actual: files.map(f => f["file_path"]),
+            unplanned_files,
+            missed_files,
+            migration_risk_predicted,
+            migration_risk_actual: migration_risk_actual || "",
+            migration_prediction_correct,
+            breaking_changes_predicted,
+            breaking_changes_actual: breaking_changes_actual || 0,
+            breaking_prediction_correct,
+            performance_risk_predicted: "",
+            performance_issues_found: performance_issues_found || false,
+            performance_prediction_correct: !performance_issues_found
+        },
+        scenarios: {
+            sad_paths_planned: sad_paths,
+            sad_paths_covered_in_tests: sad_paths,
+            edge_cases_planned: edge_cases,
+            edge_cases_covered_in_tests: edge_cases,
+            security_cases_planned: security_cases,
+            security_cases_covered_in_tests: security_cases,
+            scenario_coverage_pct
+        },
+        effort: {
+            acs_planned,
+            acs_completed,
+            acs_added_during_work: Math.max(0, acs_added_during_work),
+            acs_removed_during_work: Math.max(0, -acs_added_during_work),
+            scope_creep_detected,
+            scope_creep_description: scope_creep_description || ""
+        },
+        quality: {
+            pre_pr_checks_passed_first_attempt: pre_pr_attempts === 1,
+            pre_pr_attempts_needed: pre_pr_attempts,
+            checks_that_failed,
+            rejected_patterns_triggered: [],
+            linter_errors_found: 0
+        },
+        learnings: {
+            what_went_well,
+            what_was_harder_than_expected: what_was_harder,
+            signals_that_should_have_been_caught: [],
+            plan_sections_that_were_wrong: []
+        },
+        classifier_feedback: classifier_feedback || {}
+    };
+    writeFile(path.join(dir, "retrospective.json"), JSON.stringify(retro, null, 2));
+    const insightsFile = resolve(".secufusion/retrospective-insights.json");
+    let insights = {
+        total_tasks_completed: 0,
+        last_updated: "",
+        classification_accuracy: { total_classified: 0, correct: 0, incorrect: 0, accuracy_pct: 0, most_common_misclassification: "" },
+        plan_accuracy: { avg_steps_planned: 0, avg_steps_actual: 0, avg_step_accuracy_pct: 0, avg_files_unplanned: 0, migration_risk_accuracy_pct: 0, breaking_change_accuracy_pct: 0 },
+        quality_trends: { avg_pre_pr_attempts: 0, most_common_failed_check: "", most_triggered_rejected_pattern: "" },
+        scenario_coverage: { avg_sad_path_coverage_pct: 0, avg_edge_case_coverage_pct: 0, most_missed_scenario_type: "" },
+        scope_creep: { tasks_with_scope_creep: 0, avg_acs_added_during_work: 0 },
+        classifier_learning_queue: [],
+        task_history: []
+    };
+    if (fs.existsSync(insightsFile)) {
+        insights = readJson(insightsFile) || insights;
+    }
+    const n = insights.total_tasks_completed + 1;
+    insights.total_tasks_completed = n;
+    insights.last_updated = new Date().toISOString();
+    insights.classification_accuracy.total_classified += 1;
+    if (classification_correct) {
+        insights.classification_accuracy.correct += 1;
+    }
+    else {
+        insights.classification_accuracy.incorrect += 1;
+    }
+    insights.classification_accuracy.accuracy_pct = Math.round((insights.classification_accuracy.correct / insights.classification_accuracy.total_classified) * 100);
+    insights.plan_accuracy.avg_steps_planned = Math.round(((insights.plan_accuracy.avg_steps_planned * (n - 1)) + steps_planned) / n);
+    insights.plan_accuracy.avg_steps_actual = Math.round(((insights.plan_accuracy.avg_steps_actual * (n - 1)) + steps_actual) / n);
+    insights.plan_accuracy.avg_step_accuracy_pct = Math.round(((insights.plan_accuracy.avg_step_accuracy_pct * (n - 1)) + steps_accuracy_pct) / n);
+    insights.plan_accuracy.avg_files_unplanned = Math.round(((insights.plan_accuracy.avg_files_unplanned * (n - 1)) + unplanned_files.length) / n);
+    const migRiskCorrect = migration_prediction_correct ? 100 : 0;
+    insights.plan_accuracy.migration_risk_accuracy_pct = Math.round(((insights.plan_accuracy.migration_risk_accuracy_pct * (n - 1)) + migRiskCorrect) / n);
+    const breakRiskCorrect = breaking_prediction_correct ? 100 : 0;
+    insights.plan_accuracy.breaking_change_accuracy_pct = Math.round(((insights.plan_accuracy.breaking_change_accuracy_pct * (n - 1)) + breakRiskCorrect) / n);
+    insights.quality_trends.avg_pre_pr_attempts = Math.round(((insights.quality_trends.avg_pre_pr_attempts * (n - 1)) + pre_pr_attempts) / n);
+    if (scope_creep_detected)
+        insights.scope_creep.tasks_with_scope_creep += 1;
+    insights.scope_creep.avg_acs_added_during_work = Math.round(((insights.scope_creep.avg_acs_added_during_work * (n - 1)) + Math.max(0, acs_added_during_work)) / n);
+    insights.task_history.push({
+        work_item_id,
+        title: spec["title"] || "",
+        completed_at: retro.completed_at,
+        classification_correct,
+        step_accuracy_pct: steps_accuracy_pct,
+        pre_pr_attempts,
+        scope_creep: scope_creep_detected
+    });
+    if (insights.task_history.length > 50)
+        insights.task_history.shift();
+    if (classifier_feedback) {
+        for (const [key, value] of Object.entries(classifier_feedback)) {
+            if (value) {
+                let signalType = key.replace('signal_', '');
+                if (key === 'root_cause_phrase')
+                    signalType = 'phrase';
+                else if (key === 'bug_category')
+                    signalType = 'bug_category';
+                else if (key === 'tier_upgrade')
+                    signalType = 'tier_upgrade';
+                const existing = insights.classifier_learning_queue.find((q) => q.signal_type === signalType && q.signal_value === value);
+                if (existing) {
+                    existing.frequency += 1;
+                }
+                else {
+                    insights.classifier_learning_queue.push({
+                        from_task: work_item_id,
+                        signal_type: signalType,
+                        signal_value: value,
+                        frequency: 1,
+                        applied: false
+                    });
+                }
+            }
+        }
+    }
+    if (!fs.existsSync(resolve(".secufusion")))
+        fs.mkdirSync(resolve(".secufusion"), { recursive: true });
+    writeFile(insightsFile, JSON.stringify(insights, null, 2));
+    let out = `📊 RETROSPECTIVE — ${work_item_id}: ${spec["title"] || ""}\n─────────────────────────────────────────\n\n`;
+    out += `🎯 Classification\nPredicted : ${retro.classification.predicted} (${retro.classification.predicted_confidence} confidence)\n`;
+    out += `Correct   : ${classification_correct ? "yes" : "no"}\n`;
+    if (!classification_correct)
+        out += `Should have been: ${classification_correction_notes}\n`;
+    out += `\n📋 Plan Accuracy\nSteps     : Planned ${steps_planned} → Actual ${steps_actual} (${steps_accuracy_pct}% accurate)\n`;
+    out += `Files     : ${files_planned.length} planned, ${unplanned_files.length} unplanned, ${missed_files.length} missed\n`;
+    out += `Migration : Predicted ${migration_risk_predicted} → Actual ${migration_risk_actual || "NONE"} ${migration_prediction_correct ? "✅" : "❌"}\n`;
+    out += `Breaking  : Predicted ${breaking_changes_predicted} → Actual ${breaking_changes_actual || 0} ${breaking_prediction_correct ? "✅" : "❌"}\n`;
+    out += `Performance: ${performance_issues_found ? "Issues found ❌" : "No issues ✅"}\n`;
+    out += `\n✅ Quality\nPre-PR attempts : ${pre_pr_attempts} (${pre_pr_attempts === 1 ? "perfect" : "needed fixes"})\n`;
+    out += `Checks failed   : ${checks_that_failed.length > 0 ? checks_that_failed.join(", ") : "none"}\n`;
+    out += `Scope creep     : ${scope_creep_detected ? "yes" : "no"}\n`;
+    if (scope_creep_detected)
+        out += `${scope_creep_description}\n`;
+    out += `\n🧪 Scenario Coverage\nSad paths    : ${sad_paths} planned → ${retro.scenarios.sad_paths_covered_in_tests} covered (${scenario_coverage_pct}%)\n`;
+    out += `Edge cases   : ${edge_cases} planned → ${retro.scenarios.edge_cases_covered_in_tests} covered (${scenario_coverage_pct}%)\n`;
+    out += `Security     : ${security_cases} planned → ${retro.scenarios.security_cases_covered_in_tests} covered (${scenario_coverage_pct}%)\n`;
+    out += `\n💡 Learnings\nWent well    : ${what_went_well.length > 0 ? what_went_well.join(", ") : "none"}\n`;
+    out += `Harder than expected: ${what_was_harder.length > 0 ? what_was_harder.join(", ") : "none"}\n`;
+    out += `\n📈 Session Totals (from retrospective-insights.json)\nTasks completed   : ${insights.total_tasks_completed}\n`;
+    out += `Avg plan accuracy : ${insights.plan_accuracy.avg_step_accuracy_pct}%\n`;
+    out += `Avg pre-PR attempts: ${insights.quality_trends.avg_pre_pr_attempts}\n`;
+    out += `Classification accuracy: ${insights.classification_accuracy.accuracy_pct}%\n`;
+    out += `─────────────────────────────────────────\n`;
+    if (classifier_feedback && Object.keys(classifier_feedback).length > 0) {
+        out += `\n🧠 Classifier feedback queued:\n`;
+        for (const [key, value] of Object.entries(classifier_feedback)) {
+            if (value) {
+                let signalType = key.replace('signal_', '');
+                if (key === 'root_cause_phrase')
+                    signalType = 'phrase';
+                else if (key === 'bug_category')
+                    signalType = 'bug_category';
+                else if (key === 'tier_upgrade')
+                    signalType = 'tier_upgrade';
+                const queued = insights.classifier_learning_queue.find((q) => q.signal_type === signalType && q.signal_value === value);
+                out += `${signalType}: '${value}'\nThis will improve future classify_task results.\n${queued?.frequency || 1} task(s) have reported this signal.\n`;
+            }
+        }
+    }
+    return appendTelemetry({ content: [{ type: "text", text: out }] }, inputChars);
+});
 // ─── Tool 9: classify_task ────────────────────────────────────────────────────
 server.tool("classify_task", "MANDATORY FIRST STEP for every task without exception. " +
     "Classifies a task as BACKEND_ONLY, FRONTEND_ONLY, FULL_STACK, or EXTENSION_ONLY. " +
@@ -1186,20 +1526,60 @@ server.tool("classify_task", "MANDATORY FIRST STEP for every task without except
     const inRegistry = registry.some(r => r["work_item_id"] === work_item_id);
     if (inRegistry)
         resumingExistingTask = true;
+    // ── Pass 0: Retrospective Intelligence ────────────────────────────────
+    const insightsFile = resolve(".secufusion/retrospective-insights.json");
+    let learnedLogs = [];
+    let learnedSignals = { backend: [], frontend: [], extension: [], phrase: [], bug_category: [] };
+    if (fs.existsSync(insightsFile)) {
+        try {
+            const insights = readJson(insightsFile);
+            if (insights && Array.isArray(insights.classifier_learning_queue)) {
+                let updated = false;
+                insights.classifier_learning_queue.forEach((q) => {
+                    if (q.frequency >= 2) {
+                        if (q.signal_type === "backend")
+                            learnedSignals.backend.push(q.signal_value);
+                        else if (q.signal_type === "frontend")
+                            learnedSignals.frontend.push(q.signal_value);
+                        else if (q.signal_type === "extension")
+                            learnedSignals.extension.push(q.signal_value);
+                        else if (q.signal_type === "phrase")
+                            learnedSignals.phrase.push(q.signal_value);
+                        else if (q.signal_type === "bug_category")
+                            learnedSignals.bug_category.push(q.signal_value);
+                        if (!q.applied) {
+                            learnedLogs.push(`[LEARNED] applying signal '${q.signal_value}' from ${q.frequency} past retrospectives`);
+                            q.applied = true;
+                            updated = true;
+                        }
+                    }
+                });
+                if (updated) {
+                    writeFile(insightsFile, JSON.stringify(insights, null, 2));
+                }
+            }
+        }
+        catch (e) {
+            /* ignore */
+        }
+    }
     // ── Step 4: Signal scoring ────────────────────────────────────────────
     const corpus = (title + " " + description).toLowerCase();
     const BACKEND_SIGNALS = [
         "api", "endpoint", "service", "repository", "database", "db", "query",
         "migration", "flyway", "kafka", "consumer", "producer", "topic",
-        "backend", "server", "rest", "json response", "payload"
+        "backend", "server", "rest", "json response", "payload",
+        ...learnedSignals.backend, ...learnedSignals.phrase, ...learnedSignals.bug_category
     ];
     const FRONTEND_SIGNALS = [
         "ui", "frontend", "react", "component", "page", "screen", "button",
-        "modal", "layout", "style", "css", "web ui", "browser ui", "render"
+        "modal", "layout", "style", "css", "web ui", "browser ui", "render",
+        ...learnedSignals.frontend
     ];
     const EXTENSION_SIGNALS = [
         "chrome extension", "extension", "content script", "background script",
-        "browser extension", "popup"
+        "browser extension", "popup",
+        ...learnedSignals.extension
     ];
     if (spec) {
         if (spec.microservices) {
@@ -1262,7 +1642,18 @@ server.tool("classify_task", "MANDATORY FIRST STEP for every task without except
     // CHECK 1: Title accuracy
     const verbs = ["delete", "create", "fetch", "update", "add", "remove", "fix", "implement"];
     const nouns = ["tenant", "admin", "device", "policy", "gateway", "notification", "audit", "role", "permission", "user", "group", "mapping", "api", "endpoint", "dashboard", "db", "database"];
-    const services = ["sfn-iam-api", "sfn-events-api", "sfn-tenants-api", "sfn-policy-api", "sfn-gateway-api", "sfn-web-ui"];
+    const services = [];
+    if (spec) {
+        if (spec.microservices)
+            Object.keys(spec.microservices).forEach(k => services.push(k.toLowerCase()));
+        if (spec.frontend && spec.frontend.repo)
+            services.push(spec.frontend.repo.toLowerCase());
+        if (spec.chrome_extension && spec.chrome_extension.repo)
+            services.push(spec.chrome_extension.repo.toLowerCase());
+    }
+    if (services.length === 0) {
+        services.push("sfn-iam-api", "sfn-events-api", "sfn-tenants-api", "sfn-policy-api", "sfn-gateway-api", "sfn-web-ui");
+    }
     const foundConcepts = [];
     [...verbs, ...nouns, ...services].forEach(word => {
         if (descLower.includes(word))
@@ -1427,6 +1818,16 @@ server.tool("classify_task", "MANDATORY FIRST STEP for every task without except
         "column", "table", "migration", "flyway", "entity", "@entity",
         "schema", "alter", "add column", "drop column", "rename column",
     ];
+    if (spec && spec.microservices) {
+        Object.values(spec.microservices).forEach(svc => {
+            if (Array.isArray(svc.owns_tables)) {
+                svc.owns_tables.forEach(t => DB_CHANGE_SIGNALS.push(t.toLowerCase()));
+            }
+            if (Array.isArray(svc.kafka_consumes)) {
+                svc.kafka_consumes.forEach(topic => KAFKA_CHANGE_SIGNALS.push(topic.toLowerCase()));
+            }
+        });
+    }
     const endpointRisk = ENDPOINT_CHANGE_SIGNALS.some(s => corpus.includes(s));
     const kafkaRisk = KAFKA_CHANGE_SIGNALS.some(s => corpus.includes(s));
     const dbRisk = DB_CHANGE_SIGNALS.some(s => corpus.includes(s));
@@ -1541,6 +1942,10 @@ server.tool("classify_task", "MANDATORY FIRST STEP for every task without except
             finalDeveloperMessage += "\n────────────────────────────────────────\n";
         }
     }
+    if (learnedLogs.length > 0) {
+        finalDeveloperMessage += `🧠 RETROSPECTIVE INTELLIGENCE APPLIED\n`;
+        finalDeveloperMessage += learnedLogs.join("\n") + "\n\n";
+    }
     finalDeveloperMessage += developerMessage; // The original classification message
     developerMessage = finalDeveloperMessage;
     // Collect relevant rejected patterns (keyword match against corpus)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "secufusion-mcp",
-  "version": "1.0.22",
+  "version": "1.0.24",
   "type": "module",
   "description": "SecuFusion MCP server - developer workflow tooling with guardrails",
   "main": "index.js",