@alan512/experienceengine 0.1.2 → 0.2.0

package/dist/analyzer/llm-learning-gate.js

@@ -1,7 +1,10 @@
 import { createHash, createHmac } from "node:crypto";
 import { analyzeExperience } from "./experience-analyzer.js";
+import { buildCandidateSignals } from "./candidate-signals.js";
 import { dedupeCandidates } from "./node-deduper.js";
 import { normalizeCandidate } from "./node-normalizer.js";
+import { isSubstantiveToolEvent } from "../input/tool-event-significance.js";
+import { deriveTaskManagementSignals } from "../experience-management/task-management-signals.js";
 import { resolveDistillationResolution } from "../distillation/host-llm.js";
 import { resolveGoogleAdcAccessToken } from "../distillation/providers/google-adc.js";
 const DEFAULT_REQUEST_TIMEOUT_MS = 45_000;
@@ -34,11 +37,13 @@ Do not capture:
 - routine success with no reusable signal
 - repo-specific noise that would not help a later similar task
 - generic advice with no concrete trigger or verification signal
+- expression-layer edits that only refine wording, copy, labels, formatting, presentation, or inline notice phrasing
 
 Use experience_kind = expectation_correction when:
 - the first attempt technically worked or partially worked
 - but the user corrected the direction, layer, behavior, quality bar, or verification order
 - and the later direction produced a better or objectively supported result
+- do not use expectation_correction for copy-only, wording-only, style-only, or presentation-only refinements
 
 For expectation_correction candidates:
 - you must include confidence_signal, correction_scope, correction_category, deviation_pattern, and corrected_constraint
@@ -69,6 +74,8 @@ candidate may also include:
 - correction_category
 - deviation_pattern
 - corrected_constraint
+- promotion_signal
+- promotion_reason
 - goal
 - applicability_notes
 - recommended_steps
@@ -87,6 +94,8 @@ const EXPECTATION_CORRECTION_REPAIR_PROMPT = `You are repairing a coding-experie
 
 Decide whether the task should actually be stored as expectation_correction.
 
+Use the provided correction_window as the semantic detection context. Only promote when the correction window shows a real directional correction and the evidence_gate shows objective support or user confirmation.
+
 Return strict JSON:
 - expectation_correction: boolean
 - confidence_signal: confirmed_by_user | supported_by_objective_success | unconfirmed (required when true)
@@ -110,6 +119,87 @@ context_summary: "No user correction happened; this is a verification loop."
 draft.compact_hint: "Run pnpm typecheck after each change."
 output:
 {"expectation_correction":false}`;
