diff --git a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-stable.json.zst b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-stable.json.zst
index 10d00f3a35..08ebc8e755 100644
Binary files a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-stable.json.zst and b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-stable.json.zst differ
diff --git a/codex-rs/core/src/agent/control/user_authorization.rs b/codex-rs/core/src/agent/control/user_authorization.rs
index 71ae6176d5..cec448fecc 100644
--- a/codex-rs/core/src/agent/control/user_authorization.rs
+++ b/codex-rs/core/src/agent/control/user_authorization.rs
@@ -61,12 +61,6 @@ impl AgentControl {
                 root_history
                     .annotated_items()
                     .iter()
-                    .filter(|envelope| {
-                        !envelope
-                            .metadata
-                            .as_ref()
-                            .is_some_and(|metadata| metadata.inherited_user_message)
-                    })
                     .filter_map(|envelope| {
                         let item = &envelope.item;
                         let Some(TurnItem::UserMessage(message)) = parse_turn_item(item) else {
@@ -81,6 +75,7 @@ impl AgentControl {
                         let order = envelope
                             .metadata
                             .as_ref()
+                            .filter(|metadata| !metadata.inherited_user_message)
                             .and_then(|metadata| metadata.user_input_order);
                         Some((
                             order,
diff --git a/codex-rs/core/src/context_manager/history.rs b/codex-rs/core/src/context_manager/history.rs
index 157c79f12d..ee077e315a 100644
--- a/codex-rs/core/src/context_manager/history.rs
+++ b/codex-rs/core/src/context_manager/history.rs
@@ -4,6 +4,9 @@
 //! Oversized instructions keep an incomplete excerpt for bounded root review, including
 //! sources recovered from legacy Guardian checkpoints before their raw history is dropped.
 
+#[path = "history_user_authorization.rs"]
+mod user_authorization;
+
 use crate::context::ContextualUserFragment;
 use crate::context::ModelSwitchInstructions;
 use crate::context::world_state::PersistentModeState;
@@ -30,6 +33,7 @@ use codex_history::GuardianHistoryCheckpoint;
 use codex_history::ResponseItemEnvelope;
 use codex_history::RetainedContext;
 use codex_history::RetainedContextEvent;
+use codex_history::RetainedInputSource;
 use codex_protocol::items::TurnItem;
 use codex_protocol::models::AgentMessageInputContent;
 use codex_protocol::models::BaseInstructions;
@@ -40,6 +44,7 @@ use codex_protocol::models::ImageDetail;
 use codex_protocol::models::ResponseItem;
 use codex_protocol::openai_models::InputModality;
 use codex_protocol::protocol::InterAgentCommunication;
+use codex_protocol::protocol::SessionSource;
 use codex_protocol::protocol::TokenUsage;
 use codex_protocol::protocol::TokenUsageInfo;
 use codex_protocol::protocol::TurnContextItem;
@@ -71,6 +76,7 @@ pub(crate) struct ContextManager {
     retained_context: Arc<RetainedContext>,
     /// Capture, replay, and snapshot selection share the immutable session mode.
     guardian_context_mode: GuardianContextMode,
+    retain_inherited_user_messages: bool,
     /// Bumped whenever history is rewritten, such as compaction or rollback.
     history_version: u64,
     /// Monotonic user-input/reset revision, independent of compaction's history generation.
@@ -169,6 +175,7 @@ impl ContextManager {
             review_history: None,
             retained_context: Arc::default(),
             guardian_context_mode: GuardianContextMode::Legacy,
+            retain_inherited_user_messages: false,
             history_version: 0,
             user_message_revision: 0,
             token_info: TokenUsageInfo::new_or_append(
@@ -194,9 +201,15 @@ impl ContextManager {
         &self.retained_context
     }
 
-    pub(crate) fn with_guardian_context_mode(guardian_context_mode: GuardianContextMode) -> Self {
+    pub(crate) fn with_guardian_context_mode(
+        guardian_context_mode: GuardianContextMode,
+        source: &SessionSource,
+    ) -> Self {
         Self {
             guardian_context_mode,
+            retain_inherited_user_messages: guardian_context_mode
+                == GuardianContextMode::ThreadOwned
+                && !source.is_non_root_agent(),
             ..Self::new()
         }
     }
@@ -213,10 +226,6 @@ impl ContextManager {
         true
     }
 
-    pub(crate) fn restore_retained_context(&mut self, checkpoint: Option<&RetainedContext>) {
-        Arc::make_mut(&mut self.retained_context).restore(checkpoint, &self.items);
-    }
-
     pub(crate) fn guardian_history_checkpoint(&self) -> Option<GuardianHistoryCheckpoint> {
         if self.guardian_context_mode == GuardianContextMode::ThreadOwned {
             return None;
@@ -369,54 +378,11 @@ impl ContextManager {
                 review_history.record(&processed.item);
             }
             Arc::make_mut(&mut self.items).push(processed);
-            if crate::context::is_user_authorization_message(item) {
-                if self.guardian_context_mode == GuardianContextMode::Legacy {
-                    Arc::make_mut(&mut self.retained_context).mark_user_messages_incomplete();
-                } else if !metadata.is_some_and(|metadata| metadata.inherited_user_message)
-                    && let ResponseItem::Message {
-                        content,
-                        internal_chat_message_metadata_passthrough,
-                        ..
-                    } = item
-                {
-                    let mut complete = internal_chat_message_metadata_passthrough
-                        .as_ref()
-                        .and_then(|metadata| metadata.content_item_kinds.as_ref())
-                        .is_some_and(|kinds| {
-                            kinds.len() == content.len()
-                                && kinds.iter().all(|kind| kind.0.starts_with("user."))
-                        });
-                    let text = content
-                        .iter()
-                        .filter_map(|content| match content {
-                            ContentItem::InputText { text } | ContentItem::OutputText { text } => {
-                                Some(text.as_str())
-                            }
-                            _ => {
-                                complete = false;
-                                None
-                            }
-                        })
-                        .collect::<Vec<_>>()
-                        .join("\n");
-                    // Keep the same bounded text that child reviewers receive before
-                    // compaction, instead of letting storage discard a large source.
-                    // Local instruction sections still omit incomplete originals whole.
-                    let (text, truncated) =
-                        guardian_truncate_text(&text, GUARDIAN_MAX_ROOT_MESSAGE_TOKENS);
-                    complete &= !truncated;
-                    Arc::make_mut(&mut self.retained_context).record_user_message(
-                        codex_history::RetainedUserMessage {
-                            turn_id: item.turn_id().unwrap_or_default().to_owned(),
-                            message_id: item.id().map(|id| id.as_str().to_owned()),
-                            text,
-                            complete,
-                        },
-                        metadata.and_then(|metadata| metadata.user_input_order),
-                    );
-                }
-                self.user_message_revision = self.user_message_revision.saturating_add(1);
-            }
+            self.record_user_authorization(
+                item,
+                metadata,
+                user_authorization::UserMessageSource::Original,
+            );
         }
     }
 
@@ -590,10 +556,7 @@ impl ContextManager {
         let first_removed_message_id = snapshot[cut_idx]
             .id()
             .map(codex_protocol::ResponseItemId::as_str);
-        let acceptance_order = snapshot[cut_idx]
-            .metadata
-            .as_ref()
-            .and_then(|metadata| metadata.user_input_order);
+        let source = RetainedInputSource::from(snapshot[cut_idx].metadata.as_ref());
         let mut review_history = self.review_history.take();
         if let Some(history) = &mut review_history {
             history.truncate_before(&snapshot[cut_idx].item);
@@ -638,7 +601,7 @@ impl ContextManager {
             Arc::make_mut(&mut retained_context).rollback(
                 &removed_turns,
                 first_removed_message_id,
-                acceptance_order,
+                source,
             );
         } else {
             Arc::make_mut(&mut retained_context).retain_answers(|answer| {
diff --git a/codex-rs/core/src/context_manager/history_tests.rs b/codex-rs/core/src/context_manager/history_tests.rs
index f634b0049e..bfbe5d162b 100644
--- a/codex-rs/core/src/context_manager/history_tests.rs
+++ b/codex-rs/core/src/context_manager/history_tests.rs
@@ -1269,7 +1269,10 @@ fn drop_last_n_user_turns_preserves_prefix() {
 
     // A steered message shares its source turn, but rollback must keep the earlier
     // instruction and answer as complete evidence, including after the next compaction.
-    let mut history = ContextManager::with_guardian_context_mode(GuardianContextMode::ThreadOwned);
+    let mut history = ContextManager::with_guardian_context_mode(
+        GuardianContextMode::ThreadOwned,
+        &codex_protocol::protocol::SessionSource::Exec,
+    );
     let mut expected = None;
     for (id, text) in [
         ("restriction", "Never publish publicly."),
diff --git a/codex-rs/core/src/context_manager/history_user_authorization.rs b/codex-rs/core/src/context_manager/history_user_authorization.rs
new file mode 100644
index 0000000000..a3de08dd0f
--- /dev/null
+++ b/codex-rs/core/src/context_manager/history_user_authorization.rs
@@ -0,0 +1,105 @@
+//! Captures local authorization and adopts copied instructions when a worker becomes a root.
+//! Inherited history remains excluded for workers; roots also recover it from checkpoints.
+//! Oversized originals retain bounded, incomplete excerpts for root review.
+//! Checkpoint copies cannot establish original completeness, even when their text is short.
+
+use std::sync::Arc;
+
+use super::ContextManager;
+use crate::context::GuardianContextMode;
+use crate::guardian::GUARDIAN_MAX_ROOT_MESSAGE_TOKENS;
+use crate::guardian::guardian_truncate_text;
+use codex_history::CodexHarnessMetadata;
+use codex_history::RetainedContext;
+use codex_history::RetainedUserMessage;
+use codex_protocol::models::ContentItem;
+use codex_protocol::models::ResponseItem;
+
+/// Checkpoint items may have been shortened while preserving their original metadata.
+pub(super) enum UserMessageSource {
+    Original,
+    Checkpoint,
+}
+
+impl ContextManager {
+    pub(crate) fn restore_retained_context(&mut self, checkpoint: Option<&RetainedContext>) {
+        Arc::make_mut(&mut self.retained_context).restore(checkpoint, &self.items);
+        if self.retain_inherited_user_messages
+            && !self.retained_context.has_inherited_user_messages()
+        {
+            // Worker checkpoints intentionally omit copied instructions. A standalone
+            // root adopts the surviving prefix without duplicating an adopted checkpoint.
+            let items = Arc::clone(&self.items);
+            for envelope in items.iter().filter(|envelope| {
+                envelope
+                    .metadata
+                    .as_ref()
+                    .is_some_and(|metadata| metadata.inherited_user_message)
+            }) {
+                self.record_user_authorization(
+                    &envelope.item,
+                    envelope.metadata.as_ref(),
+                    UserMessageSource::Checkpoint,
+                );
+            }
+        }
+    }
+
+    pub(super) fn record_user_authorization(
+        &mut self,
+        item: &ResponseItem,
+        metadata: Option<&CodexHarnessMetadata>,
+        source: UserMessageSource,
+    ) {
+        if !crate::context::is_user_authorization_message(item) {
+            return;
+        }
+        let inherited = metadata.is_some_and(|metadata| metadata.inherited_user_message);
+        if self.guardian_context_mode == GuardianContextMode::Legacy {
+            Arc::make_mut(&mut self.retained_context).mark_user_messages_incomplete();
+        } else if (!inherited || self.retain_inherited_user_messages)
+            && let ResponseItem::Message {
+                content,
+                internal_chat_message_metadata_passthrough,
+                ..
+            } = item
+        {
+            let mut complete = matches!(source, UserMessageSource::Original)
+                && internal_chat_message_metadata_passthrough
+                    .as_ref()
+                    .and_then(|metadata| metadata.content_item_kinds.as_ref())
+                    .is_some_and(|kinds| {
+                        kinds.len() == content.len()
+                            && kinds.iter().all(|kind| kind.0.starts_with("user."))
+                    });
+            let text = content
+                .iter()
+                .filter_map(|content| match content {
+                    ContentItem::InputText { text } | ContentItem::OutputText { text } => {
+                        Some(text.as_str())
+                    }
+                    _ => {
+                        complete = false;
+                        None
+                    }
+                })
+                .collect::<Vec<_>>()
+                .join("\n");
+            // Keep the same bounded text that child reviewers receive before
+            // compaction, instead of letting storage discard a large source.
+            // Local instruction sections still omit incomplete originals whole.
+            let (text, truncated) = guardian_truncate_text(&text, GUARDIAN_MAX_ROOT_MESSAGE_TOKENS);
+            complete &= !truncated;
+            Arc::make_mut(&mut self.retained_context).record_user_message(
+                RetainedUserMessage {
+                    turn_id: item.turn_id().unwrap_or_default().to_owned(),
+                    message_id: item.id().map(|id| id.as_str().to_owned()),
+                    text,
+                    complete,
+                },
+                metadata.into(),
+            );
+        }
+        self.user_message_revision = self.user_message_revision.saturating_add(1);
+    }
+}
diff --git a/codex-rs/core/src/session/rollout_reconstruction.rs b/codex-rs/core/src/session/rollout_reconstruction.rs
index 4ee1497ba1..38ca95c8ee 100644
--- a/codex-rs/core/src/session/rollout_reconstruction.rs
+++ b/codex-rs/core/src/session/rollout_reconstruction.rs
@@ -339,7 +339,10 @@ impl Session {
         )
         .unwrap_or(u64::MAX);
 
-        let mut history = ContextManager::with_guardian_context_mode(self.guardian_context_mode);
+        let mut history = ContextManager::with_guardian_context_mode(
+            self.guardian_context_mode,
+            &turn_context.session_source,
+        );
         let mut saw_legacy_compaction_without_replacement_history = false;
         if let Some(checkpoint) = base_compaction
             && let Some(items) = &checkpoint.compacted.replacement_history
diff --git a/codex-rs/core/src/session/session.rs b/codex-rs/core/src/session/session.rs
index b283528024..a3e6b17a2c 100644
--- a/codex-rs/core/src/session/session.rs
+++ b/codex-rs/core/src/session/session.rs
@@ -1267,7 +1267,10 @@ impl Session {
             let mut state = SessionState::new_with_auto_compact_window_ids(
                 session_configuration.clone(),
                 initial_auto_compact_window_ids,
-                guardian_context_mode,
+                ContextManager::with_guardian_context_mode(
+                    guardian_context_mode,
+                    &session_configuration.session_source,
+                ),
             );
             state.base_instructions_provenance = base_instructions_provenance.clone();
             let managed_network_requirements_configured = config
diff --git a/codex-rs/core/src/session/tests.rs b/codex-rs/core/src/session/tests.rs
index 9e4f5992c3..116e450033 100644
--- a/codex-rs/core/src/session/tests.rs
+++ b/codex-rs/core/src/session/tests.rs
@@ -8786,9 +8786,10 @@ where
     );
 
     let mut state = SessionState::new(session_configuration.clone());
-    state.history = ContextManager::with_guardian_context_mode(GuardianContextMode::from_features(
-        &config.features,
-    ));
+    state.history = ContextManager::with_guardian_context_mode(
+        GuardianContextMode::from_features(&config.features),
+        &session_configuration.session_source,
+    );
     let (environment_manager, resolved_turn_environments) =
         resolved_environments_for_configuration(&session_configuration, &default_environments)
             .await;
diff --git a/codex-rs/core/src/state/session.rs b/codex-rs/core/src/state/session.rs
index d4d04d37aa..5333661a6f 100644
--- a/codex-rs/core/src/state/session.rs
+++ b/codex-rs/core/src/state/session.rs
@@ -12,7 +12,6 @@ use super::AdditionalContextStore;
 use super::auto_compact_window::AutoCompactWindow;
 use super::auto_compact_window::AutoCompactWindowIds;
 use super::auto_compact_window::AutoCompactWindowSnapshot;
-use crate::context::GuardianContextMode;
 use crate::context_manager::ContextManager;
 use crate::context_manager::HistoryReplacement;
 use crate::session::PreviousTurnSettings;
@@ -65,16 +64,15 @@ impl SessionState {
         Self::new_with_auto_compact_window_ids(
             session_configuration,
             AutoCompactWindowIds::new_initial(),
-            GuardianContextMode::Legacy,
+            ContextManager::new(),
         )
     }
 
     pub(crate) fn new_with_auto_compact_window_ids(
         session_configuration: SessionConfiguration,
         auto_compact_window_ids: AutoCompactWindowIds,
-        guardian_context_mode: GuardianContextMode,
+        history: ContextManager,
     ) -> Self {
-        let history = ContextManager::with_guardian_context_mode(guardian_context_mode);
         Self {
             session_configuration,
             base_instructions_provenance: None,
diff --git a/codex-rs/core/tests/suite/guardian_retained_context.rs b/codex-rs/core/tests/suite/guardian_retained_context.rs
index 9b4e632d34..f1079403a5 100644
--- a/codex-rs/core/tests/suite/guardian_retained_context.rs
+++ b/codex-rs/core/tests/suite/guardian_retained_context.rs
@@ -9,6 +9,7 @@ use std::time::Duration;
 use anyhow::Context;
 use anyhow::Result;
 use codex_core::CodexThread;
+use codex_core::ForkSnapshot;
 use codex_core::TurnInputRequest;
 use codex_core::config::Config;
 use codex_core::config::ThreadStoreConfig;
@@ -35,7 +36,9 @@ use codex_protocol::protocol::ThreadHistoryMode;
 use codex_protocol::request_user_input::RequestUserInputAnswer;
 use codex_protocol::request_user_input::RequestUserInputResponse;
 use codex_protocol::user_input::UserInput;
+use codex_thread_store::ForkBoundary;
 use codex_thread_store::LoadThreadHistoryParams;
+use codex_thread_store::PrepareForkParams;
 use core_test_support::responses::ev_assistant_message;
 use core_test_support::responses::ev_completed;
 use core_test_support::responses::ev_function_call;
@@ -893,6 +896,225 @@ enum LifecycleBoundary {
     ChildFork,
 }
 
+// Cover live copied history and a truncated referenced checkpoint. Parent-answer
+// omission is already exercised by retained_answers_cross_real_session_boundaries.
+#[test_case(ThreadHistoryMode::Legacy; "copied worker history")]
+#[test_case(ThreadHistoryMode::Paginated; "referenced truncated checkpoint")]
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn standalone_fork_retains_inherited_user_instructions(
+    history_mode: ThreadHistoryMode,
+) -> Result<()> {
+    let compacted = history_mode == ThreadHistoryMode::Paginated;
+    skip_if_no_network!(Ok(()));
+    let server = start_mock_server().await;
+    let mut test = test_codex()
+        .with_history_mode(history_mode)
+        .with_config(|config| {
+            config.experimental_thread_store = ThreadStoreConfig::Local;
+            config
+                .features
+                .disable(Feature::TokenBudget)
+                .expect("use local compaction for worker checkpoint");
+            config.model_provider.name = "Local compaction test provider".to_owned();
+            for feature in [
+                Feature::GuardianApproval,
+                Feature::GuardianThreadContext,
+                Feature::Collab,
+                Feature::MultiAgentV2,
+                Feature::DefaultModeRequestUserInput,
+            ] {
+                config
+                    .features
+                    .enable(feature)
+                    .expect("enable test feature");
+            }
+        })
+        .build_with_auto_env(&server)
+        .await?;
+    let instruction = if compacted {
+        format!(
+            "You may publish the release. {} Delegate an inspection.",
+            "Original project detail. ".repeat(500)
+        )
+    } else {
+        "You may publish the release. Delegate an inspection.".to_owned()
+    };
+    let mut created = test.thread_manager.subscribe_thread_created();
+    mount_sse_sequence(
+        &server,
+        vec![
+            sse(vec![
+                ev_function_call_with_namespace(
+                    "spawn", "collaboration", "spawn_agent",
+                    &json!({"task_name": "worker", "message": "Inspect the project.", "fork_turns": "all"}).to_string(),
+                ),
+                ev_completed("spawn-response"),
+            ]),
+            sse(vec![ev_completed("root-complete")]),
+            sse(vec![ev_completed("worker-complete")]),
+        ],
+    ).await;
+    test.codex
+        .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
+            text: instruction.clone(),
+            text_elements: Vec::new(),
+        }]))
+        .await?;
+    wait_for_event(&test.codex, |event| {
+        matches!(event, EventMsg::TurnComplete(_))
+    })
+    .await;
+    let worker = test
+        .thread_manager
+        .get_thread(created.recv().await?)
+        .await?;
+    wait_for_event(&worker, |event| matches!(event, EventMsg::TurnComplete(_))).await;
+    test.codex.shutdown_and_wait().await?;
+    let local_instruction = if compacted {
+        // Leave less than Guardian's 900-token budget for the inherited source
+        // within local compaction's 20K user-message budget.
+        format!("Ask me before publishing. {}", "x".repeat(78_000))
+    } else {
+        "Ask me before publishing.".to_owned()
+    };
+    mount_sse_sequence(&server, vec![sse(vec![ev_completed("local-instruction")])]).await;
+    worker
+        .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
+            text: local_instruction.clone(),
+            text_elements: Vec::new(),
+        }]))
+        .await?;
+    wait_for_event(&worker, |event| matches!(event, EventMsg::TurnComplete(_))).await;
+    if compacted {
+        // Local compaction keeps the inherited source message in replacement history.
+        mount_sse_sequence(
+            &server,
+            vec![sse(vec![
+                ev_assistant_message("worker-summary", "Inspected the project."),
+                ev_completed("worker-compacted"),
+            ])],
+        )
+        .await;
+        compact_and_assert_answers(&test, &worker, &[]).await?;
+    }
+    let worker_context = worker.conversation_history_snapshot().await;
+    let inherited_text = worker_context
+        .items()
+        .find_map(|item| match item {
+            ResponseItem::Message { role, content, .. } if role == "user" => {
+                let [ContentItem::InputText { text }] = content.as_slice() else {
+                    return None;
+                };
+                text.starts_with("You may publish the release.")
+                    .then(|| text.clone())
+            }
+            _ => None,
+        })
+        .context("inherited source in worker history")?;
+    if compacted {
+        assert_ne!(inherited_text, instruction);
+        assert!(inherited_text.contains("tokens truncated"));
+        assert!(inherited_text.len() < 900 * 4);
+    }
+    // The adopted root later compacts through the mechanical path, which can drop originals.
+    test.config
+        .features
+        .enable(Feature::TokenBudget)
+        .expect("use mechanical root compaction");
+    let fork = if history_mode == ThreadHistoryMode::Paginated {
+        let prepared = test
+            .thread_store
+            .prepare_fork(PrepareForkParams {
+                thread_id: worker.session_configured().thread_id,
+                boundary: ForkBoundary::Latest,
+            })
+            .await?;
+        test.thread_manager
+            .fork_prepared_thread(
+                test.config.clone(),
+                prepared,
+                /*thread_source*/ None,
+                /*parent_trace*/ None,
+                ClientMcpExtensions::default(),
+                /*reserved_thread_id*/ None,
+            )
+            .await?
+    } else {
+        test.thread_manager
+            .fork_thread_from_history(
+                ForkSnapshot::Interrupted,
+                test.config.clone(),
+                InitialHistory::Resumed(ResumedHistory {
+                    conversation_id: worker.session_configured().thread_id,
+                    history: Arc::new(load_context(&test, &worker).await?),
+                    rollout_path: None,
+                }),
+                /*thread_source*/ None,
+                /*parent_trace*/ None,
+                ClientMcpExtensions::default(),
+                /*reserved_thread_id*/ None,
+            )
+            .await?
+    };
+    assert!(fork.thread.guardian_root_snapshot().await.is_none());
+    let history = fork.thread.conversation_history_snapshot().await;
+    let retained = history.retained_context().context("root context")?;
+    let answers = codex_guardian_context::render_verified_answers(retained);
+    assert_eq!(
+        (answers.fragments, answers.complete),
+        (
+            vec![codex_guardian_context::GuardianRootMessage::IncompleteVerifiedAnswers.render()],
+            false
+        ),
+    );
+    assert_eq!(
+        retained
+            .ordered_entries()
+            .map(|(_, entry)| match entry {
+                codex_history::RetainedContextEntry::UserMessage(message) =>
+                    (message.text.clone(), message.complete),
+                codex_history::RetainedContextEntry::VerifiedAnswer(_) =>
+                    panic!("no answers before root adoption"),
+            })
+            .collect::<Vec<_>>(),
+        vec![
+            (inherited_text, !compacted),
+            (
+                codex_guardian_context::truncate_text(&local_instruction, /*max_tokens*/ 900),
+                !compacted,
+            ),
+        ],
+    );
+    let after = record_answer(
+        &fork.thread,
+        &server,
+        "root-action",
+        "Do not publish.",
+        /*acceptance_order*/ 2,
+    )
+    .await?;
+    let expected = fork
+        .thread
+        .conversation_history_snapshot()
+        .await
+        .retained_context()
+        .context("root after local answer")?
+        .clone();
+    assert!(!expected.verified_answers_complete());
+    let root = fork.thread;
+    compact_and_assert_answers(&test, &root, &[after]).await?;
+    let root = resume(&test, &root).await?;
+    assert_eq!(
+        root.conversation_history_snapshot()
+            .await
+            .retained_context(),
+        Some(&expected)
+    );
+    root.shutdown_and_wait().await?;
+    worker.shutdown_and_wait().await?;
+    Ok(())
+}
+
 #[test_case(false, true; "enabled without checkpoint")]
 #[test_case(true, true; "enabled after checkpoint")]
 #[test_case(false, false; "legacy without checkpoint")]
diff --git a/codex-rs/core/tests/suite/guardian_subagent_authorization.rs b/codex-rs/core/tests/suite/guardian_subagent_authorization.rs
index df828c99dd..e11b940801 100644
--- a/codex-rs/core/tests/suite/guardian_subagent_authorization.rs
+++ b/codex-rs/core/tests/suite/guardian_subagent_authorization.rs
@@ -657,11 +657,32 @@ async fn guardian_subagent_review_preserves_late_root_user_authorization(
         assert!(answer_position < queued_position);
         let mut partial =
             serde_json::to_value(history.retained_context().expect("retained root context"))?;
+        let mut inherited_instruction = partial["user_messages"]
+            .as_array()
+            .expect("retained user-message records")
+            .iter()
+            .find(|entry| entry["text"] == INITIAL_PROMPT)
+            .expect("initial instruction")
+            .clone();
+        inherited_instruction["inherited"] = json!(true);
+        inherited_instruction["order"] = json!(
+            original_history[queued_position]
+                .metadata
+                .as_ref()
+                .expect("queued input metadata")
+                .user_input_order
+                .expect("queued acceptance order")
+        );
         partial["user_messages"]
             .as_array_mut()
             .expect("retained user-message records")
             .retain(|entry| entry["text"] == USER_APPROVAL);
         partial["user_messages_incomplete"] = json!(true);
+        let mut inherited_prefix = partial.clone();
+        inherited_prefix["user_messages"]
+            .as_array_mut()
+            .expect("retained user-message records")
+            .push(inherited_instruction);
         let mut expected_authorization = expected_messages
             .into_iter()
             .filter(|message| !matches!(message, GuardianRootMessage::Assistant(_)))
@@ -684,12 +705,39 @@ async fn guardian_subagent_review_preserves_late_root_user_authorization(
             (partial, MissingCheckpointSource::RootInstruction, false),
             // Rebuild the local counter even when all retained metadata is absent.
             (Value::Null, MissingCheckpointSource::None, true),
+            // Prefix and local orders can collide numerically. Recovery must keep
+            // the inherited instruction first without losing the queued local grant.
+            (inherited_prefix, MissingCheckpointSource::None, true),
         ] {
             let mut expected = expected_authorization.clone();
+            let inherited_message_id = retained["user_messages"]
+                .as_array()
+                .and_then(|entries| entries.iter().find(|entry| entry["inherited"] == true))
+                .and_then(|entry| entry["message_id"].as_str());
+            if inherited_message_id.is_some() {
+                expected.insert(
+                    /*index*/ 2,
+                    GuardianRootMessage::IncompleteVerifiedAnswers,
+                );
+            }
             if retained.is_null() {
                 expected.retain(|message| !matches!(message, GuardianRootMessage::UserInput(_)));
             }
             let mut replacement_history = original_history.clone();
+            if let Some(id) = inherited_message_id {
+                let metadata = replacement_history
+                    .iter_mut()
+                    .find(|envelope| {
+                        envelope
+                            .item
+                            .id()
+                            .is_some_and(|item_id| item_id.as_str() == id)
+                    })
+                    .and_then(|envelope| envelope.metadata.as_mut())
+                    .expect("inherited input metadata");
+                metadata.inherited_user_message = true;
+                metadata.user_input_order = Some(100);
+            }
             match missing_source {
                 MissingCheckpointSource::None => {}
                 MissingCheckpointSource::VerifiedAnswer => {
diff --git a/codex-rs/guardian-context/src/retained_instructions_tests.rs b/codex-rs/guardian-context/src/retained_instructions_tests.rs
index 9e21ece663..fa78ddd875 100644
--- a/codex-rs/guardian-context/src/retained_instructions_tests.rs
+++ b/codex-rs/guardian-context/src/retained_instructions_tests.rs
@@ -1,5 +1,6 @@
 use super::*;
 use codex_history::RetainedContextEvent;
+use codex_history::RetainedInputSource;
 use codex_history::RetainedUserMessage;
 use codex_history::VerifiedAnswer;
 use codex_history::VerifiedQuestionAnswer;
@@ -28,7 +29,7 @@ fn instructions_preserve_source_order_and_whole_records() {
             text: "Do not publish after all.".to_owned(),
             complete: true,
         },
-        /*acceptance_order*/ None,
+        RetainedInputSource::Local(None),
     );
     let rendered = render_retained_instructions(&context);
     assert_eq!(
@@ -52,7 +53,7 @@ fn instructions_preserve_source_order_and_whole_records() {
             text: "Permission is conditional. ".repeat(200),
             complete: true,
         },
-        /*acceptance_order*/ None,
+        RetainedInputSource::Local(None),
     );
     let rendered = render_retained_instructions(&context);
     assert_eq!(rendered.len(), 2);
diff --git a/codex-rs/history/src/lib.rs b/codex-rs/history/src/lib.rs
index dd1b9ef05f..258c32291f 100644
--- a/codex-rs/history/src/lib.rs
+++ b/codex-rs/history/src/lib.rs
@@ -173,6 +173,8 @@ pub use reconciled_retained_context::ReconciledRetainedContext;
 pub use retained_context::RetainedContext;
 pub use retained_context::RetainedContextEntry;
 pub use retained_context::RetainedContextEvent;
+pub use retained_context::RetainedContextOrder;
+pub use retained_context::RetainedInputSource;
 pub use retained_context::RetainedUserMessage;
 pub use retained_context::VerifiedAnswer;
 pub use retained_context::VerifiedQuestionAnswer;
diff --git a/codex-rs/history/src/reconciled_retained_context.rs b/codex-rs/history/src/reconciled_retained_context.rs
index 3754044767..1343be6347 100644
--- a/codex-rs/history/src/reconciled_retained_context.rs
+++ b/codex-rs/history/src/reconciled_retained_context.rs
@@ -6,12 +6,13 @@ use std::collections::HashSet;
 
 use crate::RetainedContext;
 use crate::RetainedContextEntry;
+use crate::RetainedContextOrder;
 use crate::RetainedUserMessage;
 
 /// Retained evidence supplemented by surviving user messages without changing the checkpoint.
 pub struct ReconciledRetainedContext<'a> {
     retained_context: Option<&'a RetainedContext>,
-    recovered: Vec<(u64, RetainedUserMessage)>,
+    recovered: Vec<(RetainedContextOrder, RetainedUserMessage)>,
     /// Instructions were already missing, or a recovered source could not be ordered.
     pub missing_user_messages: bool,
 }
@@ -19,6 +20,7 @@ pub struct ReconciledRetainedContext<'a> {
 impl<'a> ReconciledRetainedContext<'a> {
     /// Reconciles eligible live user messages with retained sources in acceptance order.
     /// The caller supplies original source identities and filters out non-user context.
+    /// Inherited sources must supply no local order; retained identities match before ordering.
     /// Live messages are consumed only when retained user instructions are incomplete.
     pub fn new(
         retained_context: Option<&'a RetainedContext>,
@@ -57,7 +59,11 @@ impl<'a> ReconciledRetainedContext<'a> {
                 }
                 // Queued steering can enter raw history after a later-accepted answer.
                 // Compare their persisted sequence numbers, including checkpoint-only answers.
-                let Some(order) = order.filter(|order| used_orders.insert(*order)) else {
+                // Parent counters cannot establish an adopted prefix position.
+                let Some(order) = order
+                    .map(RetainedContextOrder::Local)
+                    .filter(|order| used_orders.insert(*order))
+                else {
                     missing_user_messages = true;
                     continue;
                 };
@@ -74,7 +80,7 @@ impl<'a> ReconciledRetainedContext<'a> {
     /// Returns retained and recovered evidence in persisted acceptance order.
     pub fn ordered_entries(
         &self,
-    ) -> impl DoubleEndedIterator<Item = (u64, RetainedContextEntry<'_>)> {
+    ) -> impl DoubleEndedIterator<Item = (RetainedContextOrder, RetainedContextEntry<'_>)> {
         let mut entries = self
             .retained_context
             .into_iter()
diff --git a/codex-rs/history/src/reconciled_retained_context_tests.rs b/codex-rs/history/src/reconciled_retained_context_tests.rs
index b851f23e19..baeb79d0dc 100644
--- a/codex-rs/history/src/reconciled_retained_context_tests.rs
+++ b/codex-rs/history/src/reconciled_retained_context_tests.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::RetainedContextEvent;
+use crate::RetainedInputSource;
 use crate::VerifiedAnswer;
 use crate::VerifiedQuestionAnswer;
 use pretty_assertions::assert_eq;
@@ -25,8 +26,8 @@ fn recovery_preserves_source_identity_acceptance_order_and_checkpoint_gaps() {
         ..retained_excerpt.clone()
     };
     let mut retained = RetainedContext::default();
-    retained.record_user_message(initial.clone(), Some(0));
-    retained.record_user_message(retained_excerpt, Some(1));
+    retained.record_user_message(initial.clone(), RetainedInputSource::Local(Some(0)));
+    retained.record_user_message(retained_excerpt, RetainedInputSource::Local(Some(1)));
     retained.record(&RetainedContextEvent::VerifiedAnswer {
         answer: VerifiedAnswer {
             turn_id: "answer-turn".to_owned(),
@@ -70,12 +71,15 @@ fn recovery_preserves_source_identity_acceptance_order_and_checkpoint_gaps() {
         ),
         (
             vec![
-                (0, "Inspect the deployment."),
-                (1, ""),
-                (2, "Make the deployment public."),
-                (3, "Never publicly."),
-                (4, "Do not deploy after all."),
-                (5, "Inspect the deployment."),
+                (RetainedContextOrder::Local(0), "Inspect the deployment."),
+                (RetainedContextOrder::Local(1), ""),
+                (
+                    RetainedContextOrder::Local(2),
+                    "Make the deployment public."
+                ),
+                (RetainedContextOrder::Local(3), "Never publicly."),
+                (RetainedContextOrder::Local(4), "Do not deploy after all."),
+                (RetainedContextOrder::Local(5), "Inspect the deployment."),
             ],
             true,
         ),
@@ -86,7 +90,10 @@ fn recovery_preserves_source_identity_acceptance_order_and_checkpoint_gaps() {
 #[test]
 fn recovery_marks_missing_and_conflicting_orders_incomplete() {
     let mut retained = RetainedContext::default();
-    retained.record_user_message(instruction("Inspect the deployment."), Some(1));
+    retained.record_user_message(
+        instruction("Inspect the deployment."),
+        RetainedInputSource::Local(Some(1)),
+    );
     assert!(!retained.has_missing_user_messages());
     let checkpoint = retained.clone();
 
@@ -111,7 +118,10 @@ fn recovery_marks_missing_and_conflicting_orders_incomplete() {
                 reconciled.missing_user_messages,
             ),
             (
-                vec![(1, "Inspect the deployment."), (2, "Do not deploy.")],
+                vec![
+                    (RetainedContextOrder::Local(1), "Inspect the deployment."),
+                    (RetainedContextOrder::Local(2), "Do not deploy.")
+                ],
                 true,
             ),
             "invalid order: {invalid_order:?}",
diff --git a/codex-rs/history/src/retained_context.rs b/codex-rs/history/src/retained_context.rs
index 8c1f368819..ecc5c364c9 100644
--- a/codex-rs/history/src/retained_context.rs
+++ b/codex-rs/history/src/retained_context.rs
@@ -1,5 +1,7 @@
 //! Bounded host-owned facts outside the model's compaction contract.
 //! Checkpoints and live recording use the same admission rules; rendering is a consumer concern.
+//! Adopted parent instructions precede local facts without sharing the local acceptance counter.
+//! Their parent verified answers are unavailable, so adopted authorization stays incomplete.
 
 use std::collections::VecDeque;
 
@@ -7,6 +9,7 @@ use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 
+use crate::CodexHarnessMetadata;
 use crate::ResponseItemEnvelope;
 
 const MAX_FAMILY_RECORDS: usize = 8;
@@ -39,6 +42,33 @@ pub struct RetainedUserMessage {
     pub complete: bool,
 }
 
+/// Local facts use their acceptance counter; copied parent instructions use prefix order.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum RetainedInputSource {
+    Local(Option<u64>),
+    Inherited,
+}
+
+impl RetainedInputSource {
+    /// Parent counters never establish order within the owning thread.
+    pub fn acceptance_order(self) -> Option<u64> {
+        match self {
+            Self::Local(order) => order,
+            Self::Inherited => None,
+        }
+    }
+}
+
+impl From<Option<&CodexHarnessMetadata>> for RetainedInputSource {
+    fn from(metadata: Option<&CodexHarnessMetadata>) -> Self {
+        if metadata.is_some_and(|metadata| metadata.inherited_user_message) {
+            Self::Inherited
+        } else {
+            Self::Local(metadata.and_then(|metadata| metadata.user_input_order))
+        }
+    }
+}
+
 impl std::fmt::Debug for RetainedUserMessage {
     fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         formatter
@@ -50,12 +80,32 @@ impl std::fmt::Debug for RetainedUserMessage {
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]
 struct Ordered<T> {
+    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+    inherited: bool,
     #[serde(default)]
     order: u64,
     #[serde(flatten)]
     value: T,
 }
 
+impl<T> Ordered<T> {
+    fn key(&self) -> RetainedContextOrder {
+        if self.inherited {
+            RetainedContextOrder::Inherited(self.order)
+        } else {
+            RetainedContextOrder::Local(self.order)
+        }
+    }
+}
+
+/// Inherited prefix order precedes the owning thread's local acceptance order.
+/// The counters have separate scopes and must not be compared without their origin.
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub enum RetainedContextOrder {
+    Inherited(u64),
+    Local(u64),
+}
+
 /// Borrowed host evidence across retained families.
 pub enum RetainedContextEntry<'a> {
     UserMessage(&'a RetainedUserMessage),
@@ -108,7 +158,7 @@ fn legacy_user_messages_incomplete() -> bool {
 fn bound_family<T: Serialize>(items: &mut VecDeque<Ordered<T>>, incomplete: &mut bool) {
     // Queued instructions can be recorded after later-accepted answers. Evict by
     // acceptance order, not by the order in which persistence happened to finish.
-    items.make_contiguous().sort_by_key(|entry| entry.order);
+    items.make_contiguous().sort_by_key(Ordered::key);
     while items.len() > MAX_FAMILY_RECORDS
         || serde_json::to_vec(items).map_or(true, |bytes| bytes.len() > MAX_FAMILY_BYTES)
     {
@@ -196,24 +246,29 @@ impl RetainedContext {
         self.user_messages_incomplete = true;
     }
 
-    /// Returns retained evidence with its persisted order, shared across both families.
-    /// Explicit acceptance order survives delayed recording; legacy records use recording order.
+    /// Whether a root checkpoint already contains its adopted instruction prefix.
+    pub fn has_inherited_user_messages(&self) -> bool {
+        self.user_messages.iter().any(|entry| entry.inherited)
+    }
+
+    /// Returns retained evidence with its origin and persisted order across both families.
+    /// Explicit acceptance order survives delayed recording; inherited prefix order stays separate.
     pub fn ordered_entries(
         &self,
-    ) -> impl DoubleEndedIterator<Item = (u64, RetainedContextEntry<'_>)> {
+    ) -> impl DoubleEndedIterator<Item = (RetainedContextOrder, RetainedContextEntry<'_>)> {
         let mut entries = self
             .verified_answers
             .iter()
             .map(|entry| {
                 (
-                    entry.order,
+                    entry.key(),
                     RetainedContextEntry::VerifiedAnswer(&entry.value),
                 )
             })
             .chain(
                 self.user_messages
                     .iter()
-                    .map(|entry| (entry.order, RetainedContextEntry::UserMessage(&entry.value))),
+                    .map(|entry| (entry.key(), RetainedContextEntry::UserMessage(&entry.value))),
             )
             .collect::<Vec<_>>();
         entries.sort_by_key(|(order, _)| *order);
@@ -222,22 +277,41 @@ impl RetainedContext {
 
     /// Records a delivered user item with its acceptance order. Legacy items without
     /// this metadata use recording order; checkpoint/suffix replay uses the same path.
+    /// Inherited instructions use prefix order because their original counters belong to parents.
     pub fn record_user_message(
         &mut self,
         mut message: RetainedUserMessage,
-        acceptance_order: Option<u64>,
+        source: RetainedInputSource,
     ) {
         message.bound();
+        let inherited = source == RetainedInputSource::Inherited;
+        // Worker forks omit parent answer records. Adopting their instructions
+        // cannot establish whether an omitted answer restricted an inherited grant.
+        self.verified_answers_incomplete |= inherited;
         if let Some(index) = self.user_messages.iter().position(|entry| {
             message.message_id.is_some() && entry.value.message_id == message.message_id
         }) {
-            if self.user_messages[index].value == message {
+            if self.user_messages[index].value == message
+                && self.user_messages[index].inherited == inherited
+            {
                 return;
             }
             self.user_messages.remove(index);
         }
-        let order = self.record_order(acceptance_order);
+        // Parent and worker counters have different scopes. Adopt the copied prefix
+        // in history order without advancing the worker's local acceptance counter.
+        let order = if inherited {
+            self.user_messages
+                .iter()
+                .filter(|entry| entry.inherited)
+                .map(|entry| entry.order.saturating_add(1))
+                .max()
+                .unwrap_or_default()
+        } else {
+            self.record_order(source.acceptance_order())
+        };
         self.user_messages.push_back(Ordered {
+            inherited,
             order,
             value: message,
         });
@@ -283,6 +357,7 @@ impl RetainedContext {
                 }
                 let order = self.record_order(acceptance_order);
                 self.verified_answers.push_back(Ordered {
+                    inherited: false,
                     order,
                     value: answer,
                 });
@@ -315,7 +390,11 @@ impl RetainedContext {
         }
         for entry in &mut self.user_messages {
             entry.value.bound();
-            self.next_order = self.next_order.max(entry.order.saturating_add(1));
+            // Also repair checkpoints written before adoption recorded the answer gap.
+            self.verified_answers_incomplete |= entry.inherited;
+            if !entry.inherited {
+                self.next_order = self.next_order.max(entry.order.saturating_add(1));
+            }
         }
         for order in surviving_items
             .iter()
@@ -345,18 +424,19 @@ impl RetainedContext {
         &mut self,
         turn_ids: &[&str],
         first_removed_message_id: Option<&str>,
-        acceptance_order: Option<u64>,
+        source: RetainedInputSource,
     ) {
-        if let Some(order) = acceptance_order.or_else(|| {
+        let boundary = source.acceptance_order().map(RetainedContextOrder::Local);
+        if let Some(boundary) = boundary.or_else(|| {
             first_removed_message_id.and_then(|id| {
                 self.user_messages
                     .iter()
                     .find(|message| message.value.message_id.as_deref() == Some(id))
-                    .map(|message| message.order)
+                    .map(Ordered::key)
             })
         }) {
-            self.verified_answers.retain(|entry| entry.order < order);
-            self.user_messages.retain(|entry| entry.order < order);
+            self.verified_answers.retain(|entry| entry.key() < boundary);
+            self.user_messages.retain(|entry| entry.key() < boundary);
             return;
         }
         self.user_messages_incomplete |= first_removed_message_id.is_some()
@@ -364,10 +444,14 @@ impl RetainedContext {
                 .user_messages
                 .iter()
                 .any(|message| turn_ids.contains(&message.value.turn_id.as_str()));
-        self.verified_answers
-            .retain(|answer| !turn_ids.contains(&answer.value.turn_id.as_str()));
-        self.user_messages
-            .retain(|message| !turn_ids.contains(&message.value.turn_id.as_str()));
+        self.verified_answers.retain(|answer| {
+            source != RetainedInputSource::Inherited
+                && !turn_ids.contains(&answer.value.turn_id.as_str())
+        });
+        self.user_messages.retain(|message| {
+            (source != RetainedInputSource::Inherited || message.inherited)
+                && !turn_ids.contains(&message.value.turn_id.as_str())
+        });
     }
 }
 
diff --git a/codex-rs/history/src/retained_context_tests.rs b/codex-rs/history/src/retained_context_tests.rs
index d3c01cbf6d..9b5bf65f99 100644
--- a/codex-rs/history/src/retained_context_tests.rs
+++ b/codex-rs/history/src/retained_context_tests.rs
@@ -31,7 +31,7 @@ fn retained_evidence_preserves_order_through_recovery_checkpoint_and_rollback()
             text: String::new(),
             complete: false,
         },
-        /*acceptance_order*/ None,
+        RetainedInputSource::Local(None),
     );
     let mut expected = context.clone();
     expected.user_messages[0].value.text = "Do not publish after all.".to_owned();
@@ -63,7 +63,7 @@ fn retained_evidence_preserves_order_through_recovery_checkpoint_and_rollback()
     restored.rollback(
         &["revocation-turn"],
         Some("revocation"),
-        /*acceptance_order*/ None,
+        RetainedInputSource::Local(None),
     );
     assert_eq!(
         restored,
@@ -99,7 +99,7 @@ fn retained_families_enforce_storage_limits_without_changing_snapshots() {
     context.rollback(
         &["turn-2"],
         /*first_removed_message_id*/ None,
-        /*acceptance_order*/ None,
+        RetainedInputSource::Local(None),
     );
     assert_eq!(context.verified_answers().count(), 0);
     assert!(!context.verified_answers_complete());
@@ -135,7 +135,7 @@ fn retained_families_enforce_storage_limits_without_changing_snapshots() {
                 text: "Keep the repository private.".to_owned(),
                 complete: true,
             },
-            /*acceptance_order*/ None,
+            RetainedInputSource::Local(None),
         );
     }
     assert!(!restored.user_messages_complete());
@@ -154,7 +154,7 @@ fn retained_families_enforce_storage_limits_without_changing_snapshots() {
             text: "An older queued instruction.".to_owned(),
             complete: true,
         },
-        Some(0),
+        RetainedInputSource::Local(Some(0)),
     );
     assert_eq!(
         restored, recent,
@@ -167,7 +167,7 @@ fn retained_families_enforce_storage_limits_without_changing_snapshots() {
             text: "restriction ".repeat(MAX_RECORD_BYTES),
             complete: true,
         },
-        /*acceptance_order*/ None,
+        RetainedInputSource::Local(None),
     );
     let Some((_, RetainedContextEntry::UserMessage(message))) =
         restored.ordered_entries().next_back()
@@ -188,7 +188,7 @@ fn recovered_excerpts_obey_record_and_family_limits() {
                 text: String::new(),
                 complete: false,
             },
-            /*acceptance_order*/ None,
+            RetainedInputSource::Local(None),
         );
     }
     let unchanged = context.clone();
@@ -281,10 +281,13 @@ fn accepted_order_survives_delayed_recording_and_checkpoint_replay() {
         text: "Keep the repository private.".to_owned(),
         complete: true,
     };
-    context.record_user_message(instruction.clone(), Some(steer_order));
+    context.record_user_message(
+        instruction.clone(),
+        RetainedInputSource::Local(Some(steer_order)),
+    );
     let mut resumed = RetainedContext::default();
     resumed.restore(Some(&checkpoint), &[]);
-    resumed.record_user_message(instruction, Some(steer_order));
+    resumed.record_user_message(instruction, RetainedInputSource::Local(Some(steer_order)));
     assert_eq!(resumed, context);
     assert_eq!(
         resumed
@@ -297,15 +300,29 @@ fn accepted_order_survives_delayed_recording_and_checkpoint_replay() {
             })
             .collect::<Vec<_>>(),
         vec![
-            (steer_order, "Keep the repository private."),
-            (answer_order, "Yes, but never publicly."),
+            (
+                RetainedContextOrder::Local(steer_order),
+                "Keep the repository private."
+            ),
+            (
+                RetainedContextOrder::Local(answer_order),
+                "Yes, but never publicly."
+            ),
         ],
     );
     // This checkpoint predates model delivery of the queued instruction. Rollback
     // still removes its later-accepted answer using the persisted boundary order.
     let mut before_delivery = checkpoint;
-    before_delivery.rollback(&["turn-1"], Some("steer"), Some(steer_order));
-    resumed.rollback(&["turn-1"], Some("steer"), Some(steer_order));
+    before_delivery.rollback(
+        &["turn-1"],
+        Some("steer"),
+        RetainedInputSource::Local(Some(steer_order)),
+    );
+    resumed.rollback(
+        &["turn-1"],
+        Some("steer"),
+        RetainedInputSource::Local(Some(steer_order)),
+    );
     assert_eq!(before_delivery, resumed);
     assert_eq!(
         resumed,
@@ -315,3 +332,57 @@ fn accepted_order_survives_delayed_recording_and_checkpoint_replay() {
         }
     );
 }
+
+#[test]
+fn adopted_instructions_preserve_local_order_and_rollback_scope() {
+    let mut context = RetainedContext::default();
+    context.record(&publish_answer());
+    for index in 0..2 {
+        let message = RetainedUserMessage {
+            turn_id: "parent-turn".to_owned(),
+            message_id: Some(format!("parent-{index}")),
+            text: format!("Parent instruction {index}"),
+            complete: true,
+        };
+        context.record_user_message(message.clone(), RetainedInputSource::Inherited);
+        context.record_user_message(message, RetainedInputSource::Inherited);
+    }
+    assert_eq!(context.reserve_order(), 1);
+    assert!(!context.verified_answers_complete());
+    assert_eq!(
+        context
+            .ordered_entries()
+            .map(|(order, _)| order)
+            .collect::<Vec<_>>(),
+        vec![
+            RetainedContextOrder::Inherited(0),
+            RetainedContextOrder::Inherited(1),
+            RetainedContextOrder::Local(0)
+        ],
+    );
+    let checkpoint = serde_json::from_slice(&serde_json::to_vec(&context).unwrap()).unwrap();
+    let mut restored = RetainedContext::default();
+    restored.restore(Some(&checkpoint), &[]);
+    assert_eq!(restored, context);
+    // Older roots adopted complete instructions without recording the missing parent answers.
+    let mut legacy_checkpoint = serde_json::to_value(&checkpoint).unwrap();
+    legacy_checkpoint["incomplete"] = serde_json::json!(false);
+    let legacy_checkpoint = serde_json::from_value(legacy_checkpoint).unwrap();
+    restored.restore(Some(&legacy_checkpoint), &[]);
+    assert_eq!(restored, context);
+    restored.rollback(
+        &["turn-1"],
+        /*first_removed_message_id*/ None,
+        RetainedInputSource::Local(Some(0)),
+    );
+    let mut expected = context;
+    expected.verified_answers.clear();
+    assert_eq!(restored, expected);
+    restored.rollback(
+        &["parent-turn"],
+        Some("parent-1"),
+        RetainedInputSource::Inherited,
+    );
+    expected.user_messages.pop_back();
+    assert_eq!(restored, expected);
+}
diff --git a/codex-rs/rollout/src/lib.rs b/codex-rs/rollout/src/lib.rs
index 390b1d08b6..462d0f0260 100644
--- a/codex-rs/rollout/src/lib.rs
+++ b/codex-rs/rollout/src/lib.rs
@@ -31,6 +31,7 @@ pub use codex_history::ResponseItemEnvelope;
 pub use codex_history::ResumedHistory;
 pub use codex_history::RetainedContextEntry;
 pub use codex_history::RetainedContextEvent;
+pub use codex_history::RetainedInputSource;
 pub use codex_history::RolloutItem;
 pub use codex_history::RolloutLine;
 pub(crate) use codex_protocol::protocol;
diff --git a/codex-rs/thread-store/src/local/rollout_migration/rollback_plan.rs b/codex-rs/thread-store/src/local/rollout_migration/rollback_plan.rs
index 6da7264cd3..588ac37787 100644
--- a/codex-rs/thread-store/src/local/rollout_migration/rollback_plan.rs
+++ b/codex-rs/thread-store/src/local/rollout_migration/rollback_plan.rs
@@ -17,6 +17,7 @@ use codex_protocol::protocol::EventMsg;
 use codex_protocol::protocol::UserMessageEvent;
 use codex_rollout::CompactedItem;
 use codex_rollout::RetainedContextEntry;
+use codex_rollout::RetainedInputSource;
 use codex_rollout::RolloutItem;
 use codex_rollout::RolloutLine;
 
@@ -42,7 +43,7 @@ struct PendingUserResponse {
 struct InstructionBoundary {
     record_index: usize,
     message_id: Option<ResponseItemId>,
-    acceptance_order: Option<u64>,
+    input_source: RetainedInputSource,
     alive: bool,
 }
 
@@ -161,10 +162,7 @@ impl RollbackPlanner {
                 } else if rollback::counts_as_boundary(&response.item) {
                     let boundary = self.start_boundary(index);
                     self.boundaries[boundary].message_id = response.id().cloned();
-                    self.boundaries[boundary].acceptance_order = response
-                        .metadata
-                        .as_ref()
-                        .and_then(|metadata| metadata.user_input_order);
+                    self.boundaries[boundary].input_source = response.metadata.as_ref().into();
                     if let ResponseItem::Message { role, content, .. } = &response.item
                         && role == "user"
                     {
@@ -323,7 +321,7 @@ impl RollbackPlanner {
         self.boundaries.push(InstructionBoundary {
             record_index: index,
             message_id: None,
-            acceptance_order: None,
+            input_source: RetainedInputSource::Local(None),
             alive: true,
         });
         let had_prior_boundary = !self.boundary_stack.is_empty();
@@ -380,7 +378,8 @@ impl RollbackPlanner {
         }
         if let Some(boundary) = first_removed_boundary {
             let source = &self.boundaries[boundary];
-            if let Some(order) = source.acceptance_order {
+            let acceptance_order = source.input_source.acceptance_order();
+            if let Some(order) = acceptance_order {
                 // An answer may have been persisted before the queued instruction
                 // accepted ahead of it. Both are removed at that acceptance boundary.
                 for fact in &self.retained_fact_sources {
@@ -411,10 +410,10 @@ impl RollbackPlanner {
             // including in checkpoints. Legacy evidence uses the recorded boundary.
             // Later checkpoints have not been observed yet and already reflect this rollback.
             for frame in self.compactions.iter_mut().rev().take_while(|frame| {
-                source.acceptance_order.is_some() || frame.record_index >= source.record_index
+                acceptance_order.is_some() || frame.record_index >= source.record_index
             }) {
                 if let Some(context) = &mut frame.item.retained_context {
-                    if source.acceptance_order.is_some()
+                    if acceptance_order.is_some()
                         || context
                             .ordered_entries()
                             .any(|(_, entry)| matches!(entry, RetainedContextEntry::UserMessage(_)))
@@ -422,7 +421,7 @@ impl RollbackPlanner {
                         context.rollback(
                             &removed_turns,
                             source.message_id.as_ref().map(ResponseItemId::as_str),
-                            source.acceptance_order,
+                            source.input_source,
                         );
                     } else {
                         // Checkpoints written without instruction retention keep the legacy