diff --git a/frontend/package-lock.json b/frontend/package-lock.json
index 5694b53..8023817 100644
--- a/frontend/package-lock.json
+++ b/frontend/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "grafyn-frontend",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "grafyn-frontend",
-      "version": "0.1.13",
+      "version": "0.1.15",
       "license": "GPL-3.0-only",
       "dependencies": {
         "@tauri-apps/api": "^1.6.0",
diff --git a/frontend/src-tauri/src/commands/canvas.rs b/frontend/src-tauri/src/commands/canvas.rs
index 56d2bda..15a11fa 100644
--- a/frontend/src-tauri/src/commands/canvas.rs
+++ b/frontend/src-tauri/src/commands/canvas.rs
@@ -9,12 +9,13 @@ use crate::models::canvas::{
 use crate::models::note::{ChunkResult, NoteCreate, NoteStatus};
 use crate::models::settings::UserSettings;
 use crate::models::twin::{
-    ActionGap, ConstitutionItem, ConstitutionSetup, DecisionEpisodeCreate, PrimitiveDecisionAssessment,
-    ReflectionCardCreate, TraceEventType, TwinContextRecord,
+    ActionGap, ConstitutionItem, ConstitutionSetup, DecisionEpisode, DecisionEpisodeCreate,
+    PrimitiveDecisionAssessment, ReflectionCardCreate, TraceEventType, TwinContextRecord,
 };
-use crate::services::openrouter::ChatMessage;
+use crate::services::ollama::OllamaService;
+use crate::services::openrouter::{ChatMessage, OpenRouterService};
 use crate::services::retrieval::RetrievalResult;
-use crate::services::twin_store::TwinStore;
+use crate::services::twin_store::{parse_twin_prediction, TwinStore};
 use crate::AppState;
 use chrono::Utc;
 use futures::StreamExt;
@@ -44,6 +45,13 @@ const LLM_NODE_HEIGHT: f64 = 200.0;
 const LLM_NODE_Y_STEP: f64 = 300.0; // height(200) + 100px gap for content overflow
 const LLM_NODE_X_GAP: f64 = 80.0;
 
+// Twin context assembly
+const TWIN_CONTEXT_VERSION: &str = "ctx-v2-cases-lexical";
+const TWIN_CONTEXT_TOKEN_BUDGET: usize = 4000;
+const MAX_TWIN_CASE_CONTEXT: usize = 5;
+const TWIN_CASE_FIELD_MAX_CHARS: usize = 800;
+const TWIN_CASE_CORRECTION_MAX_CHARS: usize = 500;
+
 #[derive(Debug, Clone)]
 struct ConversationTurn {
     prompt: String,
@@ -60,6 +68,11 @@ struct ResolvedPromptContext {
     constitution_items: Vec<ConstitutionItem>,
     action_gaps: Vec<ActionGap>,
     system_prompt: Option<String>,
+    /// Raw twin system prompt before any user system prompt is merged in;
+    /// reused verbatim by the sealed-prediction call.
+    twin_context_prompt: Option<String>,
+    context_version: Option<String>,
+    decision_case_ids: Vec<String>,
 }
 
 type StreamedResponseUpdate = (String, String, ResponseStatus, Option<String>);
@@ -304,6 +317,15 @@ pub async fn send_prompt(
                 initial_leaning: decision_metadata.initial_leaning,
                 review_date: decision_metadata.review_date,
                 primitive_assessment: PrimitiveDecisionAssessment::default(),
+                // Stamped on every decision episode — including non-Twin
+                // context tiles — so attribution survives a failed or absent
+                // hidden prediction call.
+                context_version: Some(
+                    resolved_context
+                        .context_version
+                        .clone()
+                        .unwrap_or_else(|| TWIN_CONTEXT_VERSION.to_string()),
+                ),
             })
             .map_err(|error| error.to_string())?;
     }
@@ -328,6 +350,8 @@ pub async fn send_prompt(
             "candidate_twin_record_ids": tile.candidate_twin_records.iter().map(|record| record.id.clone()).collect::<Vec<_>>(),
             "constitution_item_ids": resolved_context.constitution_items.iter().map(|item| item.id.clone()).collect::<Vec<_>>(),
             "action_gap_ids": resolved_context.action_gaps.iter().map(|gap| gap.id.clone()).collect::<Vec<_>>(),
+            "context_version": resolved_context.context_version.clone(),
+            "decision_case_ids": resolved_context.decision_case_ids.clone(),
             "web_search": tile.web_search,
             "web_search_max_results": tile.web_search_max_results,
         }),
@@ -582,6 +606,47 @@ pub async fn send_prompt(
         );
     });
 
+    // Sealed twin prediction: one hidden, non-streaming call per decision
+    // episode with at least two options. Fire-and-forget in its own task —
+    // it never emits canvas-stream events and cannot block or fail the
+    // visible flow above.
+    if let Some(episode_id) = tile.decision_episode_id.clone() {
+        let metadata = tile.decision_metadata.clone().unwrap_or_default();
+        if metadata.options.len() >= 2 {
+            let prediction_model = match model_route.provider {
+                ModelProviderRoute::Ollama => tile.models.first().cloned().unwrap_or_default(),
+                ModelProviderRoute::OpenRouter => {
+                    let settings = state.settings_service.read().await;
+                    settings.get().llm_model.clone()
+                }
+            };
+            let decision = if metadata.decision.trim().is_empty() {
+                tile.prompt.clone()
+            } else {
+                metadata.decision.clone()
+            };
+            let context_version = resolved_context
+                .context_version
+                .clone()
+                .unwrap_or_else(|| TWIN_CONTEXT_VERSION.to_string());
+            tauri::async_runtime::spawn(run_sealed_twin_prediction(
+                state.twin_store.clone(),
+                state.openrouter.clone(),
+                state.ollama.clone(),
+                model_route.provider.clone(),
+                prediction_model,
+                episode_id,
+                tile.prompt.clone(),
+                decision,
+                metadata.options.clone(),
+                metadata.stakes.clone(),
+                resolved_context.twin_context_prompt.clone(),
+                context_version,
+                tile.decision_metadata.clone(),
+            ));
+        }
+    }
+
     Ok(tile_id)
 }
 
@@ -2269,10 +2334,9 @@ async fn resolve_prompt_context(
         let pinned_ids = session.pinned_note_ids.clone();
 
         // Quality gate: note-level retrieval to check if vault has relevant content
-        let retrieval_results =
-            run_retrieval(state, &request.prompt, 5, &pinned_ids)
-                .await
-                .unwrap_or_default();
+        let retrieval_results = run_retrieval(state, &request.prompt, 5, &pinned_ids)
+            .await
+            .unwrap_or_default();
 
         let retrieval_decision = should_use_retrieved_notes(&request.prompt, &retrieval_results);
         if retrieval_decision != RetrievalDecisionReason::UseRetrievedNotes {
@@ -2289,6 +2353,9 @@ async fn resolve_prompt_context(
                 constitution_items: Vec::new(),
                 action_gaps: Vec::new(),
                 system_prompt: request.system_prompt.clone(),
+                twin_context_prompt: None,
+                context_version: None,
+                decision_case_ids: Vec::new(),
             });
         }
 
@@ -2376,6 +2443,9 @@ async fn resolve_prompt_context(
                 constitution_items: Vec::new(),
                 action_gaps: Vec::new(),
                 system_prompt: Some(system_prompt),
+                twin_context_prompt: None,
+                context_version: None,
+                decision_case_ids: Vec::new(),
             })
         } else {
             log::info!("Canvas using note-level context (chunk retrieval disabled)");
@@ -2397,6 +2467,9 @@ async fn resolve_prompt_context(
             constitution_items: Vec::new(),
             action_gaps: Vec::new(),
             system_prompt: request.system_prompt.clone(),
+            twin_context_prompt: None,
+            context_version: None,
+            decision_case_ids: Vec::new(),
         })
     }
 }