+const EXPECTATION_CORRECTION_RESCUE_PROMPT = `You are rescuing a missed directional correction from a coding task.
+
+The main learner rejected this task as not broadly reusable. You should only rescue it when the correction window and evidence gate show a real reusable expectation correction.
+
+Return strict JSON:
+- expectation_correction: boolean
+- candidate: required only when expectation_correction=true
+
+candidate must include:
+- node_type: strategy | warning
+- task_type
+- trigger_pattern
+- compact_hint
+- success_signal
+- evidence_summary
+- experience_kind: expectation_correction
+- confidence_signal: confirmed_by_user | supported_by_objective_success | unconfirmed
+- validation_state: pending_reuse_validation
+- correction_scope: task_local | repo_local | workflow_local | host_local | cross_repo_candidate
+- correction_category: goal_interpretation | quality_bar | interaction_behavior | verification_order | implementation_boundary | style_constraint
+- deviation_pattern
+- corrected_constraint
+
+Do not rescue:
+- wording-only
+- copy-only
+- style-only
+- presentation-only
+- ordinary verification loops without a corrected direction`;
+const EVIDENCE_DRIVEN_REVERSAL_REPAIR_PROMPT = `You are repairing a coding-experience draft for evidence-driven reversal.
+
+Use the provided reversal_window as the semantic detection context. Only promote when:
+- an earlier active hypothesis or direction existed
+- later task evidence invalidated it
+- the task pivoted to a replacement path
+- later verification supported the replacement path
+
+Return strict JSON:
+- reversal_detected: boolean
+- reversal_source: task_evidence (required when true)
+- superseded_hypothesis: short sentence (required when true)
+- replacement_constraint: short sentence (required when true)
+- verification_evidence: short sentence (required when true)
+- pivot_summary: short sentence (optional)
+- correction_scope: task_local | repo_local | workflow_local | host_local | cross_repo_candidate (required when true)
+- correction_category: goal_interpretation | quality_bar | interaction_behavior | verification_order | implementation_boundary | style_constraint (required when true)
+- deviation_pattern: short sentence (required when true)
+- corrected_constraint: short sentence (required when true)
+
+Do not promote ordinary verification loops, confirmation of the same direction, or loose narrowing that did not overturn the original path.`;
+const EVIDENCE_DRIVEN_REVERSAL_RESCUE_PROMPT = `You are rescuing a missed evidence-driven reversal from a coding task.
+
+The main learner did not capture a reusable candidate. Rescue only when the reversal window shows:
+- a prior active hypothesis
+- stronger invalidating task evidence
+- a pivot into a replacement path
+- later validating evidence on the replacement path
+
+Return strict JSON:
+- reversal_detected: boolean
+- reversal_source: task_evidence (required when true)
+- superseded_hypothesis: short sentence (required when true)
+- replacement_constraint: short sentence (required when true)
+- verification_evidence: short sentence (required when true)
+- pivot_summary: short sentence (optional)
+- candidate: required only when reversal_detected=true
+
+candidate must include:
+- node_type: strategy | warning
+- task_type
+- trigger_pattern
+- compact_hint
+- success_signal
+- evidence_summary
+- experience_kind: expectation_correction
+- confidence_signal: confirmed_by_user | supported_by_objective_success | unconfirmed
+- validation_state: pending_reuse_validation
+- correction_scope: task_local | repo_local | workflow_local | host_local | cross_repo_candidate
+- correction_category: goal_interpretation | quality_bar | interaction_behavior | verification_order | implementation_boundary | style_constraint
+- deviation_pattern
+- corrected_constraint`;
 const sha256Hex = (value) => createHash("sha256").update(value, "utf8").digest("hex");
 const hmac = (key, value) => createHmac("sha256", key).update(value, "utf8").digest();
 const toAmzDate = (date) => date.toISOString().replace(/[:-]|\.\d{3}/g, "");
@@ -139,6 +229,7 @@ const CONFIDENCE_SIGNALS = [
     "supported_by_objective_success",
     "unconfirmed"
 ];
