@alan512/experienceengine 0.2.0 → 0.3.0

package/dist/interaction/retrieval-policy-inspection.d.ts

@@ -0,0 +1,19 @@
+import type { InjectionScorecard, PolicyEnrichmentComponent, RetrievalPolicyStageDiagnostic } from "../types/domain.js";
+export type RetrievalPolicyStageInspection = {
+    stage: RetrievalPolicyStageDiagnostic["stage"];
+    acceptedCount?: number;
+    rejectedCount?: number;
+    passedCount?: number;
+    reasonCodes: string[];
+};
+export type RetrievalPolicyComponentInspection = PolicyEnrichmentComponent;
+export type RetrievalPolicyInspectionSummary = {
+    stages: RetrievalPolicyStageInspection[];
+    semanticMode?: "skipped" | "rerank" | "backfill";
+    topPolicyComponents: RetrievalPolicyComponentInspection[];
+    rejectedCandidates: Array<{
+        id: string;
+        reasonCodes: string[];
+    }>;
+};
+export declare const buildRetrievalPolicyInspectionSummary: (scorecard?: InjectionScorecard) => RetrievalPolicyInspectionSummary | undefined;

package/dist/interaction/retrieval-policy-inspection.js

@@ -0,0 +1,33 @@
+const SEMANTIC_STAGE = "semantic_rerank_backfill";
+const inferSemanticMode = (stage) => {
+    const modeReason = stage?.reasonCodes.find((reason) => reason.startsWith("semantic_mode:"));
+    const mode = modeReason?.slice("semantic_mode:".length);
+    return mode === "skipped" || mode === "rerank" || mode === "backfill" ? mode : undefined;
+};
+export const buildRetrievalPolicyInspectionSummary = (scorecard) => {
+    const stages = scorecard?.retrievalPolicyDiagnostics?.stages ?? [];
+    const topCandidate = scorecard?.topCandidates?.[0];
+    const topPolicyComponents = [...(topCandidate?.policyComponents ?? [])]
+        .sort((left, right) => Math.abs(right.value) - Math.abs(left.value))
+        .slice(0, 5);
+    const rejectedCandidates = scorecard?.rejectedCandidates?.slice(0, 5).map((candidate) => ({
+        id: candidate.id,
+        reasonCodes: candidate.reasonCodes
+    })) ?? [];
+    if (!stages.length && !topPolicyComponents.length && !rejectedCandidates.length) {
+        return undefined;
+    }
+    return {
+        stages: stages.map((stage) => ({
+            stage: stage.stage,
+            acceptedCount: stage.acceptedCount,
+            rejectedCount: stage.rejectedCount,
+            passedCount: stage.passedCount,
+            reasonCodes: stage.reasonCodes
+        })),
+        semanticMode: inferSemanticMode(stages.find((stage) => stage.stage === SEMANTIC_STAGE)),
+        topPolicyComponents,
+        rejectedCandidates
+    };
+};
+//# sourceMappingURL=retrieval-policy-inspection.js.map

