@alan512/experienceengine 0.1.3 → 0.2.0

package/dist/runtime/service.js

@@ -1,4 +1,3 @@
-import { LlmLearningGate } from "../analyzer/llm-learning-gate.js";
 import { buildCandidateSignals } from "../analyzer/candidate-signals.js";
 import { buildInjectionScorecard } from "../controller/injection-scorecard.js";
 import { classifyFailureAttributionReason } from "../feedback/automatic-attribution.js";
@@ -6,13 +5,16 @@ import { applyFeedback } from "../feedback/feedback-manager.js";
 import { detectHarm } from "../feedback/harm-detector.js";
 import { createEmptyStats, updateStats } from "../feedback/stats-updater.js";
 import { buildExperienceInput } from "../input/input-adapter.js";
+import { buildRetrievalContext } from "../controller/retrieval-context.js";
 import { resolveScope } from "../input/scope-resolver.js";
 import { decideIntervention } from "../controller/intervention-controller.js";
 import { renderInlineNotice } from "../controller/inline-notice.js";
+import { applyGovernedNodeFeedback, deriveNodeOriginProfileForNode } from "../experience-management/node-lifecycle-governance.js";
+import { resolveHybridRolloutState } from "../hybrid/rollout.js";
+import { selectHybridRoute } from "../hybrid/router.js";
 import { nowIso } from "../utils/clock.js";
 import { createId, stableId } from "../utils/ids.js";
 import { bootstrapDatabase, openDatabase, withTransaction } from "../store/sqlite/db.js";
-import { DistillationQueueWorker } from "../distillation/queue-worker.js";
 import { CandidateRepository } from "../store/sqlite/repositories/candidate-repo.js";
 import { DistillationJobRepository } from "../store/sqlite/repositories/distillation-job-repo.js";
 import { InputRecordRepository } from "../store/sqlite/repositories/input-record-repo.js";
@@ -23,9 +25,16 @@ import { ScopeRepository } from "../store/sqlite/repositories/scope-repo.js";
 import { StatsRepository } from "../store/sqlite/repositories/stats-repo.js";
 import { TaskRunRepository } from "../store/sqlite/repositories/task-run-repo.js";
 import { InjectionRepository } from "../store/sqlite/repositories/injection-repo.js";
+import { HybridInvocationTraceRepository } from "../store/sqlite/repositories/hybrid-invocation-trace-repo.js";
 import { RuntimeCaptureWriter } from "../plugin/runtime-capture.js";
 import { normalizeToolResult } from "../plugin/hooks/tool-result-persist.js";
 import { extractToolResultsFromPayload } from "../plugin/runtime-helpers.js";
+import { HybridReviewArtifactRepository } from "../store/sqlite/repositories/hybrid-review-artifact-repo.js";
+const loadLlmLearningGate = async () => import("../analyzer/llm-learning-gate.js");
+const loadDistillationQueueWorker = async () => import("../distillation/queue-worker.js");
+const loadHybridWorkerClientModule = async () => import("../hybrid/worker-client.js");
+const loadHybridCapsuleBuilder = async () => import("../hybrid/capsule-builder.js");
+const loadHybridPostmortemProviderClient = async () => import("../hybrid/postmortem-provider-client.js");
 const toEvidence = (input) => input.tool_events.map((event) => [event.tool_name, event.status, event.error_signature ?? event.output_summary]
     .filter(Boolean)
     .join(": "));
@@ -82,9 +91,57 @@ const buildCandidateSourceSignal = (input) => {
         failure_signature: signals.failure_signature,
         retry_count: signals.retry_count,
         correction_signals: signals.correction_signals,
+        directional_correction: signals.directional_correction,
+        evidence_driven_reversal: signals.evidence_driven_reversal,
         tool_event_summary: signals.tool_event_summary
     };
 };