+const PROMOTION_SIGNALS = ["normal", "high_value"];
 const VALIDATION_STATES = [
     "pending_reuse_validation",
     "validated_by_reuse",
@@ -163,7 +254,29 @@ const isConfidenceSignal = (value) => typeof value === "string" && CONFIDENCE_SI
 const isValidationState = (value) => typeof value === "string" && VALIDATION_STATES.includes(value);
 const isCorrectionScope = (value) => typeof value === "string" && CORRECTION_SCOPES.includes(value);
 const isCorrectionCategory = (value) => typeof value === "string" && CORRECTION_CATEGORIES.includes(value);
+const isPromotionSignal = (value) => typeof value === "string" && PROMOTION_SIGNALS.includes(value);
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const hasSubstantiveLearningEvidence = (input) => input.tool_events.some((event) => isSubstantiveToolEvent(event));
+const EXPRESSION_LAYER_PATTERN = /\b(wording|phrasing|copy|label|labels|notice|message|messages|tooltip|readme|documentation|docs|format|formatting|presentation|tone|style|styling|inline notice)\b/i;
+const OBJECTIVE_VERIFICATION_PATTERN = /\b(test|probe|verify|verification|build|compile|lint|typecheck|doctor|assert|request|response|endpoint|routing|fixture|mock|integration)\b/i;
+const looksLikeExpressionLayerOnlyTask = (input) => {
+    const text = [input.task_summary, input.context_summary, ...input.tool_events.map((event) => event.output_summary ?? "")]
+        .filter(Boolean)
+        .join("\n");
+    if (!EXPRESSION_LAYER_PATTERN.test(text)) {
+        return false;
+    }
+    return !OBJECTIVE_VERIFICATION_PATTERN.test(text);
+};
+const resolveEligibilityRejectionReason = (input) => {
+    if (!hasSubstantiveLearningEvidence(input)) {
+        return "insufficient substantive evidence: only edit or exploratory events were observed";
+    }
+    if (looksLikeExpressionLayerOnlyTask(input)) {
+        return "task stayed in expression-layer refinement: wording, copy, or presentation changes are recorded but not learned";
+    }
+    return undefined;
+};
 const isTransientProviderFailure = (error) => {
     const message = error instanceof Error ? error.message : String(error);
     return (/timed out/i.test(message) ||
@@ -224,9 +337,33 @@ const normalizeDraft = (candidate, input) => {
         escalation_condition: pickString(candidate.escalation_condition),
         evidence_summary: evidenceSummary,
         retrieval_text: undefined,
+        promotion_signal: isPromotionSignal(candidate.promotion_signal) ? candidate.promotion_signal : undefined,
+        promotion_reason: pickString(candidate.promotion_reason),
         source_kind: "system_derived"
     });
 };
+const applyTaskManagementPromotionPolicy = (input, draft) => {
+    const signals = deriveTaskManagementSignals(input);
+    const preserveHighValue = signals.realDevLikely &&
+        (signals.bugFixLike ||
+            draft.experience_kind === "expectation_correction" ||
+            input.task_type === "bug_fix" ||
+            input.task_type === "config_debug" ||
+            input.task_type === "integration_fix");
+    if (draft.promotion_signal !== "high_value" || preserveHighValue) {
+        return draft;
+    }
+    const downgradeReason = signals.metaLike
+        ? "downgraded from high_value because the task looked meta-like and still needs real-dev reuse evidence"
+        : signals.validationLike
+            ? "downgraded from high_value because the task looked validation-heavy and still needs real-dev reuse evidence"
+            : draft.promotion_reason;
+    return {
+        ...draft,
+        promotion_signal: "normal",
+        promotion_reason: downgradeReason
+    };
+};
 export class LlmLearningGate {
     config;
     options;
@@ -321,7 +458,7 @@ export class LlmLearningGate {
             temperature: 0.1
         };
     }
-    buildExpectationCorrectionRepairBody(endpoint, input, draft, reason) {
+    buildExpectationCorrectionRepairBody(endpoint, input, draft, reason, directionalCorrection) {
         const payload = JSON.stringify({
             task_summary: input.task_summary,
             task_type: input.task_type,
@@ -342,6 +479,15 @@ export class LlmLearningGate {
                 success_signal: draft.success_signal,
                 evidence_summary: draft.evidence_summary
             },
+            correction_window: {
+                selected: directionalCorrection.detected,
+                snippets: directionalCorrection.snippets,
+                sources: directionalCorrection.sources
+            },
+            evidence_gate: {
+                objective_support: directionalCorrection.objective_support,
+                user_confirmation: directionalCorrection.user_confirmation
+            },
             original_reason: reason
         }, null, 2);
         if (endpoint.kind === "anthropic") {
@@ -395,6 +541,245 @@ export class LlmLearningGate {
             temperature: 0
         };
     }
+    buildExpectationCorrectionRescueBody(endpoint, input, reason, directionalCorrection) {
+        const payload = JSON.stringify({
+            task_summary: input.task_summary,
+            task_type: input.task_type,
+            context_summary: input.context_summary,
+            outcome_signal: input.outcome_signal,
+            tool_events: input.tool_events.map((event) => ({
+                tool_name: event.tool_name,
+                status: event.status,
+                error_signature: event.error_signature,
+                output_summary: event.output_summary
+            })),
+            correction_window: {
+                selected: directionalCorrection.detected,
+                snippets: directionalCorrection.snippets,
+                sources: directionalCorrection.sources
+            },
+            evidence_gate: {
+                objective_support: directionalCorrection.objective_support,
+                user_confirmation: directionalCorrection.user_confirmation
+            },
+            original_reason: reason
+        }, null, 2);
+        if (endpoint.kind === "anthropic") {
+            return {
+                model: endpoint.model,
+                max_tokens: 768,
+                system: EXPECTATION_CORRECTION_RESCUE_PROMPT,
+                messages: [{ role: "user", content: payload }],
+                temperature: 0
+            };
+        }
+        if (endpoint.kind === "gemini") {
+            return {
+                system_instruction: {
+                    parts: [{ text: EXPECTATION_CORRECTION_RESCUE_PROMPT }]
+                },
+                contents: [
+                    {
+                        role: "user",
+                        parts: [{ text: payload }]
+                    }
+                ],
+                generationConfig: {
+                    temperature: 0,
+                    responseMimeType: "application/json"
+                }
+            };
+        }
+        if (endpoint.kind === "bedrock") {
+            return {
+                system: [{ text: EXPECTATION_CORRECTION_RESCUE_PROMPT }],
+                messages: [
+                    {
+                        role: "user",
+                        content: [{ text: payload }]
+                    }
+                ],
+                inferenceConfig: {
+                    maxTokens: 768,
+                    temperature: 0
+                }
+            };
+        }
+        return {
+            model: endpoint.model,
+            response_format: { type: "json_object" },
+            messages: [
+                { role: "system", content: EXPECTATION_CORRECTION_RESCUE_PROMPT },
+                { role: "user", content: payload }
+            ],
+            temperature: 0
+        };
+    }
+    buildEvidenceDrivenReversalRepairBody(endpoint, input, draft, reason, reversal) {
+        const payload = JSON.stringify({
+            task_summary: input.task_summary,
+            task_type: input.task_type,
+            context_summary: input.context_summary,
+            outcome_signal: input.outcome_signal,
+            tool_events: input.tool_events.map((event) => ({
+                tool_name: event.tool_name,
+                status: event.status,
+                error_signature: event.error_signature,
+                output_summary: event.output_summary
+            })),
+            draft: {
+                task_type: draft.task_type,
+                node_type: draft.node_type,
+                experience_kind: draft.experience_kind,
+                trigger_pattern: draft.trigger_pattern,
+                compact_hint: draft.compact_hint,
+                success_signal: draft.success_signal,
+                evidence_summary: draft.evidence_summary
+            },
+            reversal_window: {
+                selected: reversal.detected,
+                hypothesis_snippets: reversal.hypothesis_snippets,
+                invalidating_snippets: reversal.invalidating_snippets,
+                pivot_snippets: reversal.pivot_snippets,
+                replacement_snippets: reversal.replacement_snippets,
+                validating_snippets: reversal.validating_snippets
+            },
+            evidence_gate: {
+                prior_hypothesis: reversal.prior_hypothesis,
+                invalidating_evidence: reversal.invalidating_evidence,
+                validating_evidence: reversal.validating_evidence
+            },
+            original_reason: reason
+        }, null, 2);
+        if (endpoint.kind === "anthropic") {
+            return {
+                model: endpoint.model,
+                max_tokens: 640,
+                system: EVIDENCE_DRIVEN_REVERSAL_REPAIR_PROMPT,
+                messages: [{ role: "user", content: payload }],
+                temperature: 0
+            };
+        }
+        if (endpoint.kind === "gemini") {
+            return {
+                system_instruction: {
+                    parts: [{ text: EVIDENCE_DRIVEN_REVERSAL_REPAIR_PROMPT }]
+                },
+                contents: [
+                    {
+                        role: "user",
+                        parts: [{ text: payload }]
+                    }
+                ],
+                generationConfig: {
+                    temperature: 0,
+                    responseMimeType: "application/json"
+                }
+            };
+        }
+        if (endpoint.kind === "bedrock") {
+            return {
+                system: [{ text: EVIDENCE_DRIVEN_REVERSAL_REPAIR_PROMPT }],
+                messages: [
+                    {
+                        role: "user",
+                        content: [{ text: payload }]
+                    }
+                ],
+                inferenceConfig: {
+                    maxTokens: 640,
+                    temperature: 0
+                }
+            };
+        }
+        return {
+            model: endpoint.model,
+            response_format: { type: "json_object" },
+            messages: [
+                { role: "system", content: EVIDENCE_DRIVEN_REVERSAL_REPAIR_PROMPT },
+                { role: "user", content: payload }
+            ],
+            temperature: 0
+        };
+    }
+    buildEvidenceDrivenReversalRescueBody(endpoint, input, reason, reversal) {
+        const payload = JSON.stringify({
+            task_summary: input.task_summary,
+            task_type: input.task_type,
+            context_summary: input.context_summary,
+            outcome_signal: input.outcome_signal,
+            tool_events: input.tool_events.map((event) => ({
+                tool_name: event.tool_name,
+                status: event.status,
+                error_signature: event.error_signature,
+                output_summary: event.output_summary
+            })),
+            reversal_window: {
+                selected: reversal.detected,
+                hypothesis_snippets: reversal.hypothesis_snippets,
+                invalidating_snippets: reversal.invalidating_snippets,
+                pivot_snippets: reversal.pivot_snippets,
+                replacement_snippets: reversal.replacement_snippets,
+                validating_snippets: reversal.validating_snippets
+            },
+            evidence_gate: {
+                prior_hypothesis: reversal.prior_hypothesis,
+                invalidating_evidence: reversal.invalidating_evidence,
+                validating_evidence: reversal.validating_evidence
+            },
+            original_reason: reason
+        }, null, 2);
+        if (endpoint.kind === "anthropic") {
+            return {
+                model: endpoint.model,
+                max_tokens: 768,
+                system: EVIDENCE_DRIVEN_REVERSAL_RESCUE_PROMPT,
+                messages: [{ role: "user", content: payload }],
+                temperature: 0
+            };
+        }
+        if (endpoint.kind === "gemini") {
+            return {
+                system_instruction: {
+                    parts: [{ text: EVIDENCE_DRIVEN_REVERSAL_RESCUE_PROMPT }]
+                },
+                contents: [
+                    {
+                        role: "user",
+                        parts: [{ text: payload }]
+                    }
+                ],
+                generationConfig: {
+                    temperature: 0,
+                    responseMimeType: "application/json"
+                }
+            };
+        }
+        if (endpoint.kind === "bedrock") {
+            return {
+                system: [{ text: EVIDENCE_DRIVEN_REVERSAL_RESCUE_PROMPT }],
+                messages: [
+                    {
+                        role: "user",
+                        content: [{ text: payload }]
+                    }
+                ],
+                inferenceConfig: {
+                    maxTokens: 768,
+                    temperature: 0
+                }
+            };
+        }
+        return {
+            model: endpoint.model,
+            response_format: { type: "json_object" },
+            messages: [
+                { role: "system", content: EVIDENCE_DRIVEN_REVERSAL_RESCUE_PROMPT },
+                { role: "user", content: payload }
+            ],
+            temperature: 0
+        };
+    }
     parseExpectationCorrectionRepair(content) {
         const parsed = JSON.parse(content);
         if (parsed.expectation_correction !== true) {
@@ -424,7 +809,112 @@ export class LlmLearningGate {
             corrected_constraint: correctedConstraint
         };
     }
-    async maybeRepairExpectationCorrection(endpoint, input, reason, draft) {
+    parseExpectationCorrectionRescue(content, input, directionalCorrection) {
+        const parsed = JSON.parse(content);
+        if (parsed.expectation_correction !== true) {
+            return undefined;
+        }
+        const rawCandidate = parsed.candidate && typeof parsed.candidate === "object"
+            ? parsed.candidate
+            : undefined;
+        if (!rawCandidate) {
+            return undefined;
+        }
+        const draft = normalizeDraft(rawCandidate, input);
+        if (draft.experience_kind !== "expectation_correction" ||
+            !draft.correction_category ||
+            !draft.deviation_pattern ||
+            !draft.corrected_constraint) {
+            return undefined;
+        }
+        return {
+            draft,
+            directionalCorrectionSignal: {
+                ...directionalCorrection,
+                semantic_detected: true,
+                correction_category: draft.correction_category,
+                deviation_pattern: draft.deviation_pattern,
+                corrected_constraint: draft.corrected_constraint
+            }
+        };
+    }
+    parseEvidenceDrivenReversalRepair(content) {
+        const parsed = JSON.parse(content);
+        if (parsed.reversal_detected !== true) {
+            return undefined;
+        }
+        const reversalSource = parsed.reversal_source === "task_evidence" ? "task_evidence" : undefined;
+        const supersededHypothesis = pickString(parsed.superseded_hypothesis);
+        const replacementConstraint = pickString(parsed.replacement_constraint);
+        const verificationEvidence = pickString(parsed.verification_evidence);
+        const pivotSummary = pickString(parsed.pivot_summary);
+        const correctionScope = isCorrectionScope(parsed.correction_scope) ? parsed.correction_scope : undefined;
+        const correctionCategory = isCorrectionCategory(parsed.correction_category) ? parsed.correction_category : undefined;
+        const deviationPattern = pickString(parsed.deviation_pattern);
+        const correctedConstraint = pickString(parsed.corrected_constraint);
+        if (!reversalSource ||
+            !supersededHypothesis ||
+            !replacementConstraint ||
+            !verificationEvidence ||
+            !correctionScope ||
+            !correctionCategory ||
+            !deviationPattern ||
+            !correctedConstraint) {
+            return undefined;
+        }
+        return {
+            reversal_detected: true,
+            reversal_source: reversalSource,
+            superseded_hypothesis: supersededHypothesis,
+            replacement_constraint: replacementConstraint,
+            verification_evidence: verificationEvidence,
+            pivot_summary: pivotSummary,
+            correction_scope: correctionScope,
+            correction_category: correctionCategory,
+            deviation_pattern: deviationPattern,
+            corrected_constraint: correctedConstraint
+        };
+    }
+    parseEvidenceDrivenReversalRescue(content, input, reversal) {
+        const parsed = JSON.parse(content);
+        if (parsed.reversal_detected !== true) {
+            return undefined;
+        }
+        const reversalSource = parsed.reversal_source === "task_evidence" ? "task_evidence" : undefined;
+        const supersededHypothesis = pickString(parsed.superseded_hypothesis);
+        const replacementConstraint = pickString(parsed.replacement_constraint);
+        const verificationEvidence = pickString(parsed.verification_evidence);
+        const pivotSummary = pickString(parsed.pivot_summary);
+        const rawCandidate = parsed.candidate && typeof parsed.candidate === "object"
+            ? parsed.candidate
+            : undefined;
+        if (!rawCandidate || !reversalSource || !supersededHypothesis || !replacementConstraint || !verificationEvidence) {
+            return undefined;
+        }
+        const draft = normalizeDraft(rawCandidate, input);
+        if (draft.experience_kind !== "expectation_correction" ||
+            !draft.correction_category ||
+            !draft.deviation_pattern ||
+            !draft.corrected_constraint) {
+            return undefined;
+        }
+        return {
+            draft,
+            evidenceDrivenReversalSignal: {
+                ...reversal,
+                semantic_detected: true,
+                reversal_source: reversalSource,
+                superseded_hypothesis: supersededHypothesis,
+                replacement_constraint: replacementConstraint,
+                verification_evidence: verificationEvidence,
+                pivot_summary: pivotSummary,
+                correction_category: draft.correction_category,
+                deviation_pattern: draft.deviation_pattern,
+                corrected_constraint: draft.corrected_constraint
+            }
+        };
+    }
+    async maybeRepairExpectationCorrection(endpoint, input, reason, draft, directionalCorrection) {
         const hasCompleteExpectationCorrectionShape = draft.experience_kind === "expectation_correction" &&
             Boolean(draft.confidence_signal &&
                 draft.validation_state &&
@@ -433,25 +923,156 @@ export class LlmLearningGate {
                 draft.deviation_pattern &&
                 draft.corrected_constraint);
         if (input.outcome_signal !== "success" || hasCompleteExpectationCorrectionShape) {
-            return draft;
+            return {
+                draft,
+                directionalCorrectionSignal: directionalCorrection?.detected ? directionalCorrection : undefined
+            };
+        }
+        if (!directionalCorrection?.detected ||
+            (!directionalCorrection.objective_support && !directionalCorrection.user_confirmation)) {
+            return {
+                draft,
+                directionalCorrectionSignal: directionalCorrection?.detected ? directionalCorrection : undefined
+            };
         }
         try {
-            const response = await this.postJsonWithRetry(this.buildRequestUrl(endpoint), endpoint, this.buildExpectationCorrectionRepairBody(endpoint, input, draft, reason));
+            const response = await this.postJsonWithRetry(this.buildRequestUrl(endpoint), endpoint, this.buildExpectationCorrectionRepairBody(endpoint, input, draft, reason, directionalCorrection));
             if (!response.ok) {
-                return draft;
+                return {
+                    draft,
+                    directionalCorrectionSignal: directionalCorrection
+                };
             }
             const content = await this.parseResponseContent(endpoint, response);
             const repair = this.parseExpectationCorrectionRepair(content);
             if (!repair) {
-                return draft;
+                return {
+                    draft,
+                    directionalCorrectionSignal: directionalCorrection
+                };
             }
-            return normalizeCandidate({
-                ...draft,
-                ...repair
-            });
+            return {
+                draft: normalizeCandidate({
+                    ...draft,
+                    ...repair
+                }),
+                directionalCorrectionSignal: {
+                    ...directionalCorrection,
+                    semantic_detected: true,
+                    correction_category: repair.correction_category,
+                    deviation_pattern: repair.deviation_pattern,
+                    corrected_constraint: repair.corrected_constraint
+                }
+            };
         }
         catch {
-            return draft;
+            return {
+                draft,
+                directionalCorrectionSignal: directionalCorrection
+            };
+        }
+    }
+    async maybeRepairEvidenceDrivenReversal(endpoint, input, reason, draft, directionalCorrection, reversal) {
+        if (input.outcome_signal !== "success" ||
+            (directionalCorrection?.correction_source &&
+                directionalCorrection.correction_source !== "task_evidence" &&
+                directionalCorrection.detected) ||
+            !reversal?.detected ||
+            !reversal.prior_hypothesis ||
+            !reversal.invalidating_evidence ||
+            !reversal.validating_evidence) {
+            return {
+                draft,
+                evidenceDrivenReversalSignal: reversal?.detected ? reversal : undefined
+            };
+        }
+        try {
+            const response = await this.postJsonWithRetry(this.buildRequestUrl(endpoint), endpoint, this.buildEvidenceDrivenReversalRepairBody(endpoint, input, draft, reason, reversal));
+            if (!response.ok) {
+                return {
+                    draft,
+                    evidenceDrivenReversalSignal: reversal
+                };
+            }
+            const content = await this.parseResponseContent(endpoint, response);
+            const repair = this.parseEvidenceDrivenReversalRepair(content);
+            if (!repair) {
+                return {
+                    draft,
+                    evidenceDrivenReversalSignal: reversal
+                };
+            }
+            return {
+                draft: normalizeCandidate({
+                    ...draft,
+                    experience_kind: "expectation_correction",
+                    confidence_signal: draft.confidence_signal ?? "supported_by_objective_success",
+                    validation_state: draft.validation_state ?? "pending_reuse_validation",
+                    correction_scope: repair.correction_scope,
+                    correction_category: repair.correction_category,
+                    deviation_pattern: repair.deviation_pattern,
+                    corrected_constraint: repair.corrected_constraint
+                }),
+                evidenceDrivenReversalSignal: {
+                    ...reversal,
+                    semantic_detected: true,
+                    reversal_source: repair.reversal_source,
+                    superseded_hypothesis: repair.superseded_hypothesis,
+                    replacement_constraint: repair.replacement_constraint,
+                    verification_evidence: repair.verification_evidence,
+                    pivot_summary: repair.pivot_summary,
+                    correction_category: repair.correction_category,
+                    deviation_pattern: repair.deviation_pattern,
+                    corrected_constraint: repair.corrected_constraint
+                }
+            };
+        }
+        catch {
+            return {
+                draft,
+                evidenceDrivenReversalSignal: reversal
+            };
+        }
+    }
+    async maybeRescueExpectationCorrection(endpoint, input, reason, directionalCorrection) {
+        if (input.outcome_signal !== "success" ||
+            !directionalCorrection?.detected ||
+            (!directionalCorrection.objective_support && !directionalCorrection.user_confirmation)) {
+            return undefined;
+        }
+        try {
+            const response = await this.postJsonWithRetry(this.buildRequestUrl(endpoint), endpoint, this.buildExpectationCorrectionRescueBody(endpoint, input, reason, directionalCorrection));
+            if (!response.ok) {
+                return undefined;
+            }
+            const content = await this.parseResponseContent(endpoint, response);
+            return this.parseExpectationCorrectionRescue(content, input, directionalCorrection);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async maybeRescueEvidenceDrivenReversal(endpoint, input, reason, directionalCorrection, reversal) {
+        if (input.outcome_signal !== "success" ||
+            (directionalCorrection?.correction_source &&
+                directionalCorrection.correction_source !== "task_evidence" &&
+                directionalCorrection.detected) ||
+            !reversal?.detected ||
+            !reversal.prior_hypothesis ||
+            !reversal.invalidating_evidence ||
+            !reversal.validating_evidence) {
+            return undefined;
+        }
+        try {
+            const response = await this.postJsonWithRetry(this.buildRequestUrl(endpoint), endpoint, this.buildEvidenceDrivenReversalRescueBody(endpoint, input, reason, reversal));
+            if (!response.ok) {
+                return undefined;
+            }
+            const content = await this.parseResponseContent(endpoint, response);
+            return this.parseEvidenceDrivenReversalRescue(content, input, reversal);
+        }
+        catch {
+            return undefined;
         }
     }
     async parseResponseContent(endpoint, response) {
@@ -571,6 +1192,15 @@ export class LlmLearningGate {
                 source: "disabled"
             };
         }
+        const ineligibleReason = resolveEligibilityRejectionReason(input);
+        if (ineligibleReason) {
+            return {
+                worthCapturing: false,
+                reason: ineligibleReason,
+                drafts: [],
+                source: "disabled"
+            };
+        }
         const resolution = this.resolveDistillation();
         if (this.config.distillationMode === "disabled" || resolution.distillationMode === "disabled") {
             return {
@@ -585,7 +1215,7 @@ export class LlmLearningGate {
             return {
                 worthCapturing: fallback.accepted.length > 0,
                 reason: fallback.accepted.length > 0 ? "captured by rule fallback" : "rule fallback rejected candidate",
-                drafts: fallback.accepted,
+                drafts: fallback.accepted.map((draft) => applyTaskManagementPromotionPolicy(input, draft)),
                 source: "rule"
             };
         }
@@ -598,7 +1228,30 @@ export class LlmLearningGate {
             const parsed = JSON.parse(content);
             const worthCapturing = parsed.worth_capturing === true;
             const reason = pickString(parsed.reason) ?? "no reason provided";
+            const candidateSignals = buildCandidateSignals(input);
+            const directionalCorrection = candidateSignals.directional_correction;
+            const evidenceDrivenReversal = candidateSignals.evidence_driven_reversal;
             if (!worthCapturing) {
+                const rescued = await this.maybeRescueExpectationCorrection(resolution.endpoint, input, reason, directionalCorrection);
+                if (rescued) {
+                    return {
+                        worthCapturing: true,
+                        reason: `rescued directional correction: ${reason}`,
+                        drafts: dedupeCandidates([applyTaskManagementPromotionPolicy(input, rescued.draft)]),
+                        source: "llm",
+                        directionalCorrectionSignal: rescued.directionalCorrectionSignal
+                    };
+                }
+                const rescuedReversal = await this.maybeRescueEvidenceDrivenReversal(resolution.endpoint, input, reason, directionalCorrection, evidenceDrivenReversal);
+                if (rescuedReversal) {
+                    return {
+                        worthCapturing: true,
+                        reason: `rescued evidence-driven reversal: ${reason}`,
+                        drafts: dedupeCandidates([applyTaskManagementPromotionPolicy(input, rescuedReversal.draft)]),
+                        source: "llm",
+                        evidenceDrivenReversalSignal: rescuedReversal.evidenceDrivenReversalSignal
+                    };
+                }
                 return {
                     worthCapturing: false,
                     reason,
@@ -612,12 +1265,15 @@ export class LlmLearningGate {
             if (!rawCandidate) {
                 throw new Error("Learning gate marked worth_capturing=true without a candidate payload");
             }
-            const draft = await this.maybeRepairExpectationCorrection(resolution.endpoint, input, reason, normalizeDraft(rawCandidate, input));
+            const repaired = await this.maybeRepairExpectationCorrection(resolution.endpoint, input, reason, normalizeDraft(rawCandidate, input), directionalCorrection);
+            const reversalRepaired = await this.maybeRepairEvidenceDrivenReversal(resolution.endpoint, input, reason, repaired.draft, directionalCorrection, evidenceDrivenReversal);
             return {
                 worthCapturing: true,
                 reason,
-                drafts: dedupeCandidates([draft]),
-                source: "llm"
+                drafts: dedupeCandidates([applyTaskManagementPromotionPolicy(input, reversalRepaired.draft)]),
+                source: "llm",
+                directionalCorrectionSignal: repaired.directionalCorrectionSignal,
+                evidenceDrivenReversalSignal: reversalRepaired.evidenceDrivenReversalSignal
             };
         }
         catch (error) {
@@ -625,7 +1281,7 @@ export class LlmLearningGate {
             return {
                 worthCapturing: fallback.accepted.length > 0,
                 reason: `llm gate failed: ${error instanceof Error ? error.message : String(error)}`,
-                drafts: fallback.accepted,
+                drafts: fallback.accepted.map((draft) => applyTaskManagementPromotionPolicy(input, draft)),
                 source: "rule"
             };
         }