package/dist/interaction/retrieval-policy-inspection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retrieval-policy-inspection.js","sourceRoot":"","sources":["../../src/interaction/retrieval-policy-inspection.ts"],"names":[],"mappings":"AA0BA,MAAM,cAAc,GAAG,0BAA0B,CAAC;AAElD,MAAM,iBAAiB,GAAG,CACxB,KAAiD,EACC,EAAE;IACpD,MAAM,UAAU,GAAG,KAAK,EAAE,WAAW,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC,CAAC;IAC5F,MAAM,IAAI,GAAG,UAAU,EAAE,KAAK,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;IACxD,OAAO,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;AAC3F,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,qCAAqC,GAAG,CACnD,SAA8B,EACgB,EAAE;IAChD,MAAM,MAAM,GAAG,SAAS,EAAE,0BAA0B,EAAE,MAAM,IAAI,EAAE,CAAC;IACnE,MAAM,YAAY,GAAG,SAAS,EAAE,aAAa,EAAE,CAAC,CAAC,CAAC,CAAC;IACnD,MAAM,mBAAmB,GAAG,CAAC,GAAG,CAAC,YAAY,EAAE,gBAAgB,IAAI,EAAE,CAAC,CAAC;SACpE,IAAI,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;SACnE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACf,MAAM,kBAAkB,GACtB,SAAS,EAAE,kBAAkB,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;QAC7D,EAAE,EAAE,SAAS,CAAC,EAAE;QAChB,WAAW,EAAE,SAAS,CAAC,WAAW;KACnC,CAAC,CAAC,IAAI,EAAE,CAAC;IAEZ,IAAI,CAAC,MAAM,CAAC,MAAM,IAAI,CAAC,mBAAmB,CAAC,MAAM,IAAI,CAAC,kBAAkB,CAAC,MAAM,EAAE,CAAC;QAChF,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,OAAO;QACL,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;YAC7B,KAAK,EAAE,KAAK,CAAC,KAAK;YAClB,aAAa,EAAE,KAAK,CAAC,aAAa;YAClC,aAAa,EAAE,KAAK,CAAC,aAAa;YAClC,WAAW,EAAE,KAAK,CAAC,WAAW;YAC9B,WAAW,EAAE,KAAK,CAAC,WAAW;SAC/B,CAAC,CAAC;QACH,YAAY,EAAE,iBAAiB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,KAAK,cAAc,CAAC,CAAC;QACvF,mBAAmB;QACnB,kBAAkB;KACnB,CAAC;AACJ,CAAC,CAAC"}

package/dist/interaction/service.d.ts

@@ -1,8 +1,12 @@
 import type { ExperienceEngineConfig } from "../config/config-schema.js";
 import { type BenchmarkSummary } from "../evaluation/benchmark-summary.js";
+import { type HygieneReviewFilters, type HygieneReviewReport } from "../maintenance/experience-hygiene.js";
+import { type ExperienceExportDraftFilters, type ExperienceExportDraftReport } from "../maintenance/experience-export-drafts.js";
+import { type OperatorReviewReport } from "../maintenance/operator-review-flow.js";
 import { type HybridRouteDecision } from "../hybrid/router.js";
-import type { CandidateLifecycleState, DistillationSource, DistillationJobState, EvaluationMode, ExperienceInputRecord, FeedbackAttributionReason, InjectionEvent, InjectionScorecard, ExperienceNode, ExperienceNodeType, ExperienceState, TaskRun } from "../types/domain.js";
+import type { CandidateLifecycleState, DistillationSource, DistillationJobState, EvaluationMode, ExperienceInputRecord, FeedbackAttributionReason, AttributionRecord, EpisodeProjection, InjectionEvent, InjectionScorecard, ExperienceNode, ExperienceNodeType, ExperienceState, TaskRun } from "../types/domain.js";
 import { type ExperienceRepoSummary } from "./repo-summary.js";
