@alan512/experienceengine 0.1.2 → 0.2.0

package/dist/interaction/service.js

@@ -1,12 +1,15 @@
-import { compilePack } from "../compiler/compiler.js";
-import { deployCompiledPack } from "../compiler/deployer.js";
-import { ExperiencePackRegistry } from "../packs/fs-registry.js";
 import { buildInjectionScorecard } from "../controller/injection-scorecard.js";
 import { buildBenchmarkSummary } from "../evaluation/benchmark-summary.js";
+import { buildExplainDecisionCapsule } from "../hybrid/capsule-builder.js";
+import { resolveHybridExplainProviderEndpoint } from "../hybrid/explain-provider-client.js";
+import { resolveHybridRolloutState } from "../hybrid/rollout.js";
+import { selectHybridRoute } from "../hybrid/router.js";
+import { HybridWorkerClient } from "../hybrid/worker-client.js";
 import { resolveScope } from "../input/scope-resolver.js";
 import { bootstrapDatabase, openDatabase } from "../store/sqlite/db.js";
 import { CandidateRepository } from "../store/sqlite/repositories/candidate-repo.js";
 import { DistillationJobRepository } from "../store/sqlite/repositories/distillation-job-repo.js";
+import { HybridInvocationTraceRepository } from "../store/sqlite/repositories/hybrid-invocation-trace-repo.js";
 import { InputRecordRepository } from "../store/sqlite/repositories/input-record-repo.js";
 import { InjectionRepository } from "../store/sqlite/repositories/injection-repo.js";
 import { NodeRepository } from "../store/sqlite/repositories/node-repo.js";
@@ -14,11 +17,78 @@ import { OutcomeRecordRepository } from "../store/sqlite/repositories/outcome-re
 import { ReviewEventRepository } from "../store/sqlite/repositories/review-event-repo.js";
 import { ScopeRepository } from "../store/sqlite/repositories/scope-repo.js";
 import { TaskRunRepository } from "../store/sqlite/repositories/task-run-repo.js";
-import { ExperiencePackRepository } from "../store/sqlite/repositories/pack-repo.js";
-import { transitionState, transitionValidationState } from "../feedback/state-transition.js";
+import { applyGovernedNodeFeedback, deriveNodeOriginProfileForNode } from "../experience-management/node-lifecycle-governance.js";
+import { deriveGovernanceSignals, isPotentialMisfire } from "../experience-management/governance-observability.js";
 import { nowIso } from "../utils/clock.js";
 import { createId } from "../utils/ids.js";
 import { buildRepoSummary } from "./repo-summary.js";