+const mergeDirectionalCorrectionIntoSourceSignal = (sourceSignal, draft) => {
+    const directionalCorrection = sourceSignal.directional_correction;
+    if (!directionalCorrection) {
+        return sourceSignal;
+    }
+    const semanticDetected = Boolean(draft.experience_kind === "expectation_correction" &&
+        draft.correction_category &&
+        draft.deviation_pattern &&
+        draft.corrected_constraint);
+    if (!semanticDetected) {
+        return sourceSignal;
+    }
+    return {
+        ...sourceSignal,
+        directional_correction: {
+            ...directionalCorrection,
+            semantic_detected: true,
+            correction_category: draft.correction_category,
+            deviation_pattern: draft.deviation_pattern,
+            corrected_constraint: draft.corrected_constraint
+        }
+    };
+};
+const mergeEvidenceDrivenReversalIntoSourceSignal = (sourceSignal, draft) => {
+    const reversal = sourceSignal.evidence_driven_reversal;
+    if (!reversal) {
+        return sourceSignal;
+    }
+    const semanticDetected = Boolean(draft.experience_kind === "expectation_correction" &&
+        draft.correction_category &&
+        draft.deviation_pattern &&
+        draft.corrected_constraint);
+    if (!semanticDetected) {
+        return sourceSignal;
+    }
+    return {
+        ...sourceSignal,
+        evidence_driven_reversal: {
+            ...reversal,
+            semantic_detected: true,
+            correction_category: draft.correction_category,
+            deviation_pattern: draft.deviation_pattern,
+            corrected_constraint: draft.corrected_constraint
+        }
+    };
+};
 const summarizeRawCandidate = (sourceSignal) => {
     const fragments = [...sourceSignal.tool_event_summary];
     if (sourceSignal.failure_signature) {
@@ -104,9 +161,14 @@ const resolveCandidateKind = (input, sourceSignal) => {
     }
     return "failure";
 };
-const draftToCandidate = (draft, input, originRecordId, taskRunId) => {
+const draftToCandidate = (draft, input, originRecordId, taskRunId, directionalCorrectionSignal, evidenceDrivenReversalSignal) => {
     const timestamp = nowIso();
-    const sourceSignal = buildCandidateSourceSignal(input);
+    const baseSourceSignal = buildCandidateSourceSignal(input);
+    const sourceSignal = mergeEvidenceDrivenReversalIntoSourceSignal(mergeDirectionalCorrectionIntoSourceSignal({
+        ...baseSourceSignal,
+        directional_correction: directionalCorrectionSignal ?? baseSourceSignal.directional_correction,
+        evidence_driven_reversal: evidenceDrivenReversalSignal ?? baseSourceSignal.evidence_driven_reversal
+    }, draft), draft);
     const candidateId = stableId("candidate", [draft.scope_id, draft.task_type, draft.node_type, draft.compact_hint, originRecordId].join(":"));
     return {
         id: candidateId,
@@ -138,6 +200,7 @@ const candidateToInitialJob = (candidate, extractorProfile) => {
     };
 };
 const mergeContext = (existing, incoming) => ({
+    host: incoming.host ?? existing?.host,
     sessionId: incoming.sessionId ?? existing?.sessionId,
     cwd: incoming.cwd ?? existing?.cwd,
     userMessage: incoming.userMessage || existing?.userMessage || "",
@@ -186,6 +249,23 @@ const resolveDeliveryMode = (evaluationMode, holdoutRate, sessionId, taskSummary
         delivered: true
     };
 };
+const HYBRID_LIGHTWEIGHT_PATTERN = /\b(wording-only|wording only|copy-only|copy only|copy pass|inline notice wording|expression-layer refinement)\b/i;
+const isLightweightHybridExcludedTask = (input) => HYBRID_LIGHTWEIGHT_PATTERN.test(`${input.task_summary} ${input.context_summary ?? ""}`);
+export const decidePosttaskHybridRoute = (config, input, signals, rolloutKey = input.task_summary) => {
+    const rollout = resolveHybridRolloutState(config, rolloutKey);
+    return selectHybridRoute({
+        ...signals,
+        explicitExplanationRequest: false,
+        existingConservativePathRequired: false,
+        lightweightOrExcludedTask: signals.lightweightOrExcludedTask || isLightweightHybridExcludedTask(input),
+        rolloutAllowsAsyncPostmortem: config.hybridAsyncPostmortemEnabled && rollout.hybridActive
+    }, {
+        enabled: config.hybridEnabled && rollout.hybridActive,
+        syncExplainEnabled: false,
+        asyncPostmortemEnabled: config.hybridAsyncPostmortemEnabled && rollout.hybridActive,
+        policyVersion: config.hybridRoutePolicyVersion
+    });
+};
 export class ExperienceRuntimeService {
     config;
     db;
@@ -202,12 +282,21 @@ export class ExperienceRuntimeService {
     reviewEventRepo;
     statsRepo;
     injectionRepo;
-    distillationWorker;
-    learningGate;
+    hybridReviewArtifactRepo;
+    hybridTraceRepo;
+    runtimeOptions;
+    backgroundLearningEnabled;
+    hybridPosttaskEnabled;
+    distillationWorkerPromise;
+    learningGatePromise;
+    hybridWorkerClientPromise;
     pendingLearningTasks = new Set();
     captureWriter;
     constructor(config, logger, runtimeOptions = {}) {
         this.config = config;
+        this.runtimeOptions = runtimeOptions;
+        this.backgroundLearningEnabled = !runtimeOptions.disableBackgroundLearning;
+        this.hybridPosttaskEnabled = !runtimeOptions.disableHybridPosttask;
         this.logger = logger ?? {};
         this.db = openDatabase(config);
         bootstrapDatabase(this.db);
@@ -221,8 +310,8 @@ export class ExperienceRuntimeService {
         this.reviewEventRepo = new ReviewEventRepository(this.db);
         this.statsRepo = new StatsRepository(this.db);
         this.injectionRepo = new InjectionRepository(this.db);
-        this.distillationWorker = new DistillationQueueWorker(config, this.candidateRepo, this.jobRepo, this.nodeRepo, runtimeOptions);
-        this.learningGate = new LlmLearningGate(config, runtimeOptions);
+        this.hybridReviewArtifactRepo = new HybridReviewArtifactRepository(this.db);
+        this.hybridTraceRepo = new HybridInvocationTraceRepository(this.db);
         this.captureWriter = new RuntimeCaptureWriter(config, this.logger);
     }
     getSession(sessionId) {
@@ -247,8 +336,9 @@ export class ExperienceRuntimeService {
         session.toolEventKeys.add(key);
         session.toolEvents.push(toolEvent);
     }
-    resolveScopedNodes(scopeId) {
-        return this.nodeRepo.listInjectableByScope(scopeId);
+    // The shipped runtime path stays exact-scope-only in this rollout.
+    resolveExactScopeInjectableNodes(scopeId) {
+        return this.nodeRepo.listLiveInjectableByExactScope(scopeId);
     }
     recoverToolEvents(sessionId, payload) {
         for (const toolResult of extractToolResultsFromPayload(payload)) {
@@ -301,8 +391,245 @@ export class ExperienceRuntimeService {
     async waitForBackgroundLearning() {
         await Promise.allSettled([...this.pendingLearningTasks]);
     }
+    async getLearningGate() {
+        if (!this.backgroundLearningEnabled) {
+            return undefined;
+        }
+        this.learningGatePromise ??= loadLlmLearningGate().then(({ LlmLearningGate: LoadedLlmLearningGate }) => new LoadedLlmLearningGate(this.config, this.runtimeOptions));
+        return this.learningGatePromise;
+    }
+    async getDistillationWorker() {
+        if (!this.backgroundLearningEnabled) {
+            return undefined;
+        }
+        this.distillationWorkerPromise ??= loadDistillationQueueWorker().then(({ DistillationQueueWorker: LoadedDistillationQueueWorker }) => new LoadedDistillationQueueWorker(this.config, this.candidateRepo, this.jobRepo, this.nodeRepo, this.runtimeOptions));
+        return this.distillationWorkerPromise;
+    }
+    async getHybridWorkerClient() {
+        if (!this.hybridPosttaskEnabled) {
+            return undefined;
+        }
+        this.hybridWorkerClientPromise ??= loadHybridWorkerClientModule().then(({ HybridWorkerClient: LoadedHybridWorkerClient }) => new LoadedHybridWorkerClient({
+            explainDecisionEnabled: this.config.hybridEnabled && this.config.hybridSyncExplainEnabled,
+            postmortemReviewEnabled: this.config.hybridEnabled && this.config.hybridAsyncPostmortemEnabled,
+            postmortemReviewLlmEnabled: this.config.hybridEnabled
+                && this.config.hybridAsyncPostmortemEnabled
+                && this.config.hybridAsyncPostmortemLlmEnabled,
+            ...this.runtimeOptions.hybridWorkerClientOptions
+        }));
+        return this.hybridWorkerClientPromise;
+    }
+    buildPostmortemArtifact(input) {
+        const timestamp = nowIso();
+        return {
+            id: createId("hybridreview"),
+            task_run_id: input.taskRun.id,
+            scope_id: input.taskRun.scope_id,
+            worker_task: "postmortem_review",
+            approval_class: input.result.approvalClass === "policy_gated" ? "policy_gated" : "review_artifact",
+            schema_version: this.config.hybridCapsuleSchemaVersion,
+            route_policy_version: input.routeDecision.policyVersion,
+            worker_profile_version: this.config.hybridPostmortemReviewProfileVersion,
+            recommendation: input.result.value.candidate_recommendation,
+            summary: input.result.value.review_artifact?.summary ?? input.result.value.reason,
+            payload: input.result.value,
+            created_at: timestamp,
+            updated_at: timestamp
+        };
+    }
+    applyPostmortemDeliveryRecommendation(node, recommendation) {
+        if (recommendation === "keep" || recommendation === "review") {
+            return node;
+        }
+        if (recommendation === "quarantine") {
+            return {
+                ...node,
+                delivery_state: "quarantined",
+                quarantined_at: node.quarantined_at ?? nowIso(),
+                quarantine_reason: node.quarantine_reason ?? "postmortem_review"
+            };
+        }
+        if (node.delivery_state === "quarantined") {
+            return node;
+        }
+        return {
+            ...node,
+            delivery_state: node.delivery_state === "shadow_only" ? "shadow_only" : "conservative_only"
+        };
+    }
+    applyAcceptedPostmortemNodeReviews(input) {
+        const reviews = input.result.value.injected_node_reviews ?? [];
+        if (!reviews.length || input.taskRun.final_status === "cancelled") {
+            return false;
+        }
+        const allowedIds = new Set(input.experienceInput.injected_node_ids);
+        const existingEvents = this.reviewEventRepo.listByTaskRunId(input.taskRun.id);
+        let applied = false;
+        for (const review of reviews) {
+            if (!allowedIds.has(review.node_id) || review.confidence === "low") {
+                continue;
+            }
+            const current = this.nodeRepo.getById(review.node_id);
+            if (!current) {
+                continue;
+            }
+            const existingNodeEvents = existingEvents.filter((event) => event.node_id === review.node_id && event.source === "automatic");
+            const alreadyMarkedHelped = existingNodeEvents.some((event) => event.event_type === "mark_helped");
+            const alreadyMarkedHarmed = existingNodeEvents.some((event) => event.event_type === "mark_harmed");
+            let nextNode = current;
+            let feedbackEventType;
+            if (review.feedback_verdict === "helped" && !alreadyMarkedHelped) {
+                nextNode = applyGovernedNodeFeedback(nextNode, "helped", deriveNodeOriginProfileForNode(this.inputRepo, nextNode));
+                feedbackEventType = "mark_helped";
+            }
+            else if (review.feedback_verdict === "harmed" && !alreadyMarkedHarmed) {
+                nextNode = applyGovernedNodeFeedback(nextNode, "harmed", deriveNodeOriginProfileForNode(this.inputRepo, nextNode));
+                feedbackEventType = "mark_harmed";
+            }
+            const nodeAfterDelivery = this.applyPostmortemDeliveryRecommendation(nextNode, review.delivery_recommendation);
+            if (feedbackEventType
+                || nodeAfterDelivery.delivery_state !== current.delivery_state
+                || nodeAfterDelivery.state !== current.state
+                || nodeAfterDelivery.helped_count !== current.helped_count
+                || nodeAfterDelivery.harmed_count !== current.harmed_count
+                || nodeAfterDelivery.last_feedback_verdict !== current.last_feedback_verdict) {
+                this.nodeRepo.upsert(nodeAfterDelivery);
+                applied = true;
+            }
+            if (feedbackEventType) {
+                this.reviewEventRepo.upsert({
+                    id: createId("review"),
+                    node_id: review.node_id,
+                    task_run_id: input.taskRun.id,
+                    event_type: feedbackEventType,
+                    source: "automatic",
+                    created_at: nowIso()
+                });
+            }
+            if (current.delivery_state !== "quarantined" && nodeAfterDelivery.delivery_state === "quarantined") {
+                this.reviewEventRepo.upsert({
+                    id: createId("review"),
+                    node_id: review.node_id,
+                    task_run_id: input.taskRun.id,
+                    event_type: "quarantine",
+                    source: "automatic",
+                    created_at: nowIso()
+                });
+            }
+        }
+        return applied;
+    }
+    async persistHybridPostmortemArtifactAsync(input) {
+        if (!this.hybridPosttaskEnabled) {
+            return;
+        }
+        if (this.hybridReviewArtifactRepo.getByTaskRunId(input.taskRun.id)) {
+            return;
+        }
+        const hybridWorkerClient = await this.getHybridWorkerClient();
+        if (!hybridWorkerClient) {
+            return;
+        }
+        const candidateSignals = buildCandidateSignals(input.experienceInput);
+        const [{ buildPostmortemReviewCapsule }, { resolveHybridPostmortemProviderEndpoint }] = await Promise.all([
+            loadHybridCapsuleBuilder(),
+            loadHybridPostmortemProviderClient()
+        ]);
+        const capsule = buildPostmortemReviewCapsule({
+            schemaVersion: this.config.hybridCapsuleSchemaVersion,
+            routeDecision: input.routeDecision,
+            taskRun: input.taskRun,
+            outcomeSignal: input.experienceInput.outcome_signal,
+            triggers: {
+                directionalCorrectionPresent: candidateSignals.directional_correction?.detected === true
+                    || candidateSignals.evidence_driven_reversal?.detected === true,
+                injectedNodeInteractionPresent: input.experienceInput.injected_node_ids.length > 0,
+                retryOrInvalidationSignaturePresent: candidateSignals.retry_count > 0 || candidateSignals.evidence_driven_reversal?.invalidating_evidence === true,
+                meaningfulFailureSignaturePresent: Boolean(candidateSignals.failure_signature),
+                conservativeTransitionReviewWorthy: input.experienceInput.outcome_signal === "success" && input.experienceInput.injected_node_ids.length > 0
+            },
+            injectedNodes: input.experienceInput.injected_node_ids
+                .map((id) => this.nodeRepo.getById(id))
+                .filter((node) => Boolean(node)),
+            toolEvents: input.toolEvents
+        });
+        const providerResolution = this.config.hybridAsyncPostmortemLlmEnabled
+            ? resolveHybridPostmortemProviderEndpoint(this.config)
+            : { status: "disabled", reason: "Phase 3 provider-backed postmortem review is disabled." };
+        const result = this.config.hybridAsyncPostmortemLlmEnabled && providerResolution.status === "unavailable"
+            ? {
+                status: "fallback",
+                reason: "provider_unavailable"
+            }
+            : await hybridWorkerClient.runPostmortemReview(capsule, providerResolution.status === "configured"
+                ? {
+                    mode: "provider",
+                    endpoint: providerResolution.endpoint
+                }
+                : undefined);
+        const timestamp = nowIso();
+        const persistAcceptedArtifact = result.status === "accepted"
+            && input.rolloutMode !== "shadow"
+            && (result.approvalClass === "review_artifact" || result.approvalClass === "policy_gated");
+        const appliedNodeWriteback = result.status === "accepted" && input.rolloutMode !== "shadow"
+            ? this.applyAcceptedPostmortemNodeReviews({
+                taskRun: input.taskRun,
+                experienceInput: input.experienceInput,
+                result
+            })
+            : false;
+        this.hybridTraceRepo.upsert({
+            id: createId("hybridtrace"),
+            surface: "runtime",
+            session_id: input.taskRun.session_id,
+            scope_id: input.taskRun.scope_id,
+            worker_task: "postmortem_review",
+            route: input.routeDecision.route,
+            route_policy_version: input.routeDecision.policyVersion,
+            capsule_schema_version: this.config.hybridCapsuleSchemaVersion,
+            worker_profile_version: this.config.hybridAsyncPostmortemLlmEnabled
+                ? this.config.hybridPostmortemModelProfileVersion
+                : this.config.hybridPostmortemReviewProfileVersion,
+            rollout_mode: input.rolloutMode,
+            rollout_reason: input.rolloutReason,
+            worker_ran: result.status !== "fallback" || result.reason !== "provider_unavailable",
+            validation_status: result.status === "accepted" ? "accepted" : "fallback",
+            output_action: persistAcceptedArtifact || appliedNodeWriteback ? "stored" : "rejected",
+            fallback_reason: result.status === "accepted" ? undefined : result.reason,
+            created_at: timestamp
+        });
+        if (result.status !== "accepted") {
+            this.logger.debug?.("experienceengine.hybrid_postmortem_skipped", {
+                taskRunId: input.taskRun.id,
+                reason: result.reason
+            });
+            return;
+        }
+        if (persistAcceptedArtifact) {
+            this.hybridReviewArtifactRepo.upsert(this.buildPostmortemArtifact({
+                taskRun: input.taskRun,
+                result,
+                routeDecision: input.routeDecision
+            }));
+        }
+    }
     async persistCandidatesAsync(input, originRecordId, taskRunId, sessionId) {
-        const result = await this.learningGate.generateCandidateDrafts(input);
+        const learningGate = await this.getLearningGate();
+        if (!learningGate) {
+            if (taskRunId) {
+                const taskRun = this.taskRunRepo.getById(taskRunId);
+                if (taskRun) {
+                    this.taskRunRepo.upsert({
+                        ...taskRun,
+                        learning_status: "not_applicable",
+                        learning_reason: "background learning disabled",
+                        updated_at: nowIso()
+                    });
+                }
+            }
+            return;
+        }
+        const result = await learningGate.generateCandidateDrafts(input);
         if (taskRunId) {
             const taskRun = this.taskRunRepo.getById(taskRunId);
             if (taskRun) {
@@ -327,7 +654,7 @@ export class ExperienceRuntimeService {
             });
             return;
         }
-        const persistedCandidates = result.drafts.map((draft) => draftToCandidate(draft, input, originRecordId, taskRunId));
+        const persistedCandidates = result.drafts.map((draft) => draftToCandidate(draft, input, originRecordId, taskRunId, result.directionalCorrectionSignal, result.evidenceDrivenReversalSignal));
         withTransaction(this.db, () => {
             for (const candidate of persistedCandidates) {
                 this.candidateRepo.upsert(candidate);
@@ -342,7 +669,11 @@ export class ExperienceRuntimeService {
             reason: result.reason
         });
         if (this.config.distillationAutoDrain) {
-            await this.distillationWorker.drain().catch((error) => {
+            const distillationWorker = await this.getDistillationWorker();
+            if (!distillationWorker) {
+                return;
+            }
+            await distillationWorker.drain().catch((error) => {
                 this.logger.error?.("experienceengine.distillation_drain_failed", {
                     sessionId,
                     error: error instanceof Error ? error.message : String(error)
@@ -362,7 +693,7 @@ export class ExperienceRuntimeService {
             if (input.outcome_signal === "success") {
                 return {
                     nodeId: node.id,
-                    eventType: "mark_helped"
+                    eventType: "mark_uncertain"
                 };
             }
             if (detectHarm(input, node)) {
@@ -374,7 +705,10 @@ export class ExperienceRuntimeService {
             return undefined;
         })
             .filter((value) => Boolean(value));
-        for (const node of applyFeedback(input, touched, attributionRecordId)) {
+        const originProfilesByNodeId = Object.fromEntries(touched.map((node) => {
+            return [node.id, deriveNodeOriginProfileForNode(this.inputRepo, node)];
+        }));
+        for (const node of applyFeedback(input, touched, attributionRecordId, { originProfilesByNodeId })) {
             this.nodeRepo.upsert(node);
         }
         for (const event of automaticEvents) {
@@ -393,6 +727,7 @@ export class ExperienceRuntimeService {
         const session = this.getSession(sessionId);
         session.context = mergeContext(session.context, context);
         const input = buildExperienceInput(session.context, session.toolEvents);
+        const retrievalContext = buildRetrievalContext(input, session.context);
         const resolvedScope = resolveScope(session.context.cwd);
         const existingScope = this.scopeRepo.getById(resolvedScope.scope_id);
         if (existingScope?.is_disabled) {
@@ -410,6 +745,7 @@ export class ExperienceRuntimeService {
                 mode: "skip",
                 text: undefined,
                 notice: undefined,
+                retrievalContext,
                 input: {
                     ...input,
                     scope_id: existingScope.scope_id,
@@ -418,8 +754,8 @@ export class ExperienceRuntimeService {
             };
         }
         const stats = input.task_type !== "unknown" ? this.statsRepo.get(input.scope_id, input.task_type) : undefined;
-        const nodes = input.task_type !== "unknown" ? this.resolveScopedNodes(input.scope_id) : [];
-        const decision = await decideIntervention(input, nodes, stats, this.config.triggerThreshold, this.config.maxHints, this.config);
+        const nodes = input.task_type !== "unknown" ? this.resolveExactScopeInjectableNodes(input.scope_id) : [];
+        const decision = await decideIntervention(input, nodes, stats, this.config.triggerThreshold, this.config.maxHints, this.config, retrievalContext);
         const selectedNodeIds = decision.selected.map((node) => node.id);
         const delivery = resolveDeliveryMode(this.config.evaluationMode, this.config.holdoutRate, sessionId, input.task_summary, decision.mode !== "skip" && selectedNodeIds.length > 0);
         session.injectedNodeIds = delivery.delivered ? selectedNodeIds : [];
@@ -466,6 +802,7 @@ export class ExperienceRuntimeService {
             scorecard: decision.mode !== "skip" ? session.lastInjectionEvent?.scorecard : undefined,
             deliveryMode: decision.mode !== "skip" ? delivery.deliveryMode : undefined,
             delivered: decision.mode !== "skip" ? delivery.delivered : undefined,
+            retrievalContext,
             input: {
                 ...input,
                 injected_node_ids: session.injectedNodeIds
@@ -527,22 +864,71 @@ export class ExperienceRuntimeService {
                 input,
                 originRecordId: record.record_id,
                 taskRunId: taskRun.id,
-                sessionId
+                sessionId,
+                taskRun,
+                toolEvents: [...session.toolEvents]
             };
         });
         this.sessions.delete(sessionId);
-        if (learningTaskContext) {
-            this.trackLearningTask(this.persistCandidatesAsync(learningTaskContext.input, learningTaskContext.originRecordId, learningTaskContext.taskRunId, learningTaskContext.sessionId));
+        const rollout = resolveHybridRolloutState(this.config, `${sessionId}:${input.task_summary}`);
+        const hybridPosttaskRoute = decidePosttaskHybridRoute(this.config, input, {
+            taskStage: "posttask",
+            completedRun: true,
+            terminalOutcomeRecorded: true,
+            boundedPosttaskCapsuleAvailable: Boolean(input.task_summary),
+            postmortemAlreadyRecorded: learningTaskContext
+                ? Boolean(this.hybridReviewArtifactRepo.getByTaskRunId(learningTaskContext.taskRun.id))
+                : false,
+            lightweightOrExcludedTask: false,
+            directionalCorrectionPresent: Boolean(learningTaskContext
+                ? buildCandidateSignals(learningTaskContext.input).directional_correction?.detected
+                    || buildCandidateSignals(learningTaskContext.input).evidence_driven_reversal?.detected
+                : false),
+            injectedNodeInteractionPresent: input.injected_node_ids.length > 0,
+            retryOrInvalidationSignaturePresent: Boolean(learningTaskContext
+                ? buildCandidateSignals(learningTaskContext.input).retry_count > 0
+                    || buildCandidateSignals(learningTaskContext.input).evidence_driven_reversal?.invalidating_evidence
+                : false),
+            meaningfulFailureSignaturePresent: Boolean(learningTaskContext
+                ? buildCandidateSignals(learningTaskContext.input).failure_signature
+                : input.outcome_signal === "failure"),
+            conservativeTransitionReviewWorthy: false
+        }, `${sessionId}:${input.task_summary}`);
+        if (learningTaskContext && this.backgroundLearningEnabled) {
+            this.trackLearningTask((async () => {
+                await this.persistCandidatesAsync(learningTaskContext.input, learningTaskContext.originRecordId, learningTaskContext.taskRunId, learningTaskContext.sessionId);
+                if (hybridPosttaskRoute.route !== "ESCALATE_ASYNC_POSTMORTEM") {
+                    return;
+                }
+                const refreshedTaskRun = this.taskRunRepo.getById(learningTaskContext.taskRun.id) ?? learningTaskContext.taskRun;
+                await this.persistHybridPostmortemArtifactAsync({
+                    taskRun: refreshedTaskRun,
+                    experienceInput: learningTaskContext.input,
+                    routeDecision: hybridPosttaskRoute,
+                    toolEvents: learningTaskContext.toolEvents,
+                    rolloutMode: rollout.effectiveMode,
+                    rolloutReason: rollout.reason
+                });
+            })());
         }
         this.logger.info?.("experienceengine.finalize", {
             sessionId,
             taskType: input.task_type,
-            outcome: input.outcome_signal
+            outcome: input.outcome_signal,
+            hybridPosttaskRoute: hybridPosttaskRoute.route,
+            hybridPosttaskRouteReason: hybridPosttaskRoute.reasonCode,
+            hybridRoutePolicyVersion: hybridPosttaskRoute.policyVersion,
+            hybridRolloutMode: rollout.effectiveMode,
+            hybridRolloutReason: rollout.reason
         });
         return input;
     }
     async drainDistillationQueue(limit) {
-        return this.distillationWorker.drain(limit);
+        const distillationWorker = await this.getDistillationWorker();
+        if (!distillationWorker) {
+            return 0;
+        }
+        return distillationWorker.drain(limit);
     }
 }
 //# sourceMappingURL=service.js.map