+import { type RetrievalPolicyInspectionSummary } from "./retrieval-policy-inspection.js";
 export type ExperienceNodeSummary = {
     id: string;
     type: ExperienceNode["node_type"];
@@ -53,6 +57,7 @@ export type ExperienceTimelineEntry = {
 };
 export type ExperienceLastInspection = {
     sessionId?: string;
+    episodeId?: string;
     scopeId: string;
     taskType: ExperienceInputRecord["task_type"];
     intervention: "inject" | "skip" | "shadow" | "holdout";
@@ -60,6 +65,8 @@ export type ExperienceLastInspection = {
     delivered?: boolean;
     autoFeedback: "helped" | "harmed" | "none";
     autoFeedbackReason?: InjectionEvent["attribution_reason"];
+    attributionRecords: AttributionRecord[];
+    episodeProjection?: EpisodeProjection;
     outcome: ExperienceInputRecord["outcome_signal"];
     injectedNodes: ExperienceNodeSummary[];
     hints: string[];
@@ -68,6 +75,7 @@ export type ExperienceLastInspection = {
     decisionExplanation?: string;
     trustSummary?: string;
     retrievalNotes: string[];
+    retrievalPolicySummary?: RetrievalPolicyInspectionSummary;
     timeline: ExperienceTimelineEntry[];
     learningStatus?: TaskRun["learning_status"];
     learningReason?: string;
@@ -171,6 +179,9 @@ export declare class ExperienceInteractionService {
     private readonly hybridWorkerClient;
     private readonly inputRepo;
     private readonly injectionRepo;
+    private readonly attributionRecordRepo;
+    private readonly repoPolicyRepo;
+    private readonly episodeRepo;
     private readonly nodeRepo;
     private readonly candidateRepo;
     private readonly jobRepo;
@@ -197,8 +208,20 @@ export declare class ExperienceInteractionService {
     listNodesByState(state: ExperienceState): ExperienceNodeSummary[];
     listNodesByType(nodeType: ExperienceNodeType): ExperienceNodeSummary[];
     inspectLearningSummary(): ExperienceLearningSummary;
+    inspectHygiene(cwd?: string, filters?: Omit<HygieneReviewFilters, "scopeId"> & {
+        scopeId?: string;
+    }): HygieneReviewReport;
+    inspectExportDrafts(cwd?: string, filters?: Omit<ExperienceExportDraftFilters, "scopeId"> & {
+        scopeId?: string;
+    }): ExperienceExportDraftReport;
+    inspectReview(cwd?: string, filters?: {
+        scopeId?: string;
+        limit?: number;
+    }): OperatorReviewReport;
     private buildLearningSummary;
     inspectRepoSummary(cwd?: string): ExperienceRepoSummary;
+    inspectRepoPolicy(cwd?: string): import("../experience-management/repo-policy.js").RepoPolicyInspection;
+    restoreRepoPolicy(cwd?: string): import("../types/domain.js").RepoPolicy;
     inspectFirstValueReadiness(cwd?: string): ExperienceFirstValueReadiness;
     inspectDecisionHealth(cwd?: string, limit?: number): ExperienceDecisionHealth;
     feedbackLast(feedback: FeedbackValue, cwd?: string): FeedbackResult;

package/dist/interaction/service.js

@@ -3,6 +3,10 @@ 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 { buildDefaultRepoPolicy, inspectRepoPolicyEvidence } from "../experience-management/repo-policy.js";
+import { buildHygieneReviewReport } from "../maintenance/experience-hygiene.js";
+import { buildExperienceExportDraftReport } from "../maintenance/experience-export-drafts.js";
+import { buildOperatorReviewFlow } from "../maintenance/operator-review-flow.js";
 import { selectHybridRoute } from "../hybrid/router.js";
 import { HybridWorkerClient } from "../hybrid/worker-client.js";
 import { resolveScope } from "../input/scope-resolver.js";
@@ -12,6 +16,9 @@ import { DistillationJobRepository } from "../store/sqlite/repositories/distilla
 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 { AttributionRecordRepository } from "../store/sqlite/repositories/attribution-record-repo.js";
+import { RepoPolicyRepository } from "../store/sqlite/repositories/repo-policy-repo.js";
+import { EpisodeRepository } from "../store/sqlite/repositories/episode-repo.js";
 import { NodeRepository } from "../store/sqlite/repositories/node-repo.js";
 import { OutcomeRecordRepository } from "../store/sqlite/repositories/outcome-record-repo.js";
 import { ReviewEventRepository } from "../store/sqlite/repositories/review-event-repo.js";
@@ -20,8 +27,9 @@ import { TaskRunRepository } from "../store/sqlite/repositories/task-run-repo.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 { createId, stableId } from "../utils/ids.js";
 import { buildRepoSummary } from "./repo-summary.js";
+import { buildRetrievalPolicyInspectionSummary } from "./retrieval-policy-inspection.js";
 const normalizeHybridExplainPrompt = (value) => value
     .toLowerCase()
     .replace(/\s+/g, " ")
@@ -89,14 +97,41 @@ export const deriveStructuredSilenceReason = (input) => {
     }
     return "unknown";
 };
-const toReviewEvent = (nodeId, eventType, source, taskRunId) => ({
+const toReviewEvent = (nodeId, eventType, source, taskRunId, episodeId) => ({
     id: createId("review"),
+    episode_id: episodeId,
     node_id: nodeId,
     task_run_id: taskRunId,
     event_type: eventType,
     source,
     created_at: nowIso()
 });
+const toManualOverrideAttributionRecord = (input) => {
+    const timestamp = nowIso();
+    return {
+        id: stableId("attr", `${input.injectionEvent?.injection_id ?? "manual"}:${input.nodeId}:manual_override:${input.feedback}:${timestamp}`),
+        injection_id: input.injectionEvent?.injection_id,
+        node_id: input.nodeId,
+        episode_id: input.episodeId ?? input.injectionEvent?.episode_id,
+        intervention_strength: input.injectionEvent?.scorecard?.interventionStrength,
+        injection_mode: input.injectionEvent?.mode,
+        delivery_mode: input.injectionEvent?.delivery_mode,
+        delivered: Boolean(input.injectionEvent?.delivered),
+        outcome: input.injectionEvent?.was_successful === true
+            ? "success"
+            : input.injectionEvent?.was_successful === false
+                ? "failure"
+                : "unknown",
+        attribution_verdict: input.feedback === "helped" ? "strong_helped" : "strong_harmed",
+        confidence: "high",
+        evidence_refs: input.evidenceRefs,
+        user_override: input.feedback,
+        source: "manual_override",
+        attribution_reason: "manual_override",
+        created_at: timestamp,
+        resolved_at: timestamp
+    };
+};
 const deriveNodeRisk = (node) => {
     if (node.state === "candidate") {
         return "high";
@@ -353,6 +388,9 @@ export class ExperienceInteractionService {
     hybridWorkerClient;
     inputRepo;
     injectionRepo;
+    attributionRecordRepo;
+    repoPolicyRepo;
+    episodeRepo;
     nodeRepo;
     candidateRepo;
     jobRepo;
@@ -367,6 +405,9 @@ export class ExperienceInteractionService {
         bootstrapDatabase(db);
         this.inputRepo = new InputRecordRepository(db);
         this.injectionRepo = new InjectionRepository(db);
+        this.attributionRecordRepo = new AttributionRecordRepository(db);
+        this.repoPolicyRepo = new RepoPolicyRepository(db);
+        this.episodeRepo = new EpisodeRepository(db);
         this.nodeRepo = new NodeRepository(db);
         this.candidateRepo = new CandidateRepository(db);
         this.jobRepo = new DistillationJobRepository(db);
@@ -458,15 +499,19 @@ export class ExperienceInteractionService {
         if (!record) {
             return undefined;
         }
-        const injectionEvent = record.session_id
+        const episodeProjection = record.episode_id ? this.episodeRepo.getByEpisodeId(record.episode_id) : undefined;
+        const injectionEvent = episodeProjection?.injection_events[0] ?? (record.session_id
             ? this.injectionRepo.getLatestBySessionId(record.session_id)
             : record.injected_node_ids.length
                 ? this.injectionRepo.getLatest()
-                : undefined;
+                : undefined);
         const selectedNodeIds = injectionEvent?.injected_node_ids?.length
             ? injectionEvent.injected_node_ids
             : record.injected_node_ids;
         const injectedNodes = this.nodeRepo.listByIds(selectedNodeIds);
+        const attributionRecords = episodeProjection?.attribution_records ?? (injectionEvent
+            ? this.attributionRecordRepo.listByInjectionId(injectionEvent.injection_id)
+            : selectedNodeIds.flatMap((nodeId) => this.attributionRecordRepo.listByNodeId(nodeId)));
         const scorecard = injectionEvent?.scorecard ??
             (selectedNodeIds.length
                 ? buildInjectionScorecard({
@@ -479,17 +524,19 @@ export class ExperienceInteractionService {
                     injected_node_ids: selectedNodeIds
                 }, "inject", injectedNodes, record.session_id)
                 : undefined);
-        const taskRun = record.session_id ? this.taskRunRepo.getLatestBySessionId(record.session_id) : undefined;
-        const reviewEvents = taskRun?.id ? this.reviewEventRepo.listByTaskRunId(taskRun.id) : [];
+        const taskRun = episodeProjection?.task_run ?? (record.session_id ? this.taskRunRepo.getLatestBySessionId(record.session_id) : undefined);
+        const reviewEvents = episodeProjection?.review_events ?? (taskRun?.id ? this.reviewEventRepo.listByTaskRunId(taskRun.id) : []);
         const autoFeedback = summarizeAutomaticFeedback(reviewEvents);
-        const intervention = selectedNodeIds.length === 0
+        const intervention = injectionEvent?.mode === "skip"
             ? "skip"
-            : injectionEvent && !injectionEvent.delivered
-                ? injectionEvent.delivery_mode === "holdout"
-                    ? "holdout"
-                    : "shadow"
-                : "inject";
-        const outcomeRecord = taskRun?.id ? this.outcomeRepo.listByTaskRunId(taskRun.id)[0] : undefined;
+            : selectedNodeIds.length === 0
+                ? "skip"
+                : injectionEvent && !injectionEvent.delivered
+                    ? injectionEvent.delivery_mode === "holdout"
+                        ? "holdout"
+                        : "shadow"
+                    : "inject";
+        const outcomeRecord = episodeProjection?.outcome_records[0] ?? (taskRun?.id ? this.outcomeRepo.listByTaskRunId(taskRun.id)[0] : undefined);
         const latestAutomaticFeedback = reviewEvents.find((event) => event.source === "automatic");
         const autoFeedbackReason = inferAutoFeedbackReason({
             explicitReason: injectionEvent?.attribution_reason,
@@ -500,6 +547,7 @@ export class ExperienceInteractionService {
         const decisionExplanation = buildDecisionExplanation({ intervention, scorecard });
         return {
             sessionId: record.session_id,
+            episodeId: record.episode_id,
             scopeId: record.scope_id,
             taskType: record.task_type,
             intervention,
@@ -507,6 +555,8 @@ export class ExperienceInteractionService {
             delivered: injectionEvent?.delivered,
             autoFeedback,
             autoFeedbackReason,
+            attributionRecords,
+            episodeProjection,
             outcome: record.outcome_signal,
             injectedNodes: injectedNodes.map(toNodeSummary),
             hints: injectedNodes.map((node) => node.compact_hint),
@@ -515,6 +565,7 @@ export class ExperienceInteractionService {
             decisionExplanation,
             trustSummary: buildTrustSummary({ scorecard, injectedNodes: injectedNodes.map(toNodeSummary) }),
             retrievalNotes: buildRetrievalNotes(scorecard),
+            retrievalPolicySummary: buildRetrievalPolicyInspectionSummary(scorecard),
             timeline: buildLatestTimeline({
                 record,
                 taskRunCreatedAt: taskRun?.created_at,
@@ -537,27 +588,32 @@ export class ExperienceInteractionService {
         if (!event) {
             return undefined;
         }
-        const taskRun = event.session_id ? this.taskRunRepo.getLatestBySessionId(event.session_id) : undefined;
+        const episodeProjection = event.episode_id ? this.episodeRepo.getByEpisodeId(event.episode_id) : undefined;
+        const taskRun = episodeProjection?.task_run ?? (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 attributionRecords = episodeProjection?.attribution_records ?? this.attributionRecordRepo.listByInjectionId(event.injection_id);
+        const reviewEvents = episodeProjection?.review_events ?? (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 intervention = event.mode === "skip"
+            ? "skip"
+            : !event.delivered
+                ? event.delivery_mode === "holdout"
+                    ? "holdout"
+                    : "shadow"
+                : "inject";
+        const outcomeRecord = episodeProjection?.outcome_records[0] ?? (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,
+            episodeId: event.episode_id,
             scopeId: event.scope_id,
             taskType: event.task_type,
             intervention,
@@ -570,6 +626,8 @@ export class ExperienceInteractionService {
                 intervention,
                 outcome
             }),
+            attributionRecords,
+            episodeProjection,
             outcome,
             injectedNodes: injectedNodes.map(toNodeSummary),
             hints: injectedNodes.map((node) => node.compact_hint),
@@ -578,6 +636,7 @@ export class ExperienceInteractionService {
             decisionExplanation,
             trustSummary: buildTrustSummary({ scorecard: event.scorecard, injectedNodes: injectedNodes.map(toNodeSummary) }),
             retrievalNotes: buildRetrievalNotes(event.scorecard),
+            retrievalPolicySummary: buildRetrievalPolicyInspectionSummary(event.scorecard),
             timeline: buildLatestTimeline({
                 record: {
                     record_id: `injection:${event.injection_id}`,
@@ -661,6 +720,77 @@ export class ExperienceInteractionService {
     inspectLearningSummary() {
         return this.buildLearningSummary();
     }
+    inspectHygiene(cwd = process.cwd(), filters = {}) {
+        const scopeId = filters.scopeId ?? resolveScope(cwd).scope_id;
+        const candidateStates = ["pending", "distilled", "failed", "discarded"];
+        return buildHygieneReviewReport({
+            nodes: this.nodeRepo.listByScope(scopeId),
+            candidates: candidateStates.flatMap((state) => this.candidateRepo.listByLifecycleState(state)).filter((candidate) => candidate.scope_id === scopeId),
+            attributionRecords: this.attributionRecordRepo.listRecentByScope(scopeId, Math.max(50, filters.limit ?? 20)),
+            filters: {
+                ...filters,
+                scopeId
+            }
+        });
+    }
+    inspectExportDrafts(cwd = process.cwd(), filters = {}) {
+        const scopeId = filters.scopeId ?? resolveScope(cwd).scope_id;
+        const candidateStates = ["pending", "distilled", "failed", "discarded"];
+        const nodes = this.nodeRepo.listByScope(scopeId);
+        const explicitLowReadiness = Boolean(filters.nodeId || filters.risk || filters.state || filters.deliveryState);
+        const candidateNodes = nodes
+            .filter((node) => !filters.nodeId || node.id === filters.nodeId)
+            .filter((node) => !filters.nodeType || node.node_type === filters.nodeType)
+            .filter((node) => !filters.taskFamily || node.task_type === filters.taskFamily)
+            .filter((node) => !filters.state || node.state === filters.state)
+            .filter((node) => !filters.deliveryState || node.delivery_state === filters.deliveryState)
+            .filter((node) => explicitLowReadiness || (node.state === "active" && (!node.delivery_state || node.delivery_state === "eligible") && node.harmed_count <= node.helped_count));
+        const candidates = candidateStates
+            .flatMap((state) => this.candidateRepo.listByLifecycleState(state))
+            .filter((candidate) => candidate.scope_id === scopeId);
+        const attributionRecordsById = new Map();
+        for (const record of this.attributionRecordRepo.listRecentByScope(scopeId, Math.max(50, filters.limit ?? 20))) {
+            attributionRecordsById.set(record.id, record);
+        }
+        for (const node of candidateNodes) {
+            for (const record of this.attributionRecordRepo.listByNodeId(node.id)) {
+                attributionRecordsById.set(record.id, record);
+            }
+        }
+        const attributionRecords = [...attributionRecordsById.values()];
+        const hygiene = buildHygieneReviewReport({
+            nodes,
+            candidates,
+            attributionRecords,
+            filters: {
+                scopeId,
+                limit: Math.max(50, filters.limit ?? 20)
+            }
+        });
+        return buildExperienceExportDraftReport({
+            nodes,
+            candidates,
+            attributionRecords,
+            hygieneFindings: hygiene.findings,
+            filters: {
+                ...filters,
+                scopeId
+            }
+        });
+    }
+    inspectReview(cwd = process.cwd(), filters = {}) {
+        const scopeId = filters.scopeId ?? resolveScope(cwd).scope_id;
+        const limit = filters.limit ?? 5;
+        const repo = this.inspectRepoSummary(cwd);
+        const hygiene = this.inspectHygiene(cwd, { scopeId, limit });
+        const exportDrafts = this.inspectExportDrafts(cwd, { scopeId, limit });
+        return buildOperatorReviewFlow({
+            repo,
+            hygiene,
+            exportDrafts,
+            limit
+        });
+    }
     buildLearningSummary(scopeId) {
         const candidateStates = ["pending", "distilled", "failed", "discarded"];
         const jobStates = ["pending", "processing", "succeeded", "failed", "discarded"];
@@ -724,6 +854,7 @@ 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 policyInspection = this.inspectRepoPolicy(cwd);
         return buildRepoSummary({
             scope: {
                 scopeId: scope.scope_id,
@@ -731,9 +862,20 @@ export class ExperienceInteractionService {
                 rootPath: scope.root_path
             },
             latest: latest && latest.scopeId === scope.scope_id ? latest : undefined,
-            learning
+            learning,
+            policyInspection
         });
     }
+    inspectRepoPolicy(cwd = process.cwd()) {
+        const scope = resolveScope(cwd);
+        const policy = this.repoPolicyRepo.get(scope.scope_id) ??
+            buildDefaultRepoPolicy(scope.scope_id, this.config.repoExperienceMode);
+        return inspectRepoPolicyEvidence(policy, this.attributionRecordRepo.listRecentEligibleByScope(scope.scope_id), this.injectionRepo.listRecentResolvedByScope(scope.scope_id));
+    }
+    restoreRepoPolicy(cwd = process.cwd()) {
+        const scope = resolveScope(cwd);
+        return this.repoPolicyRepo.restore(scope.scope_id, this.config.repoExperienceMode);
+    }
     inspectFirstValueReadiness(cwd = process.cwd()) {
         const scope = resolveScope(cwd);
         const summary = this.buildLearningSummary(scope.scope_id);
@@ -869,9 +1011,25 @@ export class ExperienceInteractionService {
         const taskRunId = record.session_id
             ? this.taskRunRepo.getLatestBySessionId(record.session_id)?.id
             : undefined;
+        const episodeId = record.episode_id;
+        const injectionEvent = record.session_id
+            ? this.injectionRepo.getLatestBySessionId(record.session_id)
+            : undefined;
+        const evidenceRefs = [
+            record.record_id,
+            taskRunId,
+            injectionEvent?.injection_id
+        ].filter((value) => Boolean(value));
         for (const node of nodes) {
             this.nodeRepo.upsert(applyGovernedNodeFeedback(node, feedback, this.deriveOriginProfile(node)));
-            this.reviewEventRepo.upsert(toReviewEvent(node.id, feedback === "helped" ? "mark_helped" : "mark_harmed", "user", taskRunId));
+            this.reviewEventRepo.upsert(toReviewEvent(node.id, feedback === "helped" ? "mark_helped" : "mark_harmed", "user", taskRunId, episodeId));
+            this.attributionRecordRepo.insert(toManualOverrideAttributionRecord({
+                nodeId: node.id,
+                feedback,
+                injectionEvent,
+                episodeId,
+                evidenceRefs
+            }));
         }
         return {
             status: "updated",
@@ -890,6 +1048,11 @@ export class ExperienceInteractionService {
         }
         this.nodeRepo.upsert(applyGovernedNodeFeedback(node, feedback, this.deriveOriginProfile(node)));
         this.reviewEventRepo.upsert(toReviewEvent(nodeId, feedback === "helped" ? "mark_helped" : "mark_harmed", "user"));
+        this.attributionRecordRepo.insert(toManualOverrideAttributionRecord({
+            nodeId,
+            feedback,
+            evidenceRefs: [`manual:${nodeId}`]
+        }));
         return {
             status: "updated",
             feedback,