+const normalizeHybridExplainPrompt = (value) => value
+    .toLowerCase()
+    .replace(/\s+/g, " ")
+    .trim();
+export const isExplicitHybridExplanationRequest = (userMessage) => {
+    const message = normalizeHybridExplainPrompt(userMessage);
+    const mentionsEe = message.includes("experienceengine")
+        || message.includes("experience engine")
+        || /\bee\b/.test(message);
+    if (!mentionsEe) {
+        return false;
+    }
+    const hasExplainIntent = /\bwhy\b/.test(message)
+        || /\bexplain\b/.test(message)
+        || (/\bwhat\b/.test(message) && /\binject\b/.test(message))
+        || (/\bwhy\b/.test(message) && /\bmatch\b/.test(message))
+        || (/\bwhy\b/.test(message) && /\bskip\b/.test(message))
+        || (/\bwhy\b/.test(message) && /\bconservative\b/.test(message))
+        || message.includes("stayed quiet")
+        || message.includes("stay quiet");
+    return hasExplainIntent;
+};
+export const decideHybridExplainRoute = (userMessage) => selectHybridRoute({
+    taskStage: "prompt",
+    explicitExplanationRequest: isExplicitHybridExplanationRequest(userMessage),
+    existingConservativePathRequired: false,
+    completedRun: false,
+    terminalOutcomeRecorded: false,
+    boundedPosttaskCapsuleAvailable: false,
+    postmortemAlreadyRecorded: false,
+    lightweightOrExcludedTask: false,
+    directionalCorrectionPresent: false,
+    injectedNodeInteractionPresent: false,
+    retryOrInvalidationSignaturePresent: false,
+    meaningfulFailureSignaturePresent: false,
+    conservativeTransitionReviewWorthy: false,
+    rolloutAllowsAsyncPostmortem: false
+});
+export const deriveStructuredSilenceReason = (input) => {
+    const { inspection, readiness } = input;
+    const learningReason = inspection.learningReason?.toLowerCase() ?? "";
+    const hasEarlyRepoEvidence = readiness.rawRecords < 3 && readiness.taskRuns < 3 && readiness.candidates === 0 && readiness.nodes === 0;
+    if (inspection.learningStatus === "not_applicable") {
+        return "non_applicable_turn";
+    }
+    if (inspection.learningStatus === "rejected" && learningReason.includes("expression-layer refinement")) {
+        return "non_applicable_turn";
+    }
+    if (inspection.scorecard?.decisionReason === "ambiguous_same_family_candidate"
+        || inspection.scorecard?.decisionReason === "promising_candidate_quality"
+        || inspection.intervention === "shadow"
+        || inspection.intervention === "holdout") {
+        return "withheld_low_confidence";
+    }
+    if (hasEarlyRepoEvidence) {
+        return "warming_up";
+    }
+    if (inspection.learningStatus === "captured"
+        || learningReason.includes("llm gate failed")
+        || learningReason.includes("rule fallback rejected candidate")) {
+        return "unknown";
+    }
+    if (inspection.intervention === "skip" && (readiness.rawRecords > 0 || readiness.taskRuns > 0 || readiness.candidates > 0 || readiness.nodes > 0)) {
+        return "no_strong_match";
+    }
+    return "unknown";
+};
 const toReviewEvent = (nodeId, eventType, source, taskRunId) => ({
     id: createId("review"),
     node_id: nodeId,
@@ -27,6 +97,65 @@ const toReviewEvent = (nodeId, eventType, source, taskRunId) => ({
     source,
     created_at: nowIso()
 });
+const deriveNodeRisk = (node) => {
+    if (node.state === "candidate") {
+        return "high";
+    }
+    if (node.state === "priority_candidate") {
+        return "medium";
+    }
+    if (node.state === "cooling" || node.harmed_count > 0 || node.node_type === "warning") {
+        return node.harmed_count > node.helped_count ? "high" : "medium";
+    }
+    return "low";
+};
+const deriveQualityBand = (node) => {
+    if (node.state === "retired" || node.harmed_count > node.helped_count || deriveNodeRisk(node) === "high") {
+        return "risky";
+    }
+    if (node.state === "active" &&
+        node.validation_state === "validated_by_reuse" &&
+        node.harmed_count === 0) {
+        return "strong";
+    }
+    return "building";
+};
+const buildQualityDrivers = (node) => {
+    const drivers = [];
+    if (node.validation_state === "validated_by_reuse") {
+        drivers.push("This node has already been validated by successful reuse.");
+    }
+    if (node.helped_count > node.harmed_count) {
+        drivers.push("Helpful outcomes still outweigh harmful ones for this node.");
+    }
+    else if (node.harmed_count > node.helped_count) {
+        drivers.push("Harmful outcomes currently outweigh helpful ones for this node.");
+    }
+    if (node.state === "candidate" || node.state === "priority_candidate") {
+        drivers.push("This node is still early in its lifecycle and needs more runtime evidence.");
+    }
+    else if (node.state === "cooling") {
+        drivers.push("This node is in cooling state because recent runtime evidence weakened confidence.");
+    }
+    return drivers.slice(0, 3);
+};
+const deriveConfidence = (node) => {
+    if (node.validation_state === "validated_by_reuse" && node.state === "active" && node.harmed_count === 0) {
+        return "high";
+    }
+    if (node.state === "candidate" || node.harmed_count > node.helped_count) {
+        return "low";
+    }
+    return "medium";
+};
+const formatTaskFamily = (taskType) => taskType === "general" ? "general tasks" : `${taskType} tasks`;
+const buildApplicabilityProfile = (node) => ({
+    bestFit: `${formatTaskFamily(node.task_type)} in this repo scope`,
+    scopeValidity: node.applicability_notes ?? "Use within the same repo scope unless fresh evidence says otherwise.",
+    confidence: deriveConfidence(node),
+    risk: deriveNodeRisk(node),
+    avoidWhen: node.stop_condition ?? node.escalation_condition ?? node.avoid_steps?.[0]
+});
 const toNodeSummary = (node) => ({
     id: node.id,
     type: node.node_type,
@@ -36,13 +165,21 @@ const toNodeSummary = (node) => ({
     distillationMode: node.distillation_mode_used,
     distillationSource: node.distillation_source,
     redistilledFrom: node.redistilled_from,
+    promotionSignal: node.promotion_signal,
+    promotionReason: node.promotion_reason,
+    mergeDecision: node.merge_decision,
+    mergeReason: node.merge_reason,
+    priorityPromotionApplied: node.priority_promotion_applied,
     triggerPattern: node.trigger_pattern,
     evidenceSummary: node.evidence_summary,
     originRecordIds: node.origin_record_ids,
     helped: node.helped_count,
     harmed: node.harmed_count,
     lastUsedAt: node.last_used_at,
-    hint: node.compact_hint
+    hint: node.compact_hint,
+    qualityBand: deriveQualityBand(node),
+    qualityDrivers: buildQualityDrivers(node),
+    applicabilityProfile: buildApplicabilityProfile(node)
 });
 const toNodeDetail = (node) => ({
     ...toNodeSummary(node),
@@ -57,23 +194,6 @@ const toNodeDetail = (node) => ({
     helpedRecordIds: node.helped_record_ids,
     harmedRecordIds: node.harmed_record_ids
 });
-const applyNodeFeedback = (node, feedback) => {
-    const timestamp = nowIso();
-    const next = {
-        ...node,
-        helped_count: feedback === "helped" ? node.helped_count + 1 : node.helped_count,
-        harmed_count: feedback === "harmed" ? node.harmed_count + 1 : node.harmed_count,
-        validation_state: transitionValidationState(node, feedback),
-        last_helped_at: feedback === "helped" ? timestamp : node.last_helped_at,
-        last_harmed_at: feedback === "harmed" ? timestamp : node.last_harmed_at,
-        updated_at: timestamp
-    };
-    return {
-        ...next,
-        state: node.state === "retired" ? "retired" : transitionState(next)
-    };
-};
-const REPO_SUMMARY_TARGETS = ["codex", "agents", "claude", "github"];
 const summarizeAutomaticFeedback = (events) => {
     const automatic = events.filter((event) => event.source === "automatic");
     if (automatic.some((event) => event.event_type === "mark_harmed")) {
@@ -149,51 +269,100 @@ const buildLatestTimeline = (input) => {
     }
     return entries.sort((left, right) => left.createdAt.localeCompare(right.createdAt));
 };
-const toScopePackActivation = (pack, activation) => {
-    if (!pack) {
+const compareIsoDesc = (left, right) => {
+    if (!left && !right) {
+        return 0;
+    }
+    if (!left) {
+        return 1;
+    }
+    if (!right) {
+        return -1;
+    }
+    return right.localeCompare(left);
+};
+const buildDecisionExplanation = (input) => {
+    const scorecard = input.scorecard;
+    if (!scorecard) {
         return undefined;
     }
-    return {
-        scopeId: activation.scope_id,
-        packId: activation.pack_id,
-        status: pack.status,
-        currentVersion: pack.current_version,
-        pinnedVersion: activation.pinned_version,
-        enabled: activation.enabled,
-        updatedAt: activation.updated_at
-    };
+    if (scorecard.mode === "inject_conservative") {
+        if (scorecard.decisionReason === "ambiguous_same_family_candidate") {
+            return "ExperienceEngine found a promising same-family match and chose conservative injection instead of skipping.";
+        }
+        if (scorecard.decisionReason === "promising_candidate_quality") {
+            return "ExperienceEngine found a credible candidate, but kept the injection conservative until it has stronger runtime proof.";
+        }
+        return "ExperienceEngine chose conservative injection because the best match still needs more runtime evidence.";
+    }
+    if (scorecard.decisionReason === "mature_validated_candidate") {
+        return "A mature validated candidate cleared the fast path, so ExperienceEngine injected it normally.";
+    }
+    if (scorecard.decisionReason === "candidate_quality_positive") {
+        return "Candidate quality was strong enough to justify intervention for this task.";
+    }
+    if (scorecard.mode === "inject") {
+        return "ExperienceEngine injected the best available reusable guidance for this task.";
+    }
+    if (input.intervention === "shadow") {
+        return "ExperienceEngine found a usable match, but delivery was suppressed because this run was in shadow mode.";
+    }
+    if (input.intervention === "holdout") {
+        return "ExperienceEngine found a usable match, but delivery was withheld for evaluation.";
+    }
+    return undefined;
 };
-const toCompiledArtifactWithPack = (packId, artifact) => ({
-    ...artifact,
-    packId
-});
-const summarizePackCompiler = (registry, packIds, versionByPackId) => {
-    const compiledArtifacts = packIds.flatMap((packId) => registry.listCompiledArtifacts(packId).map((artifact) => toCompiledArtifactWithPack(packId, artifact)));
-    const stalePublishedPacks = packIds.filter((packId) => {
-        const currentVersion = versionByPackId.get(packId);
-        return currentVersion ? registry.getCompileStatus(packId, currentVersion).stale : false;
-    }).length;
-    return {
-        publishedPacks: packIds.length,
-        compiledTargets: compiledArtifacts.length,
-        stalePublishedPacks,
-        latestCompiledArtifact: compiledArtifacts[0]
-    };
+const buildTrustSummary = (input) => {
+    const scorecard = input.scorecard;
+    const primaryNode = input.injectedNodes[0];
+    if (!scorecard || !primaryNode) {
+        return undefined;
+    }
+    const confidence = scorecard.confidence ? ` ${scorecard.confidence}-confidence` : "";
+    return `${scorecard.riskLevel}-risk${confidence} ${primaryNode.state} guidance with ${primaryNode.helped} helped and ${primaryNode.harmed} harmed signal(s).`;
+};
+const buildRetrievalNotes = (scorecard) => {
+    if (!scorecard) {
+        return [];
+    }
+    const notes = [];
+    if (scorecard.queryRewriteApplied) {
+        notes.push("Query rewrite preserved retrieval intent for this task.");
+    }
+    const rerankSource = scorecard.topCandidates?.[0]?.rerankSource;
+    if (rerankSource === "model") {
+        notes.push("Model reranking participated in the final ordering.");
+    }
+    if (scorecard.fastPathApplied) {
+        notes.push("A strong candidate fast path was used.");
+    }
+    const topCandidate = scorecard.topCandidates?.[0];
+    if (topCandidate?.retrievalReasons?.length) {
+        notes.push(`Top retrieval signals: ${topCandidate.retrievalReasons.slice(0, 2).join(", ")}.`);
+    }
+    if (topCandidate?.policyReasons?.length) {
+        notes.push(`Top policy signals: ${topCandidate.policyReasons.slice(0, 2).join(", ")}.`);
+    }
+    if (scorecard.rejectedCandidates?.length) {
+        notes.push(`Runner-up candidates withheld: ${scorecard.rejectedCandidates.map((candidate) => candidate.id).join(", ")}.`);
+    }
+    return notes;
 };
 export class ExperienceInteractionService {
+    config;
+    hybridWorkerClient;
     inputRepo;
     injectionRepo;
     nodeRepo;
     candidateRepo;
     jobRepo;
+    hybridTraceRepo;
     taskRunRepo;
     outcomeRepo;
     reviewEventRepo;
     scopeRepo;
-    packRepo;
-    packRegistry;
-    packsDir;
-    constructor(config, options = {}) {
+    constructor(config) {
+        this.config = config;
         const db = openDatabase(config);
         bootstrapDatabase(db);
         this.inputRepo = new InputRecordRepository(db);
@@ -201,16 +370,90 @@ export class ExperienceInteractionService {
         this.nodeRepo = new NodeRepository(db);
         this.candidateRepo = new CandidateRepository(db);
         this.jobRepo = new DistillationJobRepository(db);
+        this.hybridTraceRepo = new HybridInvocationTraceRepository(db);
         this.taskRunRepo = new TaskRunRepository(db);
         this.outcomeRepo = new OutcomeRecordRepository(db);
         this.reviewEventRepo = new ReviewEventRepository(db);
         this.scopeRepo = new ScopeRepository(db);
-        this.packRepo = new ExperiencePackRepository(db);
-        this.packsDir = options.packsDir ?? `${config.dataDir}/packs`;
-        this.packRegistry = new ExperiencePackRegistry({
-            packsDir: this.packsDir
+        this.hybridWorkerClient = new HybridWorkerClient({
+            explainDecisionEnabled: config.hybridEnabled && config.hybridSyncExplainEnabled,
+            explainDecisionLlmEnabled: config.hybridEnabled && config.hybridSyncExplainEnabled && config.hybridExplainLlmEnabled
         });
     }
+    deriveOriginProfile(node) {
+        return deriveNodeOriginProfileForNode(this.inputRepo, node);
+    }
+    decideExplainRoute(userMessage) {
+        return decideHybridExplainRoute(userMessage);
+    }
+    async explainLastDecision(cwd = process.cwd(), userMessage) {
+        const inspection = this.inspectLast(cwd);
+        if (!inspection) {
+            return "There is no recent ExperienceEngine intervention in this workspace yet.";
+        }
+        const fallback = inspection.decisionExplanation
+            ?? "ExperienceEngine used the current bounded decision path, but no deeper explanation is stored for the latest turn.";
+        if (!userMessage) {
+            return fallback;
+        }
+        const rollout = resolveHybridRolloutState(this.config, `${cwd}:${userMessage}`);
+        if (!rollout.hybridActive) {
+            return fallback;
+        }
+        const routeDecision = this.decideExplainRoute(userMessage);
+        if (routeDecision.route !== "ESCALATE_SYNC_EXPLAIN") {
+            return fallback;
+        }
+        const capsule = buildExplainDecisionCapsule({
+            schemaVersion: this.config.hybridCapsuleSchemaVersion,
+            routeDecision,
+            inspection
+        });
+        const providerResolution = this.config.hybridExplainLlmEnabled
+            ? resolveHybridExplainProviderEndpoint(this.config)
+            : { status: "disabled", reason: "Phase 2 provider-backed explain is disabled." };
+        const phase2ExplainRequested = this.config.hybridExplainLlmEnabled;
+        const useProvider = providerResolution.status === "configured";
+        const result = phase2ExplainRequested && providerResolution.status === "unavailable"
+            ? {
+                status: "fallback",
+                reason: "provider_unavailable"
+            }
+            : await this.hybridWorkerClient.runExplainDecision(capsule, useProvider
+                ? {
+                    mode: "provider",
+                    endpoint: providerResolution.endpoint
+                }
+                : undefined);
+        const timestamp = nowIso();
+        this.hybridTraceRepo.upsert({
+            id: createId("hybridtrace"),
+            surface: "interaction",
+            session_id: inspection.sessionId,
+            scope_id: inspection.scopeId,
+            worker_task: "explain_decision",
+            route: routeDecision.route,
+            route_policy_version: routeDecision.policyVersion,
+            capsule_schema_version: this.config.hybridCapsuleSchemaVersion,
+            worker_profile_version: phase2ExplainRequested
+                ? this.config.hybridExplainModelProfileVersion
+                : this.config.hybridExplainDecisionProfileVersion,
+            rollout_mode: rollout.effectiveMode,
+            rollout_reason: rollout.reason,
+            worker_ran: result.status !== "fallback" || result.reason !== "provider_unavailable",
+            validation_status: result.status === "accepted" ? "accepted" : "fallback",
+            output_action: result.status === "accepted" && rollout.userVisible ? "surfaced" : "none",
+            fallback_reason: result.status === "accepted" ? undefined : result.reason,
+            created_at: timestamp
+        });
+        if (!rollout.userVisible) {
+            return fallback;
+        }
+        if (result.status !== "accepted") {
+            return fallback;
+        }
+        return `${result.value.decision} ${result.value.reason}`.trim();
+    }
     inspectRecord(record) {
         if (!record) {
             return undefined;
@@ -248,22 +491,13 @@ export class ExperienceInteractionService {
                 : "inject";
         const outcomeRecord = taskRun?.id ? this.outcomeRepo.listByTaskRunId(taskRun.id)[0] : undefined;
         const latestAutomaticFeedback = reviewEvents.find((event) => event.source === "automatic");
-        const scopePackStatus = this.inspectScopePackStatusByScopeId(record.scope_id);
-        const matchedPackIds = new Set();
-        for (const activation of scopePackStatus.activations.filter((entry) => entry.enabled)) {
-            const version = activation.pinnedVersion ?? activation.currentVersion;
-            for (const membership of this.packRepo.listMemberships(activation.packId, version)) {
-                if (selectedNodeIds.includes(membership.node_id)) {
-                    matchedPackIds.add(activation.packId);
-                }
-            }
-        }
         const autoFeedbackReason = inferAutoFeedbackReason({
             explicitReason: injectionEvent?.attribution_reason,
             autoFeedback,
             intervention,
             outcome: record.outcome_signal
         });
+        const decisionExplanation = buildDecisionExplanation({ intervention, scorecard });
         return {
             sessionId: record.session_id,
             scopeId: record.scope_id,
@@ -278,6 +512,9 @@ export class ExperienceInteractionService {
             hints: injectedNodes.map((node) => node.compact_hint),
             evidence: record.evidence,
             scorecard,
+            decisionExplanation,
+            trustSummary: buildTrustSummary({ scorecard, injectedNodes: injectedNodes.map(toNodeSummary) }),
+            retrievalNotes: buildRetrievalNotes(scorecard),
             timeline: buildLatestTimeline({
                 record,
                 taskRunCreatedAt: taskRun?.created_at,
@@ -290,14 +527,110 @@ export class ExperienceInteractionService {
                 autoFeedback,
                 autoFeedbackCreatedAt: latestAutomaticFeedback?.created_at
             }),
-            activePacks: scopePackStatus.activations.filter((activation) => activation.enabled),
-            matchedPacks: scopePackStatus.activations.filter((activation) => matchedPackIds.has(activation.packId)),
+            learningStatus: taskRun?.learning_status,
+            learningReason: taskRun?.learning_reason,
             summary: record.task_summary,
             createdAt: record.created_at
         };
     }
-    inspectLast() {
-        return this.inspectRecord(this.inputRepo.getLatest());
+    inspectInjectionEvent(event) {
+        if (!event) {
+            return undefined;
+        }
+        const taskRun = event.session_id ? this.taskRunRepo.getLatestBySessionId(event.session_id) : undefined;
+        const latestRecord = event.session_id ? this.inputRepo.getLatestBySessionId(event.session_id) : undefined;
+        if (latestRecord) {
+            return this.inspectRecord(latestRecord);
+        }
+        const injectedNodes = this.nodeRepo.listByIds(event.injected_node_ids);
+        const reviewEvents = taskRun?.id ? this.reviewEventRepo.listByTaskRunId(taskRun.id) : [];
+        const autoFeedback = summarizeAutomaticFeedback(reviewEvents);
+        const latestAutomaticFeedback = reviewEvents.find((reviewEvent) => reviewEvent.source === "automatic");
+        const intervention = !event.delivered
+            ? event.delivery_mode === "holdout"
+                ? "holdout"
+                : "shadow"
+            : "inject";
+        const outcomeRecord = taskRun?.id ? this.outcomeRepo.listByTaskRunId(taskRun.id)[0] : undefined;
+        const outcome = outcomeRecord?.outcome_signal ??
+            (taskRun?.final_status === "success" ? "success" : taskRun?.final_status === "failure" ? "failure" : "unknown");
+        const summary = event.task_summary ?? taskRun?.task_summary ?? "Latest injection event";
+        const decisionExplanation = buildDecisionExplanation({ intervention, scorecard: event.scorecard });
+        return {
+            sessionId: event.session_id,
+            scopeId: event.scope_id,
+            taskType: event.task_type,
+            intervention,
+            deliveryMode: event.delivery_mode,
+            delivered: event.delivered,
+            autoFeedback,
+            autoFeedbackReason: inferAutoFeedbackReason({
+                explicitReason: event.attribution_reason,
+                autoFeedback,
+                intervention,
+                outcome
+            }),
+            outcome,
+            injectedNodes: injectedNodes.map(toNodeSummary),
+            hints: injectedNodes.map((node) => node.compact_hint),
+            evidence: [],
+            scorecard: event.scorecard,
+            decisionExplanation,
+            trustSummary: buildTrustSummary({ scorecard: event.scorecard, injectedNodes: injectedNodes.map(toNodeSummary) }),
+            retrievalNotes: buildRetrievalNotes(event.scorecard),
+            timeline: buildLatestTimeline({
+                record: {
+                    record_id: `injection:${event.injection_id}`,
+                    scope_id: event.scope_id,
+                    session_id: event.session_id,
+                    task_type: event.task_type,
+                    task_summary: summary,
+                    outcome_signal: outcome,
+                    context_summary: taskRun?.context_summary,
+                    evidence: [],
+                    injected_node_ids: event.injected_node_ids,
+                    created_at: event.created_at
+                },
+                taskRunCreatedAt: taskRun?.created_at,
+                outcomeCreatedAt: outcomeRecord?.created_at,
+                outcomeSummary: outcomeRecord?.summary,
+                injectionCreatedAt: event.created_at,
+                intervention,
+                delivered: event.delivered,
+                injectedCount: injectedNodes.length,
+                autoFeedback,
+                autoFeedbackCreatedAt: latestAutomaticFeedback?.created_at
+            }),
+            learningStatus: taskRun?.learning_status,
+            learningReason: taskRun?.learning_reason,
+            summary,
+            createdAt: event.created_at
+        };
+    }
+    inspectLast(cwd = process.cwd()) {
+        const scope = resolveScope(cwd);
+        const latestRecordInScope = this.inputRepo.getLatestByScope(scope.scope_id);
+        const latestInjectionInScope = this.injectionRepo.getLatestByScope(scope.scope_id);
+        const latestScopedInspection = compareIsoDesc(latestInjectionInScope?.created_at, latestRecordInScope?.created_at) < 0
+            ? this.inspectInjectionEvent(latestInjectionInScope)
+            : this.inspectRecord(latestRecordInScope);
+        if (latestScopedInspection) {
+            return latestScopedInspection;
+        }
+        const latestRecord = this.inputRepo.getLatest();
+        const latestInjection = this.injectionRepo.getLatest();
+        return compareIsoDesc(latestInjection?.created_at, latestRecord?.created_at) < 0
+            ? this.inspectInjectionEvent(latestInjection)
+            : this.inspectRecord(latestRecord);
+    }
+    inspectLatestInjected(cwd = process.cwd()) {
+        const scope = resolveScope(cwd);
+        const latestScopedInjected = this.inputRepo.getLatestInjectedByScope(scope.scope_id);
+        if (latestScopedInjected) {
+            return this.inspectRecord(latestScopedInjected);
+        }
+        const latestInjected = this.inputRepo.getLatestInjected();
+        return latestInjected ? this.inspectRecord(latestInjected) : undefined;
     }
     inspectRecent(options = {}) {
         return this.inputRepo.listRecent(options).map((record) => ({
@@ -319,149 +652,6 @@ export class ExperienceInteractionService {
         const node = this.nodeRepo.getById(nodeId);
         return node ? toNodeDetail(node) : undefined;
     }
-    listPacks() {
-        return this.packRepo.listPacks().map((pack) => ({
-            packId: pack.pack_id,
-            name: pack.name,
-            description: pack.description,
-            owner: pack.owner,
-            status: pack.status,
-            currentVersion: pack.current_version,
-            createdAt: pack.created_at,
-            updatedAt: pack.updated_at,
-            publishedAt: pack.published_at,
-            rolledBackAt: pack.rolled_back_at,
-            scopeHints: pack.scope_hints,
-            taskFamilies: pack.task_families,
-            hostCompatibility: pack.host_compatibility
-        }));
-    }
-    inspectPack(packId) {
-        const pack = this.packRepo.getPack(packId);
-        if (!pack) {
-            return undefined;
-        }
-        const manifest = this.packRegistry.readVersionManifest(packId, pack.current_version);
-        const nodes = this.packRegistry.readVersionNodes(packId, pack.current_version);
-        return {
-            packId: pack.pack_id,
-            name: pack.name,
-            description: pack.description,
-            owner: pack.owner,
-            status: pack.status,
-            currentVersion: pack.current_version,
-            createdAt: pack.created_at,
-            updatedAt: pack.updated_at,
-            publishedAt: pack.published_at,
-            rolledBackAt: pack.rolled_back_at,
-            scopeHints: pack.scope_hints,
-            taskFamilies: pack.task_families,
-            hostCompatibility: pack.host_compatibility,
-            manifest,
-            nodeIds: nodes.map((node) => node.id),
-            compiledArtifacts: this.packRegistry.listCompiledArtifacts(packId),
-            compileStatus: this.packRegistry.getCompileStatus(packId, pack.current_version),
-            activations: this.packRepo.listActivationsByPack(packId).map((activation) => ({
-                scopeId: activation.scope_id,
-                enabled: activation.enabled,
-                pinnedVersion: activation.pinned_version,
-                updatedAt: activation.updated_at
-            }))
-        };
-    }
-    enablePack(args) {
-        const scopeId = resolveScope(args.cwd).scope_id;
-        const pack = this.packRepo.getPack(args.packId);
-        if (!pack) {
-            throw new Error(`Unknown experience pack: ${args.packId}`);
-        }
-        const existing = this.packRepo.listActivations(scopeId).find((activation) => activation.pack_id === args.packId);
-        const updatedAt = nowIso();
-        this.packRepo.upsertActivation({
-            scope_id: scopeId,
-            pack_id: args.packId,
-            enabled: true,
-            pinned_version: pack.current_version,
-            created_at: existing?.created_at ?? updatedAt,
-            updated_at: updatedAt
-        });
-        return {
-            scopeId,
-            packId: args.packId,
-            enabled: true,
-            pinnedVersion: pack.current_version,
-            updatedAt
-        };
-    }
-    disablePack(args) {
-        const scopeId = resolveScope(args.cwd).scope_id;
-        const existing = this.packRepo.listActivations(scopeId).find((activation) => activation.pack_id === args.packId);
-        const updatedAt = nowIso();
-        this.packRepo.upsertActivation({
-            scope_id: scopeId,
-            pack_id: args.packId,
-            enabled: false,
-            pinned_version: existing?.pinned_version,
-            created_at: existing?.created_at ?? updatedAt,
-            updated_at: updatedAt
-        });
-        return {
-            scopeId,
-            packId: args.packId,
-            enabled: false,
-            pinnedVersion: existing?.pinned_version,
-            updatedAt
-        };
-    }
-    compilePack(args) {
-        return compilePack({
-            packsDir: this.packsDir,
-            packId: args.packId,
-            version: args.version,
-            target: args.target
-        });
-    }
-    inspectPackDeploymentStatus(args) {
-        return deployCompiledPack({
-            packsDir: this.packsDir,
-            packId: args.packId,
-            version: args.version,
-            target: args.target,
-            repoPath: args.repoPath,
-            statusOnly: true
-        });
-    }
-    deployPackPreview(args) {
-        return deployCompiledPack({
-            packsDir: this.packsDir,
-            packId: args.packId,
-            version: args.version,
-            target: args.target,
-            repoPath: args.repoPath,
-            dryRun: true
-        });
-    }
-    inspectScopePackStatus(cwd = process.cwd()) {
-        return this.inspectScopePackStatusByScopeId(resolveScope(cwd).scope_id);
-    }
-    inspectScopePackStatusByScopeId(scopeId) {
-        const activations = this.packRepo
-            .listActivations(scopeId)
-            .map((activation) => toScopePackActivation(this.packRepo.getPack(activation.pack_id), activation))
-            .filter((activation) => Boolean(activation));
-        const publishedPackIds = Array.from(new Set(activations
-            .filter((activation) => activation.status === "published" || activation.status === "rolled_back")
-            .map((activation) => activation.packId)));
-        const compiler = summarizePackCompiler(this.packRegistry, publishedPackIds, new Map(activations
-            .filter((activation) => activation.status === "published" || activation.status === "rolled_back")
-            .map((activation) => [activation.packId, activation.currentVersion])));
-        return {
-            scopeId,
-            enabledCount: activations.filter((activation) => activation.enabled).length,
-            activations,
-            compiler
-        };
-    }
     listNodesByState(state) {
         return this.nodeRepo.listByState(state).map(toNodeSummary);
     }
@@ -474,7 +664,7 @@ export class ExperienceInteractionService {
     buildLearningSummary(scopeId) {
         const candidateStates = ["pending", "distilled", "failed", "discarded"];
         const jobStates = ["pending", "processing", "succeeded", "failed", "discarded"];
-        const nodeStates = ["candidate", "active", "cooling", "retired"];
+        const nodeStates = ["candidate", "priority_candidate", "active", "cooling", "retired"];
         const nodeSources = ["explicit_provider", "rule", "disabled"];
         const attributionReasons = [
             "success_outcome",
@@ -492,10 +682,6 @@ export class ExperienceInteractionService {
             : candidateStates.flatMap((state) => this.candidateRepo.listByLifecycleState(state));
         const candidateIds = new Set(candidates.map((candidate) => candidate.id));
         const jobs = jobStates.flatMap((state) => this.jobRepo.listByStatus(state)).filter((job) => candidateIds.has(job.candidate_id));
-        const publishedPacks = this.packRepo
-            .listPacks()
-            .filter((pack) => pack.status === "published" || pack.status === "rolled_back");
-        const compiler = summarizePackCompiler(this.packRegistry, publishedPacks.map((pack) => pack.pack_id), new Map(publishedPacks.map((pack) => [pack.pack_id, pack.current_version])));
         const effectiveness = {
             decisions: scopeId ? this.injectionRepo.countByScope(scopeId) : this.injectionRepo.count(),
             live: scopeId ? this.injectionRepo.countByScopeAndDeliveryMode(scopeId, "live") : this.injectionRepo.countByDeliveryMode("live"),
@@ -530,7 +716,6 @@ export class ExperienceInteractionService {
                 outcomes: scopeId ? this.outcomeRepo.countByScope(scopeId) : this.outcomeRepo.count(),
                 reviews: scopeId ? this.reviewEventRepo.countByNodeScope(scopeId) : this.reviewEventRepo.count()
             },
-            compiler,
             latestRecordCreatedAt: latestRecord?.created_at
         };
     }
@@ -539,11 +724,6 @@ export class ExperienceInteractionService {
         const latestRecord = this.inputRepo.getLatestByScope(scope.scope_id);
         const latest = latestRecord ? this.inspectRecord(latestRecord) : undefined;
         const learning = this.buildLearningSummary(scope.scope_id);
-        const scopePackStatus = this.inspectScopePackStatusByScopeId(scope.scope_id);
-        const activePacks = scopePackStatus.activations.filter((activation) => activation.enabled);
-        const matchedPackIds = new Set(latest?.matchedPacks.map((pack) => pack.packId) ?? []);
-        const matchedPacks = scopePackStatus.activations.filter((activation) => matchedPackIds.has(activation.packId));
-        const deployments = this.inspectRepoDeploymentStatuses(scopePackStatus.activations, cwd);
         return buildRepoSummary({
             scope: {
                 scopeId: scope.scope_id,
@@ -551,14 +731,12 @@ export class ExperienceInteractionService {
                 rootPath: scope.root_path
             },
             latest: latest && latest.scopeId === scope.scope_id ? latest : undefined,
-            learning,
-            activePacks,
-            matchedPacks,
-            deployments
+            learning
         });
     }
-    inspectFirstValueReadiness() {
-        const summary = this.inspectLearningSummary();
+    inspectFirstValueReadiness(cwd = process.cwd()) {
+        const scope = resolveScope(cwd);
+        const summary = this.buildLearningSummary(scope.scope_id);
         const rawRecords = summary.runtime.records;
         const taskRuns = summary.runtime.taskRuns;
         const candidates = summary.candidates.pending;
@@ -582,8 +760,99 @@ export class ExperienceInteractionService {
             nextStep
         };
     }
-    feedbackLast(feedback) {
-        const record = this.inputRepo.getLatestInjected();
+    inspectDecisionHealth(cwd = process.cwd(), limit = 10) {
+        const scope = resolveScope(cwd);
+        const recentRecords = this.inputRepo.listRecentByScope(scope.scope_id, limit);
+        let recentInjects = 0;
+        let recentConservativeInjects = 0;
+        let recentSkips = 0;
+        let recentPotentialMisfires = 0;
+        let recentMetaDominantSelections = 0;
+        let recentRealDevAlignedSelections = 0;
+        let recentFastPathActivations = 0;
+        let recentRerankParticipations = 0;
+        let recentQueryRewriteUsages = 0;
+        let recentSecondOpinionActivations = 0;
+        let recentSecondOpinionSkips = 0;
+        let recentSecondOpinionConservativeDowngrades = 0;
+        const scopedNodes = this.nodeRepo.listByScope(scope.scope_id);
+        const recentNodes = scopedNodes.slice(0, limit);
+        const currentPriorityCandidates = scopedNodes.filter((node) => node.state === "priority_candidate").length;
+        const recentConvergedUpdates = recentNodes.filter((node) => node.merge_decision === "UPDATE").length;
+        const recentPriorityPromotions = recentNodes.filter((node) => node.priority_promotion_applied).length;
+        let lastDecisionMode;
+        for (const record of recentRecords) {
+            const injectionEvent = record.session_id
+                ? this.injectionRepo.getLatestBySessionId(record.session_id)
+                : undefined;
+            const decisionMode = injectionEvent?.mode ?? "skip";
+            if (!lastDecisionMode) {
+                lastDecisionMode = decisionMode;
+            }
+            if (decisionMode === "inject") {
+                recentInjects += 1;
+            }
+            else if (decisionMode === "inject_conservative") {
+                recentConservativeInjects += 1;
+            }
+            else {
+                recentSkips += 1;
+            }
+            if (isPotentialMisfire(injectionEvent)) {
+                recentPotentialMisfires += 1;
+            }
+            const governance = deriveGovernanceSignals(injectionEvent?.scorecard);
+            if (governance.metaDominant) {
+                recentMetaDominantSelections += 1;
+            }
+            if (governance.realDevAligned) {
+                recentRealDevAlignedSelections += 1;
+            }
+            if (injectionEvent?.scorecard?.fastPathApplied) {
+                recentFastPathActivations += 1;
+            }
+            if (injectionEvent?.scorecard?.topCandidates?.some((candidate) => typeof candidate.rerankScore === "number")) {
+                recentRerankParticipations += 1;
+            }
+            if (injectionEvent?.scorecard?.queryRewriteApplied) {
+                recentQueryRewriteUsages += 1;
+            }
+            if (injectionEvent?.scorecard?.secondOpinionApplied) {
+                recentSecondOpinionActivations += 1;
+            }
+            if (injectionEvent?.scorecard?.secondOpinionDecision === "skip") {
+                recentSecondOpinionSkips += 1;
+            }
+            if (injectionEvent?.scorecard?.secondOpinionDecision === "allow_conservative") {
+                recentSecondOpinionConservativeDowngrades += 1;
+            }
+        }
+        return {
+            scopeId: scope.scope_id,
+            recentDecisions: recentRecords.length,
+            recentInjects,
+            recentConservativeInjects,
+            recentSkips,
+            recentPotentialMisfires,
+            recentMetaDominantSelections,
+            recentRealDevAlignedSelections,
+            recentFastPathActivations,
+            recentRerankParticipations,
+            recentQueryRewriteUsages,
+            recentSecondOpinionActivations,
+            recentSecondOpinionSkips,
+            recentSecondOpinionConservativeDowngrades,
+            currentPriorityCandidates,
+            recentConvergedUpdates,
+            recentPriorityPromotions,
+            lastDecisionMode
+        };
+    }
+    feedbackLast(feedback, cwd) {
+        const scope = cwd ? resolveScope(cwd) : undefined;
+        const record = scope
+            ? this.inputRepo.getLatestInjectedByScope(scope.scope_id) ?? this.inputRepo.getLatestInjected()
+            : this.inputRepo.getLatestInjected();
         if (!record) {
             return {
                 status: "not_found",
@@ -601,7 +870,7 @@ export class ExperienceInteractionService {
             ? this.taskRunRepo.getLatestBySessionId(record.session_id)?.id
             : undefined;
         for (const node of nodes) {
-            this.nodeRepo.upsert(applyNodeFeedback(node, feedback));
+            this.nodeRepo.upsert(applyGovernedNodeFeedback(node, feedback, this.deriveOriginProfile(node)));
             this.reviewEventRepo.upsert(toReviewEvent(node.id, feedback === "helped" ? "mark_helped" : "mark_harmed", "user", taskRunId));
         }
         return {
@@ -619,7 +888,7 @@ export class ExperienceInteractionService {
                 nodeId
             };
         }
-        this.nodeRepo.upsert(applyNodeFeedback(node, feedback));
+        this.nodeRepo.upsert(applyGovernedNodeFeedback(node, feedback, this.deriveOriginProfile(node)));
         this.reviewEventRepo.upsert(toReviewEvent(nodeId, feedback === "helped" ? "mark_helped" : "mark_harmed", "user"));
         return {
             status: "updated",
@@ -672,35 +941,5 @@ export class ExperienceInteractionService {
             state: updated.state
         };
     }
-    inspectRepoDeploymentStatuses(activations, repoPath) {
-        const published = activations.find((activation) => activation.enabled && (activation.status === "published" || activation.status === "rolled_back"));
-        if (!published) {
-            return REPO_SUMMARY_TARGETS.map((target) => ({
-                target,
-                status: "missing"
-            }));
-        }
-        return REPO_SUMMARY_TARGETS.map((target) => {
-            try {
-                const result = this.inspectPackDeploymentStatus({
-                    packId: published.packId,
-                    version: published.pinnedVersion ?? published.currentVersion,
-                    target,
-                    repoPath
-                });
-                return {
-                    target,
-                    status: result.deploymentStatus,
-                    destination: result.destinationPath
-                };
-            }
-            catch {
-                return {
-                    target,
-                    status: "missing"
-                };
-            }
-        });
-    }
 }
 //# sourceMappingURL=service.js.map