@@ -2408,10 +2481,9 @@ async fn resolve_twin_prompt_context(
     request: &PromptRequest,
 ) -> Result<ResolvedPromptContext, String> {
     let pinned_ids = session.pinned_note_ids.clone();
-    let retrieval_results =
-        run_retrieval(state, &request.prompt, 5, &pinned_ids)
-            .await
-            .unwrap_or_default();
+    let retrieval_results = run_retrieval(state, &request.prompt, 5, &pinned_ids)
+        .await
+        .unwrap_or_default();
 
     let should_use_notes = should_use_retrieved_notes(&request.prompt, &retrieval_results)
         == RetrievalDecisionReason::UseRetrievedNotes;
@@ -2484,7 +2556,14 @@ async fn resolve_twin_prompt_context(
 
     let constitution_query =
         decision_context_query(&request.prompt, request.decision_metadata.as_ref());
-    let (setup, approved_twin_records, candidate_twin_records, constitution_items, action_gaps) = {
+    let (
+        setup,
+        approved_twin_records,
+        candidate_twin_records,
+        constitution_items,
+        action_gaps,
+        decision_cases,
+    ) = {
         let mut twin_store = state.twin_store.write().await;
         let setup = twin_store
             .get_constitution_setup()
@@ -2496,33 +2575,62 @@ async fn resolve_twin_prompt_context(
         let (constitution_items, action_gaps) = twin_store
             .select_constitution_context(&constitution_query)
             .map_err(|error| error.to_string())?;
-        (setup, approved, candidate, constitution_items, action_gaps)
+        let decision_cases = twin_store
+            .select_decision_cases(&constitution_query, None, MAX_TWIN_CASE_CONTEXT)
+            .map_err(|error| error.to_string())?;
+        (
+            setup,
+            approved,
+            candidate,
+            constitution_items,
+            action_gaps,
+            decision_cases,
+        )
     };
 
+    let selection = apply_twin_context_budget(
+        decision_cases,
+        constitution_items,
+        approved_twin_records,
+        candidate_twin_records,
+        action_gaps,
+        note_contexts,
+        TWIN_CONTEXT_TOKEN_BUDGET,
+    );
+    let decision_case_ids = selection
+        .cases
+        .iter()
+        .map(|episode| episode.id.clone())
+        .collect::<Vec<_>>();
+
     let twin_prompt = build_twin_context_prompt(
         &setup,
-        &note_contexts,
-        &approved_twin_records,
-        &candidate_twin_records,
-        &constitution_items,
-        &action_gaps,
+        &selection.cases,
+        &selection.notes,
+        &selection.approved,
+        &selection.candidates,
+        &selection.constitution_items,
+        &selection.action_gaps,
         &request.twin_answer_mode,
         &request.prompt_type,
         request.decision_metadata.as_ref(),
     );
     let system_prompt = match &request.system_prompt {
         Some(user_sp) if !user_sp.is_empty() => format!("{}\n\n{}", twin_prompt, user_sp),
-        _ => twin_prompt,
+        _ => twin_prompt.clone(),
     };
 
     Ok(ResolvedPromptContext {
         messages,
         context_notes,
-        approved_twin_records,
-        candidate_twin_records,
-        constitution_items,
-        action_gaps,
+        approved_twin_records: selection.approved,
+        candidate_twin_records: selection.candidates,
+        constitution_items: selection.constitution_items,
+        action_gaps: selection.action_gaps,
         system_prompt: Some(system_prompt),
+        twin_context_prompt: Some(twin_prompt),
+        context_version: Some(TWIN_CONTEXT_VERSION.to_string()),
+        decision_case_ids,
     })
 }
 
@@ -2579,6 +2687,9 @@ async fn resolve_note_level_context(
         constitution_items: Vec::new(),
         action_gaps: Vec::new(),
         system_prompt: Some(system_prompt),
+        twin_context_prompt: None,
+        context_version: None,
+        decision_case_ids: Vec::new(),
     })
 }
 
@@ -2818,8 +2929,328 @@ fn build_note_context_prompt(notes: &[(String, String, String)]) -> String {
     prompt
 }
 
+/// Rough token estimate matching the chunk-index convention (words * 4/3).
+fn estimate_tokens(text: &str) -> usize {
+    text.split_whitespace().count() * 4 / 3 + 1
+}
+
+/// Render one past decision episode as a verbatim behavioral case.
+fn format_decision_case(episode: &DecisionEpisode) -> String {
+    let mut case = format!("### Past decision: {}\n", episode.decision.trim());
+    if !episode.options.is_empty() {
+        case.push_str(&format!("- Options: {}\n", episode.options.join(" | ")));
+    }
+    if let Some(chosen) = episode.chosen_option.as_deref() {
+        case.push_str(&format!("- Chose: {}\n", chosen.trim()));
+    }
+    if let Some(leaning) = episode.initial_leaning.as_deref() {
+        if !leaning.trim().is_empty() {
+            case.push_str(&format!("- Initial leaning: {}\n", leaning.trim()));
+        }
+    }
+    if let Some(outcome) = episode.outcome.as_deref() {
+        if !outcome.trim().is_empty() {
+            case.push_str(&format!(
+                "- Outcome: {}\n",
+                truncate_note_context_content(outcome.trim(), TWIN_CASE_FIELD_MAX_CHARS)
+            ));
+        }
+    }
+    if let Some(lesson) = episode.lesson.as_deref() {
+        if !lesson.trim().is_empty() {
+            case.push_str(&format!(
+                "- Lesson (verbatim): {}\n",
+                truncate_note_context_content(lesson.trim(), TWIN_CASE_FIELD_MAX_CHARS)
+            ));
+        }
+    }
+    if let Some(note) = episode.correction_note.as_deref() {
+        if !note.trim().is_empty() {
+            case.push_str(&format!(
+                "- Correction note (recorded when an earlier sealed twin guess missed): {}\n",
+                truncate_note_context_content(note.trim(), TWIN_CASE_CORRECTION_MAX_CHARS)
+            ));
+        }
+    }
+    case.push('\n');
+    case
+}
+
+struct TwinContextSelection {
+    cases: Vec<DecisionEpisode>,
+    constitution_items: Vec<ConstitutionItem>,
+    approved: Vec<TwinContextRecord>,
+    candidates: Vec<TwinContextRecord>,
+    action_gaps: Vec<ActionGap>,
+    notes: Vec<(String, String, String)>,
+}
+
+/// Greedy-fill the variable twin context sections into a hard token budget,
+/// in priority order: cases > constitution > approved records > candidate
+/// records > action gaps > evidence notes. Fixed scaffolding (operating
+/// contract, identity, answer instructions, decision metadata) sits outside
+/// the budget.
+#[allow(clippy::too_many_arguments)]
+fn apply_twin_context_budget(
+    cases: Vec<DecisionEpisode>,
+    constitution_items: Vec<ConstitutionItem>,
+    approved: Vec<TwinContextRecord>,
+    candidates: Vec<TwinContextRecord>,
+    action_gaps: Vec<ActionGap>,
+    notes: Vec<(String, String, String)>,
+    budget: usize,
+) -> TwinContextSelection {
+    let mut remaining = budget as isize;
+    let mut take_within_budget = move |cost: usize| -> bool {
+        if remaining - cost as isize >= 0 {
+            remaining -= cost as isize;
+            true
+        } else {
+            false
+        }
+    };
+
+    let cases = cases
+        .into_iter()
+        .filter(|episode| take_within_budget(estimate_tokens(&format_decision_case(episode))))
+        .collect();
+    let constitution_items = constitution_items
+        .into_iter()
+        .filter(|item| take_within_budget(estimate_tokens(&format_constitution_item(item))))
+        .collect();
+    let approved = approved
+        .into_iter()
+        .filter(|record| take_within_budget(estimate_tokens(&format_twin_record(record))))
+        .collect();
+    let candidates = candidates
+        .into_iter()
+        .filter(|record| take_within_budget(estimate_tokens(&format_twin_record(record))))
+        .collect();
+    let action_gaps = action_gaps
+        .into_iter()
+        .filter(|gap| take_within_budget(estimate_tokens(&format_action_gap(gap))))
+        .collect();
+    let notes = notes
+        .into_iter()
+        .filter(|(_, title, content)| {
+            take_within_budget(estimate_tokens(title) + estimate_tokens(content))
+        })
+        .collect();
+
+    TwinContextSelection {
+        cases,
+        constitution_items,
+        approved,
+        candidates,
+        action_gaps,
+        notes,
+    }
+}
+
+/// User message for the hidden sealed-prediction call. With a configured
+/// Twin Identity the framing is immersed first person; the fallback is a
+/// neutral decision-support instruction. Disclosure language lives in the
+/// app UI, never in model-facing prompts.
+fn build_twin_prediction_user_message(
+    setup: &ConstitutionSetup,
+    decision: &str,
+    options: &[String],
+    stakes: Option<&str>,
+) -> String {
+    let immersed = has_twin_identity(setup);
+    let mut message = String::new();
+    if immersed {
+        let name = setup
+            .twin_name
+            .as_deref()
+            .unwrap_or_default()
+            .trim()
+            .to_string();
+        message.push_str(&format!(
+            "I am {}. The decision in front of me: {}\n",
+            name,
+            decision.trim()
+        ));
+    } else {
+        message.push_str(&format!(
+            "Decision under consideration: {}\n",
+            decision.trim()
+        ));
+    }
+    if let Some(stakes) = stakes {
+        if !stakes.trim().is_empty() {
+            message.push_str(&format!("Stakes: {}\n", stakes.trim()));
+        }
+    }
+    message.push_str("My options:\n");
+    for (index, option) in options.iter().enumerate() {
+        message.push_str(&format!("{}. {}\n", index + 1, option));
+    }
+    if immersed {
+        message.push_str(
+            "\nWhich option do I choose? I answer with only this JSON object and nothing else:\n",
+        );
+    } else {
+        message.push_str(
+            "\nGiven the context above, determine which option best fits this decision-maker's \
+             documented values, constitution, and past decisions. Respond with only this JSON \
+             object and nothing else:\n",
+        );
+    }
+    message.push_str(
+        "{\"predicted_option\": \"<option text>\", \"option_index\": <option number from the list above>, \
+         \"confidence\": <0.0 to 1.0>, \"rationale\": \"<one or two sentences>\"}",
+    );
+    message
+}
+
+/// The hidden sealed-prediction call. Runs in its own spawned task, never
+/// touches the window, and never blocks the visible streaming flow. Lock
+/// discipline: collect owned data under the store lock, drop it, await the
+/// provider, then re-lock to attach.
+#[allow(clippy::too_many_arguments)]
+async fn run_sealed_twin_prediction(
+    twin_store: Arc<RwLock<TwinStore>>,
+    openrouter: Arc<RwLock<OpenRouterService>>,
+    ollama: Arc<RwLock<OllamaService>>,
+    provider_route: ModelProviderRoute,
+    prediction_model: String,
+    episode_id: String,
+    prompt: String,
+    decision: String,
+    options: Vec<String>,
+    stakes: Option<String>,
+    twin_context_prompt: Option<String>,
+    context_version: String,
+    decision_metadata: Option<DecisionPromptMetadata>,
+) {
+    let built = {
+        let mut store = twin_store.write().await;
+        let setup = match store.get_constitution_setup() {
+            Ok(setup) => setup,
+            Err(error) => {
+                log::warn!("Sealed prediction setup load failed for {episode_id}: {error}");
+                let _ = store.mark_twin_prediction_failed(&episode_id);
+                return;
+            }
+        };
+
+        let system_prompt = if let Some(prompt) = twin_context_prompt {
+            prompt
+        } else {
+            // Non-Twin-context decision tile: build a twin-only context on
+            // the spot so predictions cover every decision, not just
+            // Twin-mode ones (skipping them would bias the eval sample).
+            let query = decision_context_query(&prompt, decision_metadata.as_ref());
+            let selections =
+                store
+                    .select_context_records(&prompt)
+                    .and_then(|(approved, candidates)| {
+                        let (constitution_items, action_gaps) =
+                            store.select_constitution_context(&query)?;
+                        let cases = store.select_decision_cases(
+                            &query,
+                            Some(&episode_id),
+                            MAX_TWIN_CASE_CONTEXT,
+                        )?;
+                        Ok((approved, candidates, constitution_items, action_gaps, cases))
+                    });
+            match selections {
+                Ok((approved, candidates, constitution_items, action_gaps, cases)) => {
+                    let selection = apply_twin_context_budget(
+                        cases,
+                        constitution_items,
+                        approved,
+                        candidates,
+                        action_gaps,
+                        Vec::new(),
+                        TWIN_CONTEXT_TOKEN_BUDGET,
+                    );
+                    let answer_mode = if has_twin_identity(&setup) {
+                        TwinAnswerMode::Simulation
+                    } else {
+                        TwinAnswerMode::Advisor
+                    };
+                    build_twin_context_prompt(
+                        &setup,
+                        &selection.cases,
+                        &selection.notes,
+                        &selection.approved,
+                        &selection.candidates,
+                        &selection.constitution_items,
+                        &selection.action_gaps,
+                        &answer_mode,
+                        &PromptType::Decision,
+                        decision_metadata.as_ref(),
+                    )
+                }
+                Err(error) => {
+                    log::warn!("Sealed prediction context build failed for {episode_id}: {error}");
+                    let _ = store.mark_twin_prediction_failed(&episode_id);
+                    return;
+                }
+            }
+        };
+
+        let user_message =
+            build_twin_prediction_user_message(&setup, &decision, &options, stakes.as_deref());
+        (system_prompt, user_message)
+    };
+    let (system_prompt, user_message) = built;
+
+    let messages = vec![ChatMessage {
+        role: "user".to_string(),
+        content: user_message,
+    }];
+    let result = match provider_route {
+        ModelProviderRoute::Ollama => {
+            let ollama = ollama.read().await;
+            ollama
+                .chat(&prediction_model, messages, Some(&system_prompt), Some(0.2))
+                .await
+        }
+        ModelProviderRoute::OpenRouter => {
+            let openrouter = openrouter.read().await;
+            openrouter
+                .chat(
+                    &prediction_model,
+                    messages,
+                    Some(&system_prompt),
+                    Some(0.2),
+                    Some(600),
+                    Some("none"),
+                    false,
+                    0,
+                )
+                .await
+        }
+    };
+
+    match result {
+        Ok(raw) => {
+            let draft = parse_twin_prediction(&raw, &options);
+            let mut store = twin_store.write().await;
+            if let Err(error) = store.attach_twin_prediction(
+                &episode_id,
+                draft,
+                &prediction_model,
+                &context_version,
+            ) {
+                log::warn!("Failed to seal twin prediction for {episode_id}: {error}");
+            }
+        }
+        Err(error) => {
+            log::warn!("Sealed twin prediction call failed for {episode_id}: {error}");
+            let mut store = twin_store.write().await;
+            let _ = store.mark_twin_prediction_failed(&episode_id);
+        }
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
 fn build_twin_context_prompt(
     setup: &ConstitutionSetup,
+    decision_cases: &[DecisionEpisode],
     notes: &[(String, String, String)],
     approved_records: &[TwinContextRecord],
     candidate_records: &[TwinContextRecord],
@@ -2840,6 +3271,19 @@ fn build_twin_context_prompt(
 
     prompt.push_str(&format_twin_identity_section(setup, answer_mode));
 
+    prompt.push_str("## Past Decision Cases\n\n");
+    if decision_cases.is_empty() {
+        prompt.push_str("No similar past decisions were selected for this prompt.\n\n");
+    } else {
+        prompt.push_str(
+            "These are this person's actual past decisions, verbatim. \
+             Weight them above abstracted records: they show how tradeoffs were really made.\n",
+        );
+        for episode in decision_cases {
+            prompt.push_str(&format_decision_case(episode));
+        }
+    }
+
     let reviewed_constitution = constitution_items
         .iter()
         .filter(|item| {
@@ -3018,10 +3462,7 @@ fn has_twin_identity(setup: &ConstitutionSetup) -> bool {
             .is_some_and(|value| !value.trim().is_empty())
 }
 
-fn format_twin_identity_section(
-    setup: &ConstitutionSetup,
-    answer_mode: &TwinAnswerMode,
-) -> String {
+fn format_twin_identity_section(setup: &ConstitutionSetup, answer_mode: &TwinAnswerMode) -> String {
     let mut section = String::from("## Twin Identity\n\n");
     let name = setup.twin_name.as_deref().map(str::trim).unwrap_or("");
     let role = setup.twin_role.as_deref().map(str::trim).unwrap_or("");
@@ -3493,6 +3934,7 @@ mod tests {
 
         let prompt = build_twin_context_prompt(
             &ConstitutionSetup::default(),
+            &[],
             &[(
                 "note-1".into(),
                 "Decision Notes".into(),
@@ -3538,6 +3980,7 @@ mod tests {
             &[],
             &[],
             &[],
+            &[],
             &TwinAnswerMode::Simulation,
             &PromptType::Standard,
             None,
@@ -3548,9 +3991,7 @@ mod tests {
         assert!(prompt.contains("My role/context is founder deciding from product evidence."));
         assert!(prompt.contains("Use reviewed notes and uploaded interviews only."));
         assert!(prompt.contains("Continue my documented reasoning pattern"));
-        assert!(prompt.contains(
-            "do not append questions unless the user's request asks for them"
-        ));
+        assert!(prompt.contains("do not append questions unless the user's request asks for them"));
         assert!(!prompt.contains("reflective questions"));
         assert!(!prompt.contains("next question"));
         assert!(!prompt.contains("not the user's actual view"));
@@ -3586,6 +4027,7 @@ mod tests {
             &[],
             &[],
             &[],
+            &[],
             &TwinAnswerMode::Advisor,
             &PromptType::Decision,
             Some(&metadata),
@@ -3616,6 +4058,7 @@ mod tests {
             &[],
             &[],
             &[],
+            &[],
             &TwinAnswerMode::Simulation,
             &PromptType::Decision,
             Some(&metadata),
@@ -3628,13 +4071,161 @@ mod tests {
         assert!(!prompt.contains("Decision Mirror simulation session"));
         assert!(!prompt.contains("natural first-person reflection"));
         assert!(!prompt.contains("numbered headings"));
-        assert!(prompt.contains(
-            "do not append questions unless the user's request asks for them"
-        ));
+        assert!(prompt.contains("do not append questions unless the user's request asks for them"));
         assert!(!prompt.contains("not the user's actual view"));
         assert!(prompt.contains("Decision: Should Grafyn build Decision Mirror first?"));
     }
 
+    fn test_decision_case(
+        id: &str,
+        decision: &str,
+        lesson: Option<&str>,
+        note: Option<&str>,
+    ) -> DecisionEpisode {
+        let now = Utc::now();
+        DecisionEpisode {
+            id: id.to_string(),
+            session_id: "session-1".to_string(),
+            tile_id: format!("tile-{id}"),
+            decision: decision.to_string(),
+            options: vec!["Ship now".to_string(), "Wait a sprint".to_string()],
+            stakes: None,
+            initial_leaning: Some("Ship now".to_string()),
+            selected_response: None,
+            chosen_option: Some("Wait a sprint".to_string()),
+            confidence: None,
+            review_date: None,
+            outcome: None,
+            regret_score: None,
+            lesson: lesson.map(|text| text.to_string()),
+            missed_something: None,
+            primitive_assessment: PrimitiveDecisionAssessment::default(),
+            twin_prediction: None,
+            prediction_status: None,
+            agreement: None,
+            correction_note: note.map(|text| text.to_string()),
+            context_version: None,
+            outcome_recorded_at: None,
+            created_at: now,
+            updated_at: now,
+        }
+    }
+
+    #[test]
+    fn twin_context_prompt_renders_past_decision_cases_verbatim() {
+        let case = test_decision_case(
+            "case-1",
+            "Ship the importer before polish?",
+            Some("I always regret shipping before the empty states are done."),
+            Some("Twin assumed I optimize for speed; I optimize for trust."),
+        );
+
+        let prompt = build_twin_context_prompt(
+            &ConstitutionSetup::default(),
+            &[case],
+            &[],
+            &[],
+            &[],
+            &[],
+            &[],
+            &TwinAnswerMode::Advisor,
+            &PromptType::Standard,
+            None,
+        );
+
+        assert!(prompt.contains("## Past Decision Cases"));
+        assert!(prompt.contains("Past decision: Ship the importer before polish?"));
+        assert!(prompt.contains("Options: Ship now | Wait a sprint"));
+        assert!(prompt.contains("Chose: Wait a sprint"));
+        assert!(prompt.contains("I always regret shipping before the empty states are done."));
+        assert!(prompt.contains("Twin assumed I optimize for speed; I optimize for trust."));
+        assert!(prompt.contains("Weight them above abstracted records"));
+    }
+
+    #[test]
+    fn twin_context_budget_keeps_cases_and_drops_notes_when_tight() {
+        let case = test_decision_case("case-1", "Ship the importer before polish?", None, None);
+        let big_note = (
+            "note-1".to_string(),
+            "Big note".to_string(),
+            "evidence ".repeat(400),
+        );
+
+        let selection = apply_twin_context_budget(
+            vec![case],
+            Vec::new(),
+            Vec::new(),
+            Vec::new(),
+            Vec::new(),
+            vec![big_note],
+            60,
+        );
+
+        assert_eq!(selection.cases.len(), 1);
+        assert!(selection.notes.is_empty());
+    }
+
+    #[test]
+    fn sealed_prediction_prompt_is_immersed_with_identity_and_never_meta_framed() {
+        let setup = test_twin_identity_setup();
+        let options = vec!["Ship now".to_string(), "Wait a sprint".to_string()];
+        let user_message = build_twin_prediction_user_message(
+            &setup,
+            "Ship the importer before polish?",
+            &options,
+            Some("Launch trust"),
+        );
+        let system_prompt = build_twin_context_prompt(
+            &setup,
+            &[],
+            &[],
+            &[],
+            &[],
+            &[],
+            &[],
+            &TwinAnswerMode::Simulation,
+            &PromptType::Decision,
+            None,
+        );
+
+        assert!(user_message.contains("I am Alex Chen."));
+        assert!(user_message.contains("Which option do I choose?"));
+        assert!(user_message.contains("1. Ship now"));
+        assert!(user_message.contains("2. Wait a sprint"));
+        assert!(user_message.contains("predicted_option"));
+
+        // The full model-facing prompt must never meta-frame the twin.
+        let full_prompt = format!("{system_prompt}\n{user_message}").to_lowercase();
+        for forbidden in [
+            "simulate",
+            "roleplay",
+            "role-play",
+            "predict what the user",
+            "what would the user",
+            "pretend to be",
+        ] {
+            assert!(
+                !full_prompt.contains(forbidden),
+                "model-facing prompt contains forbidden meta-framing: {forbidden}"
+            );
+        }
+    }
+
+    #[test]
+    fn sealed_prediction_prompt_uses_advisor_framing_without_identity() {
+        let options = vec!["Ship now".to_string(), "Wait a sprint".to_string()];
+        let user_message = build_twin_prediction_user_message(
+            &ConstitutionSetup::default(),
+            "Ship the importer before polish?",
+            &options,
+            None,
+        );
+
+        assert!(!user_message.contains("I am "));
+        assert!(user_message.contains("best fits this decision-maker's"));
+        assert!(user_message.contains("predicted_option"));
+    }
+
     #[test]
     fn test_build_selected_parent_chain_returns_root_to_leaf_order() {
         let session = build_session(vec![
diff --git a/frontend/src-tauri/src/models/twin.rs b/frontend/src-tauri/src/models/twin.rs
index 7dc4f06..f24b7b0 100644
--- a/frontend/src-tauri/src/models/twin.rs
+++ b/frontend/src-tauri/src/models/twin.rs
@@ -92,6 +92,7 @@ pub enum TraceEventType {
     ConstitutionInferenceRun,
     TileDeleted,
     ResponseDeleted,
+    TwinPredictionSealed,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
@@ -370,10 +371,53 @@ pub struct DecisionEpisode {
     pub missed_something: Option<String>,
     #[serde(default)]
     pub primitive_assessment: PrimitiveDecisionAssessment,
+    #[serde(default)]
+    pub twin_prediction: Option<TwinPrediction>,
+    #[serde(default)]
+    pub prediction_status: Option<String>,
+    #[serde(default)]
+    pub agreement: Option<bool>,
+    #[serde(default)]
+    pub correction_note: Option<String>,
+    #[serde(default)]
+    pub context_version: Option<String>,
+    #[serde(default)]
+    pub outcome_recorded_at: Option<DateTime<Utc>>,
     pub created_at: DateTime<Utc>,
     pub updated_at: DateTime<Utc>,
 }
 
+/// Parser output for a twin prediction before it is sealed into storage.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TwinPredictionDraft {
+    pub predicted_option: String,
+    #[serde(default)]
+    pub matched_option_index: Option<usize>,
+    #[serde(default)]
+    pub confidence: Option<f32>,
+    #[serde(default)]
+    pub rationale: Option<String>,
+    pub parse_mode: String,
+}
+
+/// A sealed twin prediction. `sealed_at` is stamped when the prediction is
+/// persisted; it must never be shown through UI, IPC, or export while the
+/// episode's `chosen_option` is unset.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TwinPrediction {
+    pub predicted_option: String,
+    #[serde(default)]
+    pub matched_option_index: Option<usize>,
+    #[serde(default)]
+    pub confidence: Option<f32>,
+    #[serde(default)]
+    pub rationale: Option<String>,
+    pub parse_mode: String,
+    pub model_id: String,
+    pub context_version: String,
+    pub sealed_at: DateTime<Utc>,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct DecisionEpisodeCreate {
     pub id: String,
@@ -390,6 +434,8 @@ pub struct DecisionEpisodeCreate {
     pub review_date: Option<String>,
     #[serde(default)]
     pub primitive_assessment: PrimitiveDecisionAssessment,
+    #[serde(default)]
+    pub context_version: Option<String>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]
@@ -412,6 +458,8 @@ pub struct DecisionOutcomeUpdate {
     pub missed_something: Option<String>,
     #[serde(default)]
     pub primitive_assessment: Option<PrimitiveDecisionAssessment>,
+    #[serde(default)]
+    pub correction_note: Option<String>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
@@ -657,6 +705,8 @@ pub struct DecisionEpisodeWithReflections {
     pub reflection_cards: Vec<ReflectionCard>,
     #[serde(default)]
     pub feedback_events: Vec<TraceEvent>,
+    #[serde(default)]
+    pub prediction_sealed: bool,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
@@ -912,6 +962,8 @@ pub struct ExportBundle {
     pub decision_mirror_benchmark: ExportFileSummary,
     pub constitution_items: ExportFileSummary,
     pub action_gaps: ExportFileSummary,
+    pub decision_episodes: ExportFileSummary,
+    pub feedback_events: ExportFileSummary,
     pub manifest_path: String,
     pub included_records: usize,
     pub excluded_records: usize,
diff --git a/frontend/src-tauri/src/services/ollama.rs b/frontend/src-tauri/src/services/ollama.rs
index 30e298a..0fdbbf8 100644
--- a/frontend/src-tauri/src/services/ollama.rs
+++ b/frontend/src-tauri/src/services/ollama.rs
@@ -81,6 +81,71 @@ impl OllamaService {
         })
     }
 
+    /// Non-streaming completion. Used for hidden calls (e.g. sealed twin
+    /// predictions) where nothing renders incrementally; visible canvas
+    /// responses keep using `chat_stream`.
+    pub async fn chat(
+        &self,
+        model: &str,
+        messages: Vec<ChatMessage>,
+        system_prompt: Option<&str>,
+        temperature: Option<f64>,
+    ) -> Result<String> {
+        if model.trim().is_empty() {
+            return Err(anyhow::anyhow!(
+                "Select an Ollama model for local vault/twin responses before sending vault context"
+            ));
+        }
+
+        let mut all_messages = Vec::new();
+        if let Some(system) = system_prompt {
+            all_messages.push(ChatMessage {
+                role: "system".to_string(),
+                content: system.to_string(),
+            });
+        }
+        all_messages.extend(messages);
+
+        let request = OllamaChatRequest {
+            model: model.to_string(),
+            messages: all_messages,
+            stream: false,
+            options: temperature.map(|temperature| OllamaOptions { temperature }),
+        };
+
+        let response = self
+            .client
+            .post(format!("{}/api/chat", self.base_url))
+            .json(&request)
+            .timeout(Duration::from_secs(60))
+            .send()
+            .await
+            .context("Failed to reach Ollama. Is Ollama running locally?")?;
+
+        if !response.status().is_success() {
+            let status = response.status();
+            let error_text = response.text().await.unwrap_or_default();
+            return Err(anyhow::anyhow!(
+                "Ollama API error ({}): {}",
+                status,
+                error_text
+            ));
+        }
+
+        let parsed: OllamaChatResponse = response
+            .json()
+            .await
+            .context("Failed to parse Ollama chat response")?;
+        if let Some(error) = parsed.error {
+            return Err(anyhow::anyhow!("Ollama error: {}", error));
+        }
+
+        Ok(parsed
+            .message
+            .map(|message| message.content)
+            .unwrap_or_default())
+    }
+
     pub async fn chat_stream(
         &self,
         model: &str,
@@ -221,6 +286,12 @@ impl OllamaModelDetails {
     }
 }
 
+#[derive(Debug, Deserialize)]
+struct OllamaChatResponse {
+    message: Option<ChatMessage>,
+    error: Option<String>,
+}
+
 #[derive(Debug, Deserialize)]
 struct OllamaStreamLine {
     message: Option<ChatMessage>,
@@ -288,4 +359,36 @@ mod tests {
         assert_eq!(value["messages"][0]["role"], "system");
         assert_eq!(value["messages"][1]["content"], "What should I do?");
     }
+
+    #[test]
+    fn non_streaming_chat_request_serializes_stream_false() {
+        let request = OllamaChatRequest {
+            model: "llama3.1:8b".to_string(),
+            messages: vec![ChatMessage {
+                role: "user".to_string(),
+                content: "Which option do I choose?".to_string(),
+            }],
+            stream: false,
+            options: Some(OllamaOptions { temperature: 0.2 }),
+        };
+
+        let value = serde_json::to_value(request).unwrap();
+
+        assert_eq!(value["stream"], false);
+        assert_eq!(value["options"]["temperature"], 0.2);
+    }
+
+    #[test]
+    fn chat_response_parses_message_and_error() {
+        let ok: OllamaChatResponse = serde_json::from_str(
+            r#"{"message": {"role": "assistant", "content": "Wait a sprint"}, "done": true}"#,
+        )
+        .unwrap();
+        assert_eq!(ok.message.unwrap().content, "Wait a sprint");
+        assert!(ok.error.is_none());
+
+        let err: OllamaChatResponse =
+            serde_json::from_str(r#"{"error": "model not found"}"#).unwrap();
+        assert_eq!(err.error.as_deref(), Some("model not found"));
+    }
 }
diff --git a/frontend/src-tauri/src/services/twin_store.rs b/frontend/src-tauri/src/services/twin_store.rs
index 2092403..17e7c5a 100644
--- a/frontend/src-tauri/src/services/twin_store.rs
+++ b/frontend/src-tauri/src/services/twin_store.rs
@@ -8,8 +8,9 @@ use crate::models::twin::{
     ExportBundle, ExportFileSummary, MemoryDigestAction, MemoryDigestItem,
     MemoryDigestReviewRequest, MemoryDigestState, PromotionState, RecordOrigin, ReflectionCard,
     ReflectionCardCreate, ReflectionScores, ResolvedEvidenceRef, SessionTrace, TraceEvent,
-    TraceEventType, TwinContextRecord, TwinExportRequest, TwinInferenceRunSummary,
-    TwinReviewRecord, UserRecord, UserRecordCreate, UserRecordKind, UserRecordUpdate,
+    TraceEventType, TwinContextRecord, TwinExportRequest, TwinInferenceRunSummary, TwinPrediction,
+    TwinPredictionDraft, TwinReviewRecord, UserRecord, UserRecordCreate, UserRecordKind,
+    UserRecordUpdate,
 };
 #[cfg(test)]
 use crate::models::twin::{DecisionMirrorPreset, PrimitiveDecisionAssessment};
@@ -31,6 +32,8 @@ const AUTO_PROMOTE_CONFIDENCE: f32 = 0.75;
 const AUTO_PROMOTE_SUPPORT_COUNT: usize = 3;
 const EXCERPT_MAX_CHARS: usize = 220;
 const MAX_TWIN_CANDIDATE_CONTEXT_RECORDS: usize = 8;
+const MAX_TWIN_APPROVED_CONTEXT_RECORDS: usize = 12;
+const MAX_TWIN_APPROVED_FALLBACK_RECORDS: usize = 3;
 const MAX_MEMORY_DIGEST_ITEMS: usize = 5;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -426,12 +429,18 @@ impl TwinStore {
 
         let query_terms = lexical_terms(query);
         let mut approved = Vec::new();
+        let mut approved_fallback = Vec::new();
         let mut candidates = Vec::new();
 
         for record in self.record_cache.values() {
             match record.promotion_state {
                 PromotionState::Endorsed | PromotionState::AutoPromoted => {
-                    approved.push(twin_context_record(record, "approved"));
+                    let relevance = twin_record_relevance(record, &query_terms);
+                    if relevance > 0 {
+                        approved.push((relevance, twin_context_record(record, "approved")));
+                    } else {
+                        approved_fallback.push(twin_context_record(record, "approved"));
+                    }
                 }
                 PromotionState::Candidate => {
                     let relevance = twin_record_relevance(record, &query_terms);
@@ -448,12 +457,35 @@ impl TwinStore {
         }
 
         approved.sort_by(|a, b| {
-            b.confidence
-                .partial_cmp(&a.confidence)
-                .unwrap_or(std::cmp::Ordering::Equal)
-                .then_with(|| b.evidence_count.cmp(&a.evidence_count))
+            b.0.cmp(&a.0).then_with(|| {
+                b.1.confidence
+                    .partial_cmp(&a.1.confidence)
+                    .unwrap_or(std::cmp::Ordering::Equal)
+                    .then_with(|| b.1.evidence_count.cmp(&a.1.evidence_count))
+            })
         });
 
+        let approved: Vec<TwinContextRecord> = if approved.is_empty() {
+            // Never assemble an empty behavioral context just because the
+            // query shares no keywords with any approved record.
+            approved_fallback.sort_by(|a, b| {
+                b.confidence
+                    .partial_cmp(&a.confidence)
+                    .unwrap_or(std::cmp::Ordering::Equal)
+                    .then_with(|| b.evidence_count.cmp(&a.evidence_count))
+            });
+            approved_fallback
+                .into_iter()
+                .take(MAX_TWIN_APPROVED_FALLBACK_RECORDS)
+                .collect()
+        } else {
+            approved
+                .into_iter()
+                .take(MAX_TWIN_APPROVED_CONTEXT_RECORDS)
+                .map(|(_, record)| record)
+                .collect()
+        };
+
         candidates.sort_by(|a, b| {
             b.0.cmp(&a.0).then_with(|| b.1.cmp(&a.1)).then_with(|| {
                 b.2.confidence
@@ -526,6 +558,13 @@ impl TwinStore {
         Self::validate_file_id(&create.tile_id)?;
 
         let now = Utc::now();
+        // A prediction is only attempted when there are at least two options
+        // to choose between; record why one will not arrive otherwise.
+        let prediction_status = if create.options.len() >= 2 {
+            Some("requested".to_string())
+        } else {
+            None
+        };
         let episode = DecisionEpisode {
             id: create.id,
             session_id: create.session_id,
@@ -543,6 +582,12 @@ impl TwinStore {
             lesson: None,
             missed_something: None,
             primitive_assessment: create.primitive_assessment,
+            twin_prediction: None,
+            prediction_status,
+            agreement: None,
+            correction_note: None,
+            context_version: create.context_version,
+            outcome_recorded_at: None,
             created_at: now,
             updated_at: now,
         };
@@ -588,6 +633,64 @@ impl TwinStore {
         Ok(episodes)
     }
 
+    /// Select past decided episodes as verbatim behavioral cases for twin
+    /// context. Correction notes (recorded when a sealed prediction missed)
+    /// break ties between equally relevant cases but never outrank a more
+    /// relevant case.
+    pub fn select_decision_cases(
+        &self,
+        query: &str,
+        exclude_episode_id: Option<&str>,
+        max: usize,
+    ) -> Result<Vec<DecisionEpisode>> {
+        if max == 0 {
+            return Ok(Vec::new());
+        }
+
+        let query_terms = lexical_terms(query);
+        let mut scored = Vec::new();
+        let mut fallback = Vec::new();
+
+        for episode in self.list_decision_episodes()? {
+            if episode.chosen_option.is_none() {
+                continue;
+            }
+            if exclude_episode_id.is_some_and(|id| id == episode.id) {
+                continue;
+            }
+            let score = decision_case_relevance(&episode, &query_terms);
+            if score > 0 {
+                scored.push((score, episode));
+            } else {
+                fallback.push(episode);
+            }
+        }
+
+        if scored.is_empty() {
+            // No keyword overlap at all: include the most recent decided
+            // cases rather than an empty behavioral context.
+            fallback.sort_by(|a, b| b.updated_at.cmp(&a.updated_at));
+            fallback.truncate(max.min(2));
+            return Ok(fallback);
+        }
+
+        scored.sort_by(|a, b| {
+            b.0.cmp(&a.0)
+                .then_with(|| {
+                    b.1.correction_note
+                        .is_some()
+                        .cmp(&a.1.correction_note.is_some())
+                })
+                .then_with(|| b.1.updated_at.cmp(&a.1.updated_at))
+        });
+
+        Ok(scored
+            .into_iter()
+            .take(max)
+            .map(|(_, episode)| episode)
+            .collect())
+    }
+
     pub fn update_decision_outcome(
         &mut self,
         id: &str,
@@ -601,7 +704,13 @@ impl TwinStore {
             episode.selected_response = Some(selected_response);
         }
         if let Some(chosen_option) = update.chosen_option {
-            episode.chosen_option = Some(chosen_option);
+            // Canonicalize label/case variants ("b", "Option 2", extra
+            // whitespace) against the recorded options; unmatched free text
+            // is kept as-is (legacy and "other" outcomes stay recordable).
+            let canonical = match_option_index(&chosen_option, &episode.options)
+                .map(|index| episode.options[index].clone())
+                .unwrap_or(chosen_option);
+            episode.chosen_option = Some(canonical);
         }
         if let Some(confidence) = update.confidence {
             episode.confidence = Some(confidence.clamp(0.0, 1.0));
@@ -624,6 +733,26 @@ impl TwinStore {
         if let Some(primitive_assessment) = update.primitive_assessment {
             episode.primitive_assessment = primitive_assessment;
         }
+        if let Some(correction_note) = update.correction_note {
+            episode.correction_note = Some(correction_note);
+        }
+
+        if episode.outcome_recorded_at.is_none()
+            && (episode.chosen_option.is_some() || episode.outcome.is_some())
+        {
+            episode.outcome_recorded_at = Some(Utc::now());
+        }
+
+        // Agreement is recomputed whenever both sides exist, so a corrected
+        // chosen_option keeps the stored agreement current. Only predictions
+        // sealed before the outcome was first recorded count.
+        if let (Some(chosen), Some(prediction)) = (&episode.chosen_option, &episode.twin_prediction)
+        {
+            let recorded_at = episode.outcome_recorded_at.unwrap_or_else(Utc::now);
+            if prediction.sealed_at <= recorded_at {
+                episode.agreement = Some(compute_agreement(prediction, chosen, &episode.options));
+            }
+        }
 
         episode.updated_at = Utc::now();
         self.write_decision_file(&episode)?;
@@ -642,12 +771,99 @@ impl TwinStore {
                 "lesson": episode.lesson,
                 "missed_something": episode.missed_something,
                 "primitive_assessment": episode.primitive_assessment,
+                "agreement": episode.agreement,
+                "correction_note": episode.correction_note,
+                "prediction_context_version": episode
+                    .twin_prediction
+                    .as_ref()
+                    .map(|prediction| prediction.context_version.clone()),
             }),
         )?;
 
         Ok(episode)
     }
 
+    /// Seal a twin prediction onto an episode. Refuses (as a logged no-op
+    /// returning the unchanged episode) when the outcome is already recorded
+    /// or a prediction already exists, so `sealed_at` always precedes the
+    /// outcome structurally. The trace payload never contains the predicted
+    /// option — the trace viewer must not leak a sealed prediction.
+    pub fn attach_twin_prediction(
+        &mut self,
+        episode_id: &str,
+        draft: TwinPredictionDraft,
+        model_id: &str,
+        context_version: &str,
+    ) -> Result<DecisionEpisode> {
+        Self::validate_file_id(episode_id)?;
+        let path = self.decision_file_path(episode_id);
+        let mut episode = self.read_decision_file(&path)?;
+
+        if episode.chosen_option.is_some() {
+            log::warn!(
+                "Twin prediction for episode {} arrived after the outcome was recorded; discarding",
+                episode_id
+            );
+            episode.prediction_status = Some("outcome_recorded_first".to_string());
+            episode.updated_at = Utc::now();
+            self.write_decision_file(&episode)?;
+            return Ok(episode);
+        }
+        if episode.twin_prediction.is_some() {
+            log::warn!(
+                "Episode {} already has a sealed twin prediction; ignoring duplicate",
+                episode_id
+            );
+            return Ok(episode);
+        }
+
+        let prediction = TwinPrediction {
+            predicted_option: draft.predicted_option,
+            matched_option_index: draft.matched_option_index,
+            confidence: draft.confidence,
+            rationale: draft.rationale,
+            parse_mode: draft.parse_mode.clone(),
+            model_id: model_id.to_string(),
+            context_version: context_version.to_string(),
+            sealed_at: Utc::now(),
+        };
+        let sealed_at = prediction.sealed_at;
+        episode.twin_prediction = Some(prediction);
+        episode.prediction_status = Some("sealed".to_string());
+        episode.updated_at = Utc::now();
+        self.write_decision_file(&episode)?;
+
+        self.append_trace_event(
+            &episode.session_id,
+            TraceEventType::TwinPredictionSealed,
+            json!({
+                "decision_episode_id": episode.id,
+                "tile_id": episode.tile_id,
+                "model_id": model_id,
+                "context_version": context_version,
+                "parse_mode": draft.parse_mode,
+                "sealed_at": sealed_at,
+            }),
+        )?;
+
+        Ok(episode)
+    }
+
+    /// Record that the hidden prediction call failed, so exported episodes
+    /// distinguish "no prediction because the call failed" from "agreed to
+    /// not predict" — silent gaps would inflate measured accuracy.
+    pub fn mark_twin_prediction_failed(&mut self, episode_id: &str) -> Result<()> {
+        Self::validate_file_id(episode_id)?;
+        let path = self.decision_file_path(episode_id);
+        let mut episode = self.read_decision_file(&path)?;
+        if episode.twin_prediction.is_some() || episode.chosen_option.is_some() {
+            return Ok(());
+        }
+        episode.prediction_status = Some("failed".to_string());
+        episode.updated_at = Utc::now();
+        self.write_decision_file(&episode)
+    }
+
     pub fn record_reflection_card(
         &mut self,
         create: ReflectionCardCreate,
@@ -1029,14 +1245,22 @@ impl TwinStore {
         let mut episodes = self
             .list_decision_episodes()?
             .into_iter()
-            .map(|episode| {
+            .map(|mut episode| {
                 let mut reflection_cards = cards_by_episode.remove(&episode.id).unwrap_or_default();
                 reflection_cards.sort_by(|a, b| b.created_at.cmp(&a.created_at));
                 let feedback_events = self.decision_feedback_events(&episode).unwrap_or_default();
+                // A sealed prediction must never cross IPC before the outcome
+                // is recorded; the UI only learns that one exists.
+                let prediction_sealed =
+                    episode.twin_prediction.is_some() && episode.chosen_option.is_none();
+                if prediction_sealed {
+                    episode.twin_prediction = None;
+                }
                 DecisionEpisodeWithReflections {
                     episode,
                     reflection_cards,
                     feedback_events,
+                    prediction_sealed,
                 }
             })
             .collect::<Vec<_>>();
@@ -1764,6 +1988,8 @@ impl TwinStore {
         let benchmark_path = output_dir.join("decision_mirror_benchmark.jsonl");
         let constitution_path = output_dir.join("constitution_items.jsonl");
         let action_gaps_path = output_dir.join("action_gaps.jsonl");
+        let decision_episodes_path = output_dir.join("decision_episodes.jsonl");
+        let feedback_events_path = output_dir.join("feedback_events.jsonl");
         let manifest_path = output_dir.join("manifest.json");
 
         let mut records: Vec<UserRecord> = self.record_cache.values().cloned().collect();
@@ -1843,7 +2069,86 @@ impl TwinStore {
             .collect::<std::result::Result<Vec<_>, _>>()?;
         self.write_jsonl_file(&action_gaps_path, &action_gap_lines)?;
 
+        // Decision episodes with sealed-prediction integrity: while an
+        // episode has no recorded choice, its prediction exports as a
+        // non-revealing stub so the bet cannot leak through an early export.
+        let decision_episode_lines = self
+            .list_decision_episodes()?
+            .into_iter()
+            .map(|episode| {
+                let still_sealed =
+                    episode.twin_prediction.is_some() && episode.chosen_option.is_none();
+                let mut value = serde_json::to_value(&episode)?;
+                if still_sealed {
+                    if let Some(object) = value.as_object_mut() {
+                        let stub = episode.twin_prediction.as_ref().map(|prediction| {
+                            serde_json::json!({
+                                "sealed": true,
+                                "sealed_at": prediction.sealed_at,
+                                "model_id": prediction.model_id,
+                                "context_version": prediction.context_version,
+                                "parse_mode": prediction.parse_mode,
+                            })
+                        });
+                        object.insert("twin_prediction".to_string(), stub.unwrap_or(Value::Null));
+                    }
+                }
+                serde_json::to_string(&value).map_err(anyhow::Error::from)
+            })
+            .collect::<Result<Vec<_>>>()?;
+        self.write_jsonl_file(&decision_episodes_path, &decision_episode_lines)?;
+
+        // Ranking / Matches-Me / insight raw material. Privacy rule: skip
+        // events that are evidence for records now marked Rejected, Private,
+        // or NoTrain.
+        let excluded_event_ids: HashSet<String> = self
+            .record_cache
+            .values()
+            .filter(|record| {
+                matches!(
+                    record.promotion_state,
+                    PromotionState::Rejected | PromotionState::Private | PromotionState::NoTrain
+                )
+            })
+            .flat_map(|record| {
+                record
+                    .evidence_refs
+                    .iter()
+                    .map(|evidence| evidence.event_id.clone())
+            })
+            .collect();
+        let feedback_event_lines = self
+            .list_session_traces()?
+            .into_iter()
+            .flat_map(|trace| {
+                let session_id = trace.session_id.clone();
+                let trace_id = trace.id.clone();
+                trace
+                    .events
+                    .into_iter()
+                    .filter(|event| {
+                        matches!(
+                            event.event_type,
+                            TraceEventType::FeedbackRecorded
+                                | TraceEventType::RankingRecorded
+                                | TraceEventType::InsightCaptured
+                        ) && !excluded_event_ids.contains(&event.id)
+                    })
+                    .map(move |event| {
+                        serde_json::to_string(&serde_json::json!({
+                            "session_id": session_id,
+                            "trace_id": trace_id,
+                            "event": event,
+                        }))
+                        .map_err(anyhow::Error::from)
+                    })
+                    .collect::<Vec<_>>()
+            })
+            .collect::<Result<Vec<_>>>()?;
+        self.write_jsonl_file(&feedback_events_path, &feedback_event_lines)?;
+
         let manifest = serde_json::json!({
+            "bundle_schema_version": 2,
             "generated_at": Utc::now(),
             "root_path": self.root_path.display().to_string(),
             "eval_percentage": eval_percentage,
@@ -1874,6 +2179,14 @@ impl TwinStore {
                     "path": action_gaps_path.display().to_string(),
                     "count": action_gap_lines.len(),
                 },
+                "decision_episodes": {
+                    "path": decision_episodes_path.display().to_string(),
+                    "count": decision_episode_lines.len(),
+                },
+                "feedback_events": {
+                    "path": feedback_events_path.display().to_string(),
+                    "count": feedback_event_lines.len(),
+                },
             },
             "excluded_counts": {
                 "private_or_no_train": private_or_no_train_record_ids.len(),
@@ -1907,6 +2220,14 @@ impl TwinStore {
                 path: action_gaps_path.display().to_string(),
                 count: action_gap_lines.len(),
             },
+            decision_episodes: ExportFileSummary {
+                path: decision_episodes_path.display().to_string(),
+                count: decision_episode_lines.len(),
+            },
+            feedback_events: ExportFileSummary {
+                path: feedback_events_path.display().to_string(),
+                count: feedback_event_lines.len(),
+            },
             train: ExportFileSummary {
                 path: train_path.display().to_string(),
                 count: train_lines.len(),
@@ -3680,6 +4001,199 @@ fn twin_record_relevance(record: &UserRecord, query_terms: &HashSet<String>) ->
     query_terms.intersection(&record_terms).count()
 }
 
+const PREDICTION_OPTION_MAX_CHARS: usize = 500;
+const PREDICTION_RATIONALE_MAX_CHARS: usize = 2000;
+
+/// Normalize an option string for comparison: trim, strip wrapping quotes,
+/// lowercase, collapse whitespace. Label forms ("Option 2", "B") are handled
+/// separately by `match_option_index` so meaningful digits survive.
+pub fn normalize_option(text: &str) -> String {
+    text.trim()
+        .trim_matches(|c: char| c == '"' || c == '\'' || c == '`')
+        .to_lowercase()
+        .split_whitespace()
+        .collect::<Vec<_>>()
+        .join(" ")
+}
+
+fn truncate_chars(text: &str, max_chars: usize) -> String {
+    if text.chars().count() <= max_chars {
+        text.to_string()
+    } else {
+        text.chars().take(max_chars).collect()
+    }
+}
+
+fn match_option_index(text: &str, options: &[String]) -> Option<usize> {
+    let normalized = normalize_option(text);
+    if normalized.is_empty() {
+        return None;
+    }
+
+    // Label forms: "option 2" / "choice b" / bare "2" / bare "b".
+    let label = ["option", "choice"]
+        .iter()
+        .find_map(|prefix| normalized.strip_prefix(prefix))
+        .map(str::trim)
+        .unwrap_or(&normalized)
+        .trim_matches(|c: char| c == '.' || c == ')' || c == ':' || c.is_whitespace());
+    if label.len() == 1 {
+        if let Some(letter) = label.chars().next() {
+            if letter.is_ascii_lowercase() {
+                let index = (letter as usize) - ('a' as usize);
+                if index < options.len() {
+                    return Some(index);
+                }
+            }
+        }
+    }
+    // Bare number labels: humans count from 1.
+    if let Ok(number) = label.parse::<usize>() {
+        if (1..=options.len()).contains(&number) {
+            return Some(number - 1);
+        }
+    }
+
+    options
+        .iter()
+        .position(|option| normalize_option(option) == normalized)
+}
+
+fn sanitize_confidence(raw: Option<f64>) -> Option<f32> {
+    let value = raw?;
+    if !value.is_finite() {
+        return None;
+    }
+    let value = if value > 2.0 && value <= 100.0 {
+        // Percent-style answer ("73" meaning 73%).
+        value / 100.0
+    } else {
+        // Near-misses like 1.2 are over-confident, not percentages.
+        value
+    };
+    Some(value.clamp(0.0, 1.0) as f32)
+}
+
+/// Parse the raw model output of a sealed-prediction call into a draft.
+/// Fallback chain: fenced/embedded strict JSON -> normalized string match
+/// against `options` -> raw text (manual adjudication later).
+pub fn parse_twin_prediction(raw: &str, options: &[String]) -> TwinPredictionDraft {
+    #[derive(serde::Deserialize)]
+    struct ParsedPrediction {
+        predicted_option: Option<String>,
+        option_index: Option<Value>,
+        confidence: Option<f64>,
+        rationale: Option<String>,
+    }
+
+    let json_slice = raw
+        .find('{')
+        .and_then(|start| raw.rfind('}').map(|end| &raw[start..=end]));
+
+    if let Some(slice) = json_slice {
+        if let Ok(parsed) = serde_json::from_str::<ParsedPrediction>(slice) {
+            let text = parsed.predicted_option.unwrap_or_default();
+            let text_index = match_option_index(&text, options);
+            let field_index = parsed.option_index.as_ref().and_then(|value| match value {
+                Value::Number(number) => number.as_u64().map(|n| n as usize),
+                Value::String(text) => text.trim().parse::<usize>().ok(),
+                _ => None,
+            });
+            // The prompt displays a 1-based option list, so prefer the
+            // 1-based reading; tolerate 0-based answers, and let the option
+            // text disambiguate when both readings are valid.
+            let field_index = field_index.and_then(|index| {
+                let one_based = index.checked_sub(1).filter(|i| *i < options.len());
+                let zero_based = Some(index).filter(|i| *i < options.len());
+                match (one_based, zero_based) {
+                    (Some(ob), Some(zb)) => match text_index {
+                        Some(text_idx) if text_idx == zb => Some(zb),
+                        _ => Some(ob),
+                    },
+                    (Some(ob), None) => Some(ob),
+                    (None, Some(zb)) => Some(zb),
+                    (None, None) => None,
+                }
+            });
+            // The option text is what the model actually said; a conflicting
+            // numeric index loses.
+            let matched_option_index = match (text_index, field_index) {
+                (Some(text_idx), _) => Some(text_idx),
+                (None, Some(field_idx)) if text.is_empty() => Some(field_idx),
+                _ => None,
+            };
+            let predicted_option = if text.is_empty() {
+                matched_option_index
+                    .map(|index| options[index].clone())
+                    .unwrap_or_else(|| truncate_chars(raw.trim(), PREDICTION_OPTION_MAX_CHARS))
+            } else {
+                truncate_chars(&text, PREDICTION_OPTION_MAX_CHARS)
+            };
+            return TwinPredictionDraft {
+                predicted_option,
+                matched_option_index,
+                confidence: sanitize_confidence(parsed.confidence),
+                rationale: parsed
+                    .rationale
+                    .map(|text| truncate_chars(&text, PREDICTION_RATIONALE_MAX_CHARS)),
+                parse_mode: "json".to_string(),
+            };
+        }
+    }
+
+    if let Some(index) = match_option_index(raw, options) {
+        return TwinPredictionDraft {
+            predicted_option: options[index].clone(),
+            matched_option_index: Some(index),
+            confidence: None,
+            rationale: None,
+            parse_mode: "string_match".to_string(),
+        };
+    }
+
+    TwinPredictionDraft {
+        predicted_option: truncate_chars(raw.trim(), PREDICTION_OPTION_MAX_CHARS),
+        matched_option_index: None,
+        confidence: None,
+        rationale: None,
+        parse_mode: "raw".to_string(),
+    }
+}
+
+fn compute_agreement(prediction: &TwinPrediction, chosen: &str, options: &[String]) -> bool {
+    let chosen_index = match_option_index(chosen, options);
+    match (prediction.matched_option_index, chosen_index) {
+        (Some(predicted), Some(chosen)) => predicted == chosen,
+        _ => normalize_option(&prediction.predicted_option) == normalize_option(chosen),
+    }
+}
+
+fn decision_case_relevance(episode: &DecisionEpisode, query_terms: &HashSet<String>) -> usize {
+    if query_terms.is_empty() {
+        return 0;
+    }
+
+    let mut haystack = episode.decision.clone();
+    haystack.push(' ');
+    haystack.push_str(&episode.options.join(" "));
+    for text in [
+        episode.chosen_option.as_deref(),
+        episode.initial_leaning.as_deref(),
+        episode.lesson.as_deref(),
+        episode.outcome.as_deref(),
+        episode.correction_note.as_deref(),
+    ]
+    .into_iter()
+    .flatten()
+    {
+        haystack.push(' ');
+        haystack.push_str(text);
+    }
+
+    let episode_terms = lexical_terms(&haystack);
+    query_terms.intersection(&episode_terms).count()
+}
+
 fn lexical_terms(text: &str) -> HashSet<String> {
     const STOPWORDS: &[&str] = &[
         "a", "an", "and", "are", "as", "at", "be", "by", "can", "do", "for", "from", "how", "i",
@@ -4072,6 +4586,7 @@ mod tests {
                     action_gap_risk: None,
                     outcome_feedback: None,
                 },
+                context_version: None,
             })
             .expect("decision episode should persist");
 
@@ -5146,4 +5661,629 @@ mod tests {
         assert_eq!(trace.events[0].id, event.id);
         assert_eq!(trace.events[0].event_type, TraceEventType::PromptSubmitted);
     }
+
+    #[test]
+    fn decision_episode_old_json_loads_with_default_prediction_fields() {
+        let temp_dir = tempdir().expect("temp dir should be created");
+        let store = TwinStore::new(temp_dir.path().to_path_buf());
+
+        let old_json = r#"{
+            "id": "legacy-episode",
+            "session_id": "session-1",
+            "tile_id": "tile-1",
+            "decision": "Ship now or wait?",
+            "options": ["Ship now", "Wait"],
+            "chosen_option": "Ship now",
+            "created_at": "2026-01-01T00:00:00Z",
+            "updated_at": "2026-01-01T00:00:00Z"
+        }"#;
+        std::fs::create_dir_all(&store.decisions_path).expect("decisions dir");
+        std::fs::write(store.decisions_path.join("legacy-episode.json"), old_json)
+            .expect("legacy episode should write");
+
+        let episodes = store
+            .list_decision_episodes()
+            .expect("legacy episode should deserialize");
+        assert_eq!(episodes.len(), 1);
+        let episode = &episodes[0];
+        assert!(episode.twin_prediction.is_none());
+        assert!(episode.prediction_status.is_none());
+        assert!(episode.agreement.is_none());
+        assert!(episode.correction_note.is_none());
+        assert!(episode.context_version.is_none());
+        assert!(episode.outcome_recorded_at.is_none());
+    }
+
+    #[test]
+    fn sealed_prediction_redacted_from_reflections_until_outcome() {
+        let temp_dir = tempdir().expect("temp dir should be created");
+        let mut store = TwinStore::new(temp_dir.path().to_path_buf());
+
+        let episode = store
+            .record_decision_episode(DecisionEpisodeCreate {
+                id: "decision-sealed".to_string(),
+                session_id: "session-1".to_string(),
+                tile_id: "tile-1".to_string(),
+                decision: "Take the Denver job?".to_string(),
+                options: vec!["Take it".to_string(), "Stay".to_string()],
+                stakes: None,
+                initial_leaning: None,
+                review_date: None,
+                primitive_assessment: PrimitiveDecisionAssessment::default(),
+                context_version: Some("ctx-test".to_string()),
+            })
+            .expect("decision episode should persist");
+        assert_eq!(episode.prediction_status.as_deref(), Some("requested"));
+
+        let mut sealed = episode.clone();
+        sealed.twin_prediction = Some(TwinPrediction {
+            predicted_option: "Stay".to_string(),
+            matched_option_index: Some(1),
+            confidence: Some(0.7),
+            rationale: Some("Family proximity outweighs salary here.".to_string()),
+            parse_mode: "json".to_string(),
+            model_id: "test/model".to_string(),
+            context_version: "ctx-test".to_string(),
+            sealed_at: Utc::now(),
+        });
+        sealed.prediction_status = Some("sealed".to_string());
+        store
+            .write_decision_file(&sealed)
+            .expect("sealed episode should write");
+
+        let listed = store
+            .list_decision_episodes_with_reflections()
+            .expect("episodes should list");
+        let item = listed
+            .iter()
+            .find(|item| item.episode.id == "decision-sealed")
+            .expect("episode should be listed");
+        assert!(item.prediction_sealed);
+        assert!(item.episode.twin_prediction.is_none());
+
+        store
+            .update_decision_outcome(
+                "decision-sealed",
+                DecisionOutcomeUpdate {
+                    chosen_option: Some("Stay".to_string()),
+                    ..DecisionOutcomeUpdate::default()
+                },
+            )
+            .expect("outcome should record");
+
+        let listed = store
+            .list_decision_episodes_with_reflections()
+            .expect("episodes should list after outcome");
+        let item = listed
+            .iter()
+            .find(|item| item.episode.id == "decision-sealed")
+            .expect("episode should be listed after outcome");
+        assert!(!item.prediction_sealed);
+        let prediction = item
+            .episode
+            .twin_prediction
+            .as_ref()
+            .expect("prediction should be revealed after outcome");
+        assert_eq!(prediction.predicted_option, "Stay");
+    }
+
+    fn endorsed_record(store: &mut TwinStore, content: &str, confidence: f32) -> UserRecord {
+        store
+            .create_user_record(UserRecordCreate {
+                kind: UserRecordKind::Preference,
+                content: content.to_string(),
+                origin: RecordOrigin::User,
+                evidence_refs: Vec::new(),
+                confidence,
+                promotion_state: Some(PromotionState::Endorsed),
+                valid_from: None,
+                valid_until: None,
+                links: Vec::new(),
+                metadata: HashMap::new(),
+            })
+            .expect("record should be created")
+    }
+
+    fn decided_episode(
+        store: &mut TwinStore,
+        id: &str,
+        decision: &str,
+        chosen: &str,
+        correction_note: Option<&str>,
+    ) -> DecisionEpisode {
+        let episode = store
+            .record_decision_episode(DecisionEpisodeCreate {
+                id: id.to_string(),
+                session_id: "session-1".to_string(),
+                tile_id: format!("tile-{id}"),
+                decision: decision.to_string(),
+                options: vec!["Option A".to_string(), "Option B".to_string()],
+                stakes: None,
+                initial_leaning: None,
+                review_date: None,
+                primitive_assessment: PrimitiveDecisionAssessment::default(),
+                context_version: None,
+            })
+            .expect("episode should persist");
+        let mut decided = episode.clone();
+        decided.chosen_option = Some(chosen.to_string());
+        decided.correction_note = correction_note.map(|note| note.to_string());
+        store
+            .write_decision_file(&decided)
+            .expect("decided episode should write");
+        decided
+    }
+
+    #[test]
+    fn approved_records_are_relevance_gated_with_confidence_fallback() {
+        let temp_dir = tempdir().expect("temp dir should be created");
+        let mut store = TwinStore::new(temp_dir.path().to_path_buf());
+
+        endorsed_record(
+            &mut store,
+            "Prefers remote work over relocation for salary",
+            0.6,
+        );
+        endorsed_record(&mut store, "Enjoys woodworking podcasts on weekends", 0.9);
+
+        let (approved, _) = store
+            .select_context_records("Should I accept the relocation offer for more salary?")
+            .expect("selection should succeed");
+        assert_eq!(approved.len(), 1);
+        assert!(approved[0].content.contains("relocation"));
+
+        // No keyword overlap at all: fall back to top-confidence records
+        // instead of an empty behavioral context.
+        let (fallback, _) = store
+            .select_context_records("zzz qqq xyzzy")
+            .expect("fallback selection should succeed");
+        assert!(!fallback.is_empty());
+        assert!(fallback.len() <= MAX_TWIN_APPROVED_FALLBACK_RECORDS);
+        assert!(fallback[0].content.contains("woodworking"));
+    }
+
+    #[test]
+    fn decision_cases_rank_relevance_above_correction_notes() {
+        let temp_dir = tempdir().expect("temp dir should be created");
+        let mut store = TwinStore::new(temp_dir.path().to_path_buf());
+
+        decided_episode(
+            &mut store,
+            "case-relevant",
+            "Accept the Denver relocation offer with higher salary?",
+            "Option B",
+            None,
+        );
+        decided_episode(
+            &mut store,
+            "case-correction",
+            "Buy the relocation boxes early?",
+            "Option A",
+            Some("Twin guessed wrong here"),
+        );
+        // Undecided episode must never appear as a case.
+        store
+            .record_decision_episode(DecisionEpisodeCreate {
+                id: "case-undecided".to_string(),
+                session_id: "session-1".to_string(),
+                tile_id: "tile-undecided".to_string(),
+                decision: "Relocation salary salary salary?".to_string(),
+                options: vec!["A".to_string(), "B".to_string()],
+                stakes: None,
+                initial_leaning: None,
+                review_date: None,
+                primitive_assessment: PrimitiveDecisionAssessment::default(),
+                context_version: None,
+            })
+            .expect("undecided episode should persist");
+
+        let cases = store
+            .select_decision_cases("Denver relocation salary decision", None, 5)
+            .expect("cases should select");
+        assert_eq!(cases.len(), 2);
+        // The strongly relevant case outranks the weakly relevant one even
+        // though the weak one carries a correction note.
+        assert_eq!(cases[0].id, "case-relevant");
+        assert_eq!(cases[1].id, "case-correction");
+        assert!(cases.iter().all(|case| case.id != "case-undecided"));
+
+        let excluded = store
+            .select_decision_cases(
+                "Denver relocation salary decision",
+                Some("case-relevant"),
+                5,
+            )
+            .expect("exclusion should apply");
+        assert!(excluded.iter().all(|case| case.id != "case-relevant"));
+
+        // Zero overlap: most recent decided cases, capped at two.
+        let recent = store
+            .select_decision_cases("zzz qqq xyzzy", None, 5)
+            .expect("fallback should select");
+        assert!(!recent.is_empty());
+        assert!(recent.len() <= 2);
+        assert!(recent.iter().all(|case| case.chosen_option.is_some()));
+    }
+
+    fn prediction_options() -> Vec<String> {
+        vec![
+            "Take the Denver job".to_string(),
+            "Stay in Austin".to_string(),
+        ]
+    }
+
+    #[test]
+    fn parse_twin_prediction_strict_json() {
+        let raw = r#"{"predicted_option": "Stay in Austin", "option_index": 2, "confidence": 0.8, "rationale": "Family proximity wins."}"#;
+        let draft = parse_twin_prediction(raw, &prediction_options());
+        assert_eq!(draft.parse_mode, "json");
+        assert_eq!(draft.matched_option_index, Some(1));
+        assert_eq!(draft.predicted_option, "Stay in Austin");
+        assert_eq!(draft.confidence, Some(0.8));
+        assert_eq!(draft.rationale.as_deref(), Some("Family proximity wins."));
+    }
+
+    #[test]
+    fn parse_twin_prediction_fenced_json_with_language_tag() {
+        let raw = "```json\n{\"predicted_option\": \"Take the Denver job\", \"option_index\": 1, \"confidence\": 0.6, \"rationale\": \"Growth.\"}\n```";
+        let draft = parse_twin_prediction(raw, &prediction_options());
+        assert_eq!(draft.parse_mode, "json");
+        assert_eq!(draft.matched_option_index, Some(0));
+    }
+
+    #[test]
+    fn parse_twin_prediction_index_as_string_and_one_based() {
+        let raw = r#"{"option_index": "1", "confidence": 0.5}"#;
+        let draft = parse_twin_prediction(raw, &prediction_options());
+        // 1-based reading preferred: "1" means the first listed option.
+        assert_eq!(draft.matched_option_index, Some(0));
+        assert_eq!(draft.predicted_option, "Take the Denver job");
+    }
+
+    #[test]
+    fn parse_twin_prediction_text_beats_conflicting_index() {
+        let raw = r#"{"predicted_option": "Stay in Austin", "option_index": 1, "confidence": 0.9}"#;
+        let draft = parse_twin_prediction(raw, &prediction_options());
+        // The option text is what the model said; the conflicting index loses.
+        assert_eq!(draft.matched_option_index, Some(1));
+    }
+
+    #[test]
+    fn parse_twin_prediction_out_of_range_index_with_valid_text() {
+        let raw = r#"{"predicted_option": "Stay in Austin", "option_index": 9}"#;
+        let draft = parse_twin_prediction(raw, &prediction_options());
+        assert_eq!(draft.matched_option_index, Some(1));
+    }
+
+    #[test]
+    fn parse_twin_prediction_bare_text_and_labels() {
+        let options = prediction_options();
+        let bare = parse_twin_prediction("  Stay in Austin\n", &options);
+        assert_eq!(bare.parse_mode, "string_match");
+        assert_eq!(bare.matched_option_index, Some(1));
+
+        let letter = parse_twin_prediction("B", &options);
+        assert_eq!(letter.matched_option_index, Some(1));
+
+        let labeled = parse_twin_prediction("Option 2", &options);
+        assert_eq!(labeled.matched_option_index, Some(1));
+    }
+
+    #[test]
+    fn parse_twin_prediction_garbage_falls_to_raw() {
+        let long_garbage = "I think there are many considerations here ".repeat(40);
+        let draft = parse_twin_prediction(&long_garbage, &prediction_options());
+        assert_eq!(draft.parse_mode, "raw");
+        assert!(draft.matched_option_index.is_none());
+        assert!(draft.predicted_option.chars().count() <= 500);
+    }
+
+    #[test]
+    fn parse_twin_prediction_sanitizes_confidence() {
+        let options = prediction_options();
+        let percent = parse_twin_prediction(
+            r#"{"predicted_option": "Stay in Austin", "confidence": 73}"#,
+            &options,
+        );
+        assert_eq!(percent.confidence, Some(0.73));
+
+        let overshoot = parse_twin_prediction(
+            r#"{"predicted_option": "Stay in Austin", "confidence": 1.2}"#,
+            &options,
+        );
+        assert_eq!(overshoot.confidence, Some(1.0));
+
+        let negative = parse_twin_prediction(
+            r#"{"predicted_option": "Stay in Austin", "confidence": -0.1}"#,
+            &options,
+        );
+        assert_eq!(negative.confidence, Some(0.0));
+
+        let null = parse_twin_prediction(
+            r#"{"predicted_option": "Stay in Austin", "confidence": null}"#,
+            &options,
+        );
+        assert!(null.confidence.is_none());
+    }
+
+    #[test]
+    fn attach_twin_prediction_refuses_after_outcome_and_duplicates() {
+        let temp_dir = tempdir().expect("temp dir should be created");
+        let mut store = TwinStore::new(temp_dir.path().to_path_buf());
+
+        let episode = store
+            .record_decision_episode(DecisionEpisodeCreate {
+                id: "decision-attach".to_string(),
+                session_id: "session-1".to_string(),
+                tile_id: "tile-1".to_string(),
+                decision: "Take the Denver job?".to_string(),
+                options: prediction_options(),
+                stakes: None,
+                initial_leaning: None,
+                review_date: None,
+                primitive_assessment: PrimitiveDecisionAssessment::default(),
+                context_version: Some("ctx-test".to_string()),
+            })
+            .expect("episode should persist");
+
+        let draft = parse_twin_prediction("Stay in Austin", &prediction_options());
+        let sealed = store
+            .attach_twin_prediction(&episode.id, draft.clone(), "test/model", "ctx-test")
+            .expect("first attach should seal");
+        assert_eq!(sealed.prediction_status.as_deref(), Some("sealed"));
+        let first_sealed_at = sealed.twin_prediction.as_ref().unwrap().sealed_at;
+
+        // Duplicate attach is a no-op.
+        let duplicate = store
+            .attach_twin_prediction(&episode.id, draft.clone(), "other/model", "ctx-test")
+            .expect("duplicate attach should not error");
+        assert_eq!(
+            duplicate.twin_prediction.as_ref().unwrap().sealed_at,
+            first_sealed_at
+        );
+        assert_eq!(
+            duplicate.twin_prediction.as_ref().unwrap().model_id,
+            "test/model"
+        );
+
+        // Outcome-first race: attach after the choice is recorded.
+        let late_episode = store
+            .record_decision_episode(DecisionEpisodeCreate {
+                id: "decision-late".to_string(),
+                session_id: "session-1".to_string(),
+                tile_id: "tile-2".to_string(),
+                decision: "Take the Denver job?".to_string(),
+                options: prediction_options(),
+                stakes: None,
+                initial_leaning: None,
+                review_date: None,
+                primitive_assessment: PrimitiveDecisionAssessment::default(),
+                context_version: None,
+            })
+            .expect("episode should persist");
+        store
+            .update_decision_outcome(
+                &late_episode.id,
+                DecisionOutcomeUpdate {
+                    chosen_option: Some("Stay in Austin".to_string()),
+                    ..DecisionOutcomeUpdate::default()
+                },
+            )
+            .expect("outcome should record");
+        let refused = store
+            .attach_twin_prediction(&late_episode.id, draft, "test/model", "ctx-test")
+            .expect("late attach should not error");
+        assert!(refused.twin_prediction.is_none());
+        assert_eq!(
+            refused.prediction_status.as_deref(),
+            Some("outcome_recorded_first")
+        );
+    }
+
+    #[test]
+    fn outcome_computes_agreement_and_canonicalizes_choice() {
+        let temp_dir = tempdir().expect("temp dir should be created");
+        let mut store = TwinStore::new(temp_dir.path().to_path_buf());
+
+        let episode = store
+            .record_decision_episode(DecisionEpisodeCreate {
+                id: "decision-agree".to_string(),
+                session_id: "session-1".to_string(),
+                tile_id: "tile-1".to_string(),
+                decision: "Take the Denver job?".to_string(),
+                options: prediction_options(),
+                stakes: None,
+                initial_leaning: None,
+                review_date: None,
+                primitive_assessment: PrimitiveDecisionAssessment::default(),
+                context_version: Some("ctx-test".to_string()),
+            })
+            .expect("episode should persist");
+        let draft = parse_twin_prediction("Stay in Austin", &prediction_options());
+        store
+            .attach_twin_prediction(&episode.id, draft, "test/model", "ctx-test")
+            .expect("prediction should seal");
+
+        // Label + case variant resolves to the canonical option text and
+        // agreement computes via index comparison.
+        let updated = store
+            .update_decision_outcome(
+                &episode.id,
+                DecisionOutcomeUpdate {
+                    chosen_option: Some("option 2".to_string()),
+                    correction_note: None,
+                    ..DecisionOutcomeUpdate::default()
+                },
+            )
+            .expect("outcome should record");
+        assert_eq!(updated.chosen_option.as_deref(), Some("Stay in Austin"));
+        assert_eq!(updated.agreement, Some(true));
+        assert!(updated.outcome_recorded_at.is_some());
+
+        // Editing the choice recomputes agreement and accepts a correction
+        // note; outcome_recorded_at is not reset.
+        let first_recorded_at = updated.outcome_recorded_at;
+        let edited = store
+            .update_decision_outcome(
+                &episode.id,
+                DecisionOutcomeUpdate {
+                    chosen_option: Some("  TAKE the denver JOB ".to_string()),
+                    correction_note: Some("Twin overweighted family proximity.".to_string()),
+                    ..DecisionOutcomeUpdate::default()
+                },
+            )
+            .expect("edited outcome should record");
+        assert_eq!(edited.chosen_option.as_deref(), Some("Take the Denver job"));
+        assert_eq!(edited.agreement, Some(false));
+        assert_eq!(
+            edited.correction_note.as_deref(),
+            Some("Twin overweighted family proximity.")
+        );
+        assert_eq!(edited.outcome_recorded_at, first_recorded_at);
+    }
+
+    #[test]
+    fn outcome_without_prediction_records_no_agreement_and_keeps_free_text() {
+        let temp_dir = tempdir().expect("temp dir should be created");
+        let mut store = TwinStore::new(temp_dir.path().to_path_buf());
+
+        let episode = store
+            .record_decision_episode(DecisionEpisodeCreate {
+                id: "decision-free".to_string(),
+                session_id: "session-1".to_string(),
+                tile_id: "tile-1".to_string(),
+                decision: "Take the Denver job?".to_string(),
+                options: prediction_options(),
+                stakes: None,
+                initial_leaning: None,
+                review_date: None,
+                primitive_assessment: PrimitiveDecisionAssessment::default(),
+                context_version: None,
+            })
+            .expect("episode should persist");
+
+        let updated = store
+            .update_decision_outcome(
+                &episode.id,
+                DecisionOutcomeUpdate {
+                    chosen_option: Some("Negotiated a remote arrangement instead".to_string()),
+                    ..DecisionOutcomeUpdate::default()
+                },
+            )
+            .expect("outcome should record");
+        // Free text that matches no option is preserved verbatim.
+        assert_eq!(
+            updated.chosen_option.as_deref(),
+            Some("Negotiated a remote arrangement instead")
+        );
+        assert!(updated.agreement.is_none());
+    }
+
+    #[test]
+    fn export_redacts_sealed_predictions_and_filters_private_feedback_events() {
+        let temp_dir = tempdir().expect("temp dir should be created");
+        let mut store = TwinStore::new(temp_dir.path().to_path_buf());
+
+        for (id, record_outcome) in [("episode-sealed", false), ("episode-revealed", true)] {
+            store
+                .record_decision_episode(DecisionEpisodeCreate {
+                    id: id.to_string(),
+                    session_id: "session-1".to_string(),
+                    tile_id: format!("tile-{id}"),
+                    decision: "Take the Denver job?".to_string(),
+                    options: prediction_options(),
+                    stakes: None,
+                    initial_leaning: None,
+                    review_date: None,
+                    primitive_assessment: PrimitiveDecisionAssessment::default(),
+                    context_version: Some("ctx-test".to_string()),
+                })
+                .expect("episode should persist");
+            let draft = parse_twin_prediction("Stay in Austin", &prediction_options());
+            store
+                .attach_twin_prediction(id, draft, "test/model", "ctx-test")
+                .expect("prediction should seal");
+            if record_outcome {
+                store
+                    .update_decision_outcome(
+                        id,
+                        DecisionOutcomeUpdate {
+                            chosen_option: Some("Stay in Austin".to_string()),
+                            ..DecisionOutcomeUpdate::default()
+                        },
+                    )
+                    .expect("outcome should record");
+            }
+        }
+
+        // One feedback event tied to a record later marked Private, one free.
+        let private_event = store
+            .append_trace_event(
+                "session-1",
+                TraceEventType::FeedbackRecorded,
+                json!({"rationale": "extremely sensitive rationale"}),
+            )
+            .expect("event should append");
+        let exportable_event = store
+            .append_trace_event(
+                "session-1",
+                TraceEventType::RankingRecorded,
+                json!({"ranking": ["a", "b"]}),
+            )
+            .expect("event should append");
+        store
+            .create_user_record(UserRecordCreate {
+                kind: UserRecordKind::Preference,
+                content: "Private claim".to_string(),
+                origin: RecordOrigin::User,
+                evidence_refs: vec![EvidenceRef {
+                    trace_id: "session-1".to_string(),
+                    event_id: private_event.id.clone(),
+                    session_id: "session-1".to_string(),
+                    tile_id: None,
+                    model_id: None,
+                    note: None,
+                    source_type: None,
+                    source_id: None,
+                    source_label: None,
+                    excerpt: None,
+                    speaker_role: None,
+                }],
+                confidence: default_record_confidence(),
+                promotion_state: Some(PromotionState::Private),
+                valid_from: None,
+                valid_until: None,
+                links: Vec::new(),
+                metadata: HashMap::new(),
+            })
+            .expect("private record should be created");
+
+        let bundle = store
+            .export_bundle(TwinExportRequest::default())
+            .expect("export should succeed");
+        assert_eq!(bundle.decision_episodes.count, 2);
+
+        let episodes_content = std::fs::read_to_string(&bundle.decision_episodes.path)
+            .expect("decision episodes file should read");
+        let sealed_line = episodes_content
+            .lines()
+            .find(|line| line.contains("episode-sealed"))
+            .expect("sealed episode should export");
+        assert!(sealed_line.contains("\"sealed\":true"));
+        assert!(!sealed_line.contains("predicted_option"));
+        assert!(!sealed_line.contains("rationale"));
+        let revealed_line = episodes_content
+            .lines()
+            .find(|line| line.contains("episode-revealed"))
+            .expect("revealed episode should export");
+        assert!(revealed_line.contains("predicted_option"));
+        assert!(revealed_line.contains("\"agreement\":true"));
+        assert!(revealed_line.contains("ctx-test"));
+
+        let feedback_content = std::fs::read_to_string(&bundle.feedback_events.path)
+            .expect("feedback events file should read");
+        assert!(!feedback_content.contains("extremely sensitive rationale"));
+        assert!(!feedback_content.contains(&private_event.id));
+        assert!(feedback_content.contains(&exportable_event.id));
+    }
 }
diff --git a/frontend/src/__tests__/unit/components/TwinReviewDecisions.spec.js b/frontend/src/__tests__/unit/components/TwinReviewDecisions.spec.js
new file mode 100644
index 0000000..373fcfa
--- /dev/null
+++ b/frontend/src/__tests__/unit/components/TwinReviewDecisions.spec.js
@@ -0,0 +1,179 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest'
+import { mount, flushPromises } from '@vue/test-utils'
+
+vi.mock('vue-router', () => ({
+  useRoute: () => ({ query: {} })
+}))
+
+vi.mock('@/api/client', () => ({
+  twin: {
+    getReview: vi.fn().mockResolvedValue([]),
+    listMemoryDigest: vi.fn().mockResolvedValue([]),
+    listConstitutionItems: vi.fn().mockResolvedValue([]),
+    listActionGaps: vi.fn().mockResolvedValue([]),
+    listDecisionEpisodes: vi.fn().mockResolvedValue([]),
+    getConstitutionSetup: vi.fn().mockResolvedValue({}),
+    getDecisionMirrorConfig: vi.fn().mockResolvedValue({
+      preset: 'balanced',
+      advanced_enabled: false,
+      weights: {}
+    }),
+    updateDecisionOutcome: vi.fn().mockResolvedValue({})
+  }
+}))
+
+import TwinReviewView from '@/views/TwinReviewView.vue'
+import { twin } from '@/api/client'
+
+function decisionItem(overrides = {}, episodeOverrides = {}) {
+  return {
+    episode: {
+      id: 'episode-1',
+      session_id: 'session-1',
+      tile_id: 'tile-1',
+      decision: 'Ship the importer before polish?',
+      options: ['Ship now', 'Wait a sprint'],
+      chosen_option: null,
+      twin_prediction: null,
+      agreement: null,
+      correction_note: null,
+      primitive_assessment: {},
+      reflection_cards: [],
+      ...episodeOverrides
+    },
+    reflection_cards: [],
+    feedback_events: [],
+    prediction_sealed: false,
+    ...overrides
+  }
+}
+
+async function mountWithDecisions(items) {
+  twin.listDecisionEpisodes.mockResolvedValue(items)
+  const wrapper = mount(TwinReviewView)
+  await flushPromises()
+  return wrapper
+}
+
+describe('TwinReviewView decision predictions', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    twin.getReview.mockResolvedValue([])
+    twin.listMemoryDigest.mockResolvedValue([])
+    twin.listConstitutionItems.mockResolvedValue([])
+    twin.listActionGaps.mockResolvedValue([])
+    twin.getConstitutionSetup.mockResolvedValue({})
+    twin.getDecisionMirrorConfig.mockResolvedValue({
+      preset: 'balanced',
+      advanced_enabled: false,
+      weights: {}
+    })
+    twin.updateDecisionOutcome.mockResolvedValue({})
+  })
+
+  it('shows the sealed badge and no prediction content before the outcome', async () => {
+    const wrapper = await mountWithDecisions([
+      decisionItem({ prediction_sealed: true })
+    ])
+
+    expect(wrapper.text()).toContain('Twin sealed a prediction')
+    expect(wrapper.text()).not.toContain('Twin predicted')
+    expect(wrapper.find('.prediction-reveal').exists()).toBe(false)
+  })
+
+  it('reveals the prediction with a Missed badge and correction input after a disagreeing outcome', async () => {
+    const wrapper = await mountWithDecisions([
+      decisionItem(
+        { prediction_sealed: false },
+        {
+          chosen_option: 'Wait a sprint',
+          agreement: false,
+          twin_prediction: {
+            predicted_option: 'Ship now',
+            confidence: 0.8,
+            rationale: 'Past launches favored speed.',
+            parse_mode: 'json',
+            model_id: 'test/model',
+            context_version: 'ctx-test',
+            sealed_at: '2026-06-12T00:00:00Z'
+          }
+        }
+      )
+    ])
+
+    expect(wrapper.text()).toContain('Twin predicted')
+    expect(wrapper.text()).toContain('Ship now')
+    expect(wrapper.text()).toContain('80% confident')
+    expect(wrapper.text()).toContain('Missed')
+    expect(wrapper.text()).toContain('Past launches favored speed.')
+    expect(wrapper.find('.correction-row input').exists()).toBe(true)
+  })
+
+  it('shows Matched badge without a correction input on agreement', async () => {
+    const wrapper = await mountWithDecisions([
+      decisionItem(
+        { prediction_sealed: false },
+        {
+          chosen_option: 'Ship now',
+          agreement: true,
+          twin_prediction: {
+            predicted_option: 'Ship now',
+            confidence: 0.6,
+            rationale: null,
+            parse_mode: 'json',
+            model_id: 'test/model',
+            context_version: 'ctx-test',
+            sealed_at: '2026-06-12T00:00:00Z'
+          }
+        }
+      )
+    ])
+
+    expect(wrapper.text()).toContain('Matched my choice')
+    expect(wrapper.find('.correction-row input').exists()).toBe(false)
+  })
+
+  it('includes chosen_option and correction_note in the outcome payload', async () => {
+    const wrapper = await mountWithDecisions([
+      decisionItem(
+        { prediction_sealed: false },
+        {
+          chosen_option: 'Wait a sprint',
+          agreement: false,
+          twin_prediction: {
+            predicted_option: 'Ship now',
+            confidence: null,
+            rationale: null,
+            parse_mode: 'json',
+            model_id: 'test/model',
+            context_version: 'ctx-test',
+            sealed_at: '2026-06-12T00:00:00Z'
+          }
+        }
+      )
+    ])
+
+    await wrapper.find('.chosen-option-select').setValue('Wait a sprint')
+    await wrapper.find('.correction-row input').setValue('Twin overweights speed.')
+    await wrapper.find('.outcome-row button').trigger('click')
+    await flushPromises()
+
+    expect(twin.updateDecisionOutcome).toHaveBeenCalledWith(
+      'episode-1',
+      expect.objectContaining({
+        chosen_option: 'Wait a sprint',
+        correction_note: 'Twin overweights speed.'
+      })
+    )
+  })
+
+  it('keeps legacy episodes without options editable via free text', async () => {
+    const wrapper = await mountWithDecisions([
+      decisionItem({}, { options: [], chosen_option: 'Did something else' })
+    ])
+
+    const freeText = wrapper.find('.outcome-row input[placeholder="Chosen option"]')
+    expect(freeText.exists()).toBe(true)
+    expect(freeText.element.value).toBe('Did something else')
+  })
+})
diff --git a/frontend/src/views/TwinReviewView.vue b/frontend/src/views/TwinReviewView.vue
index cd87c3a..3282cd2 100644
--- a/frontend/src/views/TwinReviewView.vue
+++ b/frontend/src/views/TwinReviewView.vue
@@ -650,13 +650,23 @@ const DecisionRow = defineComponent({
   },
   emits: ['update-outcome'],
   setup(props, { emit }) {
+    const episodeOptions = props.item.episode.options || []
+    const savedChoice = props.item.episode.chosen_option || ''
+    const choiceInList = savedChoice && episodeOptions.includes(savedChoice)
     const outcome = ref(props.item.episode.outcome || '')
     const lesson = ref(props.item.episode.lesson || '')
     const regretScore = ref(props.item.episode.regret_score ?? '')
+    const chosenSelect = ref(choiceInList ? savedChoice : (savedChoice ? '__other__' : ''))
+    const chosenOther = ref(choiceInList ? '' : savedChoice)
+    const correctionNote = ref(props.item.episode.correction_note || '')
+    const resolvedChoice = () =>
+      chosenSelect.value === '__other__' ? chosenOther.value.trim() : chosenSelect.value
     const save = () => emit('update-outcome', props.item.episode.id, {
       outcome: outcome.value || null,
       lesson: lesson.value || null,
-      regret_score: regretScore.value === '' ? null : Number(regretScore.value)
+      regret_score: regretScore.value === '' ? null : Number(regretScore.value),
+      chosen_option: resolvedChoice() || null,
+      correction_note: correctionNote.value.trim() || null
     })
     return () => {
       const latestCard = props.item.reflection_cards?.[0]
@@ -732,7 +742,50 @@ const DecisionRow = defineComponent({
             ])
           ])
         : null,
+      props.item.prediction_sealed
+        ? h('div', { class: 'prediction-sealed-badge' },
+            'Twin sealed a prediction — record your choice to reveal it')
+        : null,
+      props.item.episode.twin_prediction
+        ? h('div', { class: 'prediction-reveal' }, [
+            h('div', { class: 'prediction-headline' }, [
+              h('strong', 'Twin predicted: '),
+              h('span', props.item.episode.twin_prediction.predicted_option),
+              props.item.episode.twin_prediction.confidence != null
+                ? h('span', { class: 'prediction-confidence' },
+                    ` (${Math.round(props.item.episode.twin_prediction.confidence * 100)}% confident)`)
+                : null,
+              props.item.episode.agreement === true
+                ? h('span', { class: 'agreement-badge match' }, 'Matched my choice')
+                : null,
+              props.item.episode.agreement === false
+                ? h('span', { class: 'agreement-badge miss' }, 'Missed')
+                : null
+            ]),
+            props.item.episode.twin_prediction.rationale
+              ? h('p', { class: 'prediction-rationale' }, props.item.episode.twin_prediction.rationale)
+              : null
+          ])
+        : null,
       h('div', { class: 'outcome-row' }, [
+        episodeOptions.length
+          ? h('select', {
+              class: 'chosen-option-select',
+              value: chosenSelect.value,
+              onChange: event => { chosenSelect.value = event.target.value }
+            }, [
+              h('option', { value: '' }, 'Chosen option…'),
+              ...episodeOptions.map(option => h('option', { value: option }, option)),
+              h('option', { value: '__other__' }, 'Other…')
+            ])
+          : null,
+        (!episodeOptions.length || chosenSelect.value === '__other__')
+          ? h('input', {
+              value: chosenOther.value,
+              placeholder: 'Chosen option',
+              onInput: event => { chosenOther.value = event.target.value }
+            })
+          : null,
         h('input', {
           value: outcome.value,
           placeholder: 'Outcome',
@@ -752,7 +805,16 @@ const DecisionRow = defineComponent({
           onInput: event => { regretScore.value = event.target.value }
         }),
         h('button', { onClick: save }, 'Save')
-      ])
+      ]),
+      props.item.episode.agreement === false
+        ? h('div', { class: 'correction-row' }, [
+            h('input', {
+              value: correctionNote.value,
+              placeholder: 'Why was the twin wrong?',
+              onInput: event => { correctionNote.value = event.target.value }
+            })
+          ])
+        : null
     ])
     }
   }
@@ -1545,6 +1607,66 @@ function showMessage(type, text, duration = 3500) {
   margin-top: var(--spacing-sm);
 }
 
+.prediction-sealed-badge {
+  margin-top: var(--spacing-sm);
+  padding: 4px 8px;
+  border: 1px dashed var(--border-subtle);
+  border-radius: var(--radius-sm);
+  color: var(--text-secondary);
+  font-size: 0.8rem;
+}
+
+.prediction-reveal {
+  margin-top: var(--spacing-sm);
+  padding: var(--spacing-sm);
+  border: 1px solid var(--border-subtle);
+  border-radius: var(--radius-sm);
+  background: color-mix(in srgb, var(--bg-tertiary) 75%, transparent);
+}
+
+.prediction-headline {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 6px;
+  font-size: 0.85rem;
+}
+
+.prediction-confidence {
+  color: var(--text-secondary);
+}
+
+.prediction-rationale {
+  margin: 6px 0 0;
+  color: var(--text-secondary);
+  font-size: 0.8rem;
+}
+
+.agreement-badge {
+  padding: 2px 8px;
+  border-radius: 999px;
+  font-size: 0.72rem;
+}
+
+.agreement-badge.match {
+  background: color-mix(in srgb, var(--accent-green, #22c55e) 18%, transparent);
+  color: var(--accent-green, #22c55e);
+}
+
+.agreement-badge.miss {
+  background: color-mix(in srgb, var(--accent-red, #ef4444) 18%, transparent);
+  color: var(--accent-red, #ef4444);
+}
+
+.correction-row {
+  margin-top: 6px;
+}
+
+.correction-row input,
+.chosen-option-select {
+  min-height: 28px;
+}
+
 .review-actions button,
 .record-actions button,
 .outcome-row button {