diff --git a/AGENTS.md b/AGENTS.md
index 101a0773d9..6eccd86ca3 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -252,8 +252,6 @@ formatting.
 **Operational traps.** Do not adopt the review-slog toolkit as a merge gate
 until its
 [blocking condition](docs/open-questions.md#review-slog-toolkit-adoption) is
-cleared. Do not rely on automatic context compaction until its
-[blocking condition](docs/open-questions.md#automatic-context-compaction) is
 cleared.
 
 Run `git worktree list` before working with another checkout of this clone.
diff --git a/apps/signalboxd/src/process_runtime.rs b/apps/signalboxd/src/process_runtime.rs
index 57da0e73a8..e83058b688 100644
--- a/apps/signalboxd/src/process_runtime.rs
+++ b/apps/signalboxd/src/process_runtime.rs
@@ -101,7 +101,8 @@ use signalbox_persistence::{
         PostgresCommissionedDispatchStore,
     },
     context_compaction::{
-        AppliedContextCompaction, ContextCompactionCommandLookup, ContextCompactionRepository,
+        AppliedContextCompaction, AutomaticContextCompactionPreviewMember,
+        ContextCompactionCommandLookup, ContextCompactionRepository,
         ContextCompactionRepositoryError, FailedContextCompactionDisposition,
         PrepareContextCompactionOutcome, PrepareContextCompactionRequest,
         PreparedContextCompaction,
@@ -6956,7 +6957,6 @@ where
             session,
             requested_through_position,
             automatic_for_turn: None,
-            automatic_content_byte_target: None,
             defaults_version: defaults.version(),
             selection,
             target,
@@ -7167,6 +7167,7 @@ pub(crate) enum AutomaticContextCompactionError {
     Repository(ContextCompactionRepositoryError),
     Model,
     Configuration,
+    InputDoesNotFit,
     State,
     Integrity,
     AlreadyAttempted,
@@ -7193,7 +7194,7 @@ impl ClassifyOperatorFailure for AutomaticContextCompactionError {
             Self::Read(ProcessReadError::Corruption(_)) | Self::Integrity => {
                 signalbox_application::OperatorFailureClass::FailClosedCorruption
             }
-            Self::Configuration | Self::State | Self::AlreadyAttempted => {
+            Self::Configuration | Self::InputDoesNotFit | Self::State | Self::AlreadyAttempted => {
                 signalbox_application::OperatorFailureClass::CallerOrHubBug
             }
         }
@@ -7218,6 +7219,7 @@ impl ClassifyOperatorFailure for AutomaticContextCompactionError {
             }
             Self::Model => "context_compaction_model",
             Self::Configuration => "context_compaction_configuration",
+            Self::InputDoesNotFit => "context_compaction_input_does_not_fit",
             Self::State => "context_compaction_state",
             Self::Integrity => "context_compaction_integrity",
             Self::AlreadyAttempted => "context_compaction_already_attempted",
@@ -7225,6 +7227,73 @@ impl ClassifyOperatorFailure for AutomaticContextCompactionError {
     }
 }
 
+fn automatic_context_compaction_boundary(
+    members: &[AutomaticContextCompactionPreviewMember],
+    entries: &[ProcessTranscriptEntry],
+    input_byte_budget: u64,
+) -> Result<Option<u64>, AutomaticContextCompactionError> {
+    if members.len() != entries.len() {
+        return Err(AutomaticContextCompactionError::Integrity);
+    }
+    let mut encoded_lengths = Vec::with_capacity(entries.len());
+    let mut boundaries = Vec::with_capacity(entries.len());
+    for (member, entry) in members.iter().zip(entries) {
+        if member.reference() != transcript_entry_reference(entry) {
+            return Err(AutomaticContextCompactionError::Integrity);
+        }
+        let encoded = serde_json::to_vec(&context_compaction_entry_value(entry))
+            .map_err(|_| AutomaticContextCompactionError::Integrity)?;
+        encoded_lengths.push(
+            u64::try_from(encoded.len()).map_err(|_| AutomaticContextCompactionError::Integrity)?,
+        );
+        boundaries.push((member.position(), member.is_safe_boundary()));
+    }
+    Ok(bounded_rendered_compaction_boundary(
+        &encoded_lengths,
+        &boundaries,
+        input_byte_budget,
+    ))
+}
+
+fn bounded_rendered_compaction_boundary(
+    encoded_lengths: &[u64],
+    boundaries: &[(u64, bool)],
+    input_byte_budget: u64,
+) -> Option<u64> {
+    if encoded_lengths.len() != boundaries.len() {
+        return None;
+    }
+    let separators = u64::try_from(encoded_lengths.len().saturating_sub(1)).ok()?;
+    let total_bytes = encoded_lengths
+        .iter()
+        .fold(2_u64, |total, length| total.saturating_add(*length));
+    let target_bytes = total_bytes
+        .saturating_add(separators)
+        .div_ceil(2)
+        .min(input_byte_budget);
+    let mut prefix_bytes = 1_u64;
+    let mut latest_safe = None;
+    for (index, ((position, safe_boundary), encoded_length)) in
+        boundaries.iter().zip(encoded_lengths).enumerate()
+    {
+        if index > 0 {
+            prefix_bytes = prefix_bytes.saturating_add(1);
+        }
+        prefix_bytes = prefix_bytes.saturating_add(*encoded_length);
+        let candidate_bytes = prefix_bytes.saturating_add(1);
+        if candidate_bytes > input_byte_budget {
+            break;
+        }
+        if *safe_boundary {
+            latest_safe = Some(*position);
+            if candidate_bytes >= target_bytes {
+                return latest_safe;
+            }
+        }
+    }
+    latest_safe
+}
+
 pub(crate) async fn compact_automatically(
     model_calls: &PostgresModelCallRepository,
     model_configuration: &HubModelConfiguration,
@@ -7263,22 +7332,50 @@ pub(crate) async fn compact_automatically(
     let definition = runtime_models
         .resolve(target)
         .ok_or(AutomaticContextCompactionError::Configuration)?;
-    let automatic_content_byte_target = u64::from(definition.context_window_tokens())
+    let compaction_prompt = model_configuration.compaction_prompt();
+    let prompt_bytes = u64::try_from(compaction_prompt.len())
+        .map_err(|_| AutomaticContextCompactionError::Configuration)?;
+    let automatic_input_byte_budget = u64::from(definition.context_window_tokens())
         .checked_sub(u64::from(definition.max_output_tokens()))
-        .and_then(NonZeroU64::new)
+        .and_then(|available| available.checked_sub(prompt_bytes))
+        .filter(|available| *available > 0)
         .ok_or(AutomaticContextCompactionError::Configuration)?;
     let credential_reference = model_calls
         .resolve_session_credential_reference(session, target)
         .await
         .map_err(AutomaticContextCompactionError::Credential)?;
     let repository = ContextCompactionRepository::new(model_calls.pool().clone());
+    let preview = repository
+        .preview_automatic_range(session)
+        .await
+        .map_err(AutomaticContextCompactionError::Repository)?
+        .ok_or(AutomaticContextCompactionError::State)?;
+    let preview_positions = preview
+        .members()
+        .iter()
+        .map(|member| member.position())
+        .collect::<Vec<_>>();
+    let preview_entries = preview
+        .members()
+        .iter()
+        .map(|member| member.reference())
+        .collect::<Vec<_>>();
+    let rendered_entries = ProcessReadRepository::new(model_calls.pool().clone())
+        .read_selected_transcript_entries(&preview_positions, &preview_entries)
+        .await
+        .map_err(AutomaticContextCompactionError::Read)?;
+    let requested_through_position = automatic_context_compaction_boundary(
+        preview.members(),
+        &rendered_entries,
+        automatic_input_byte_budget,
+    )?
+    .ok_or(AutomaticContextCompactionError::InputDoesNotFit)?;
     let prepared = loop {
         let request = PrepareContextCompactionRequest {
             command: DurableCommandId::from_uuid(uuid::Uuid::now_v7()),
             session,
-            requested_through_position: None,
+            requested_through_position: Some(requested_through_position),
             automatic_for_turn: Some(turn),
-            automatic_content_byte_target: Some(automatic_content_byte_target),
             defaults_version: defaults.version(),
             selection,
             target,
@@ -7337,6 +7434,19 @@ pub(crate) async fn compact_automatically(
             return Err(AutomaticContextCompactionError::Integrity);
         }
     };
+    if u64::try_from(rendered_range.len())
+        .ok()
+        .is_none_or(|rendered_bytes| rendered_bytes > automatic_input_byte_budget)
+    {
+        fail_context_compaction_until_resolved(
+            &repository,
+            &prepared,
+            FailedContextCompactionDisposition::KnownFailed,
+        )
+        .await
+        .map_err(AutomaticContextCompactionError::Repository)?;
+        return Err(AutomaticContextCompactionError::InputDoesNotFit);
+    }
     authorize_context_compaction_until_resolved(&repository, &prepared)
         .await
         .map_err(AutomaticContextCompactionError::Repository)?;
@@ -7346,7 +7456,7 @@ pub(crate) async fn compact_automatically(
         selection: prepared.selection(),
         target: prepared.target(),
         credential_reference: prepared.credential_reference().to_owned(),
-        system_prompt: model_configuration.compaction_prompt().to_owned(),
+        system_prompt: compaction_prompt.to_owned(),
         rendered_range,
     };
     let result = match model.execute(request).await {
@@ -15446,11 +15556,12 @@ mod tests {
         acquire_inbound_frame_permit_after_input, acquire_review_command_permit,
         acquire_review_command_permit_while_buffered, acquire_snapshot_reader_permit,
         admit_snapshot_reader, admitted_user_content, blob_read_budget,
-        blob_upload_begin_preflight, canonical_review_request_digest,
-        claude_conversion_failure_disposition, codex_conversion_failure_disposition,
-        consume_snapshot_queued_update, context_compaction_failure_disposition, execute_import,
-        foreground_peer_activity, handle_append_conversation_import,
-        handle_begin_conversation_import, handle_commit_conversation_import, import_evidence,
+        blob_upload_begin_preflight, bounded_rendered_compaction_boundary,
+        canonical_review_request_digest, claude_conversion_failure_disposition,
+        codex_conversion_failure_disposition, consume_snapshot_queued_update,
+        context_compaction_failure_disposition, execute_import, foreground_peer_activity,
+        handle_append_conversation_import, handle_begin_conversation_import,
+        handle_commit_conversation_import, import_evidence,
         imported_conversation_internal_diagnostic, inspect_connection_completion,
         internal_protocol_error, map_rejection, nudge_after_process_await_rejection,
         nudge_after_process_message_rejection, nudge_delegation_issuer, nudge_delegation_wake,
@@ -15840,6 +15951,54 @@ mod tests {
         );
     }
 
+    #[test]
+    fn automatic_compaction_boundary_counts_the_rendered_json_envelope() {
+        let first = serde_json::json!({
+            "position": 1,
+            "type": "user",
+            "content": "x".repeat(90),
+        });
+        let second = serde_json::json!({
+            "position": 2,
+            "type": "assistant",
+            "content": "y".repeat(90),
+        });
+        let first_bytes = u64::try_from(
+            serde_json::to_vec(&first)
+                .expect("the fixture JSON is serializable")
+                .len(),
+        )
+        .expect("the fixture length fits u64");
+        let second_bytes = u64::try_from(
+            serde_json::to_vec(&second)
+                .expect("the fixture JSON is serializable")
+                .len(),
+        )
+        .expect("the fixture length fits u64");
+        let first_array_bytes = first_bytes + 2;
+
+        assert_eq!(
+            bounded_rendered_compaction_boundary(
+                &[first_bytes, second_bytes],
+                &[(11, true), (12, true)],
+                first_array_bytes,
+            ),
+            Some(11)
+        );
+    }
+
+    #[test]
+    fn automatic_compaction_boundary_never_crosses_the_model_budget_for_a_tool_exchange() {
+        assert_eq!(
+            bounded_rendered_compaction_boundary(
+                &[60, 100, 100],
+                &[(21, true), (22, false), (23, true)],
+                170,
+            ),
+            Some(21)
+        );
+    }
+
     #[test]
     fn snapshot_delta_boundary_consumes_only_the_queued_prefix() {
         let mut queued = 2;
diff --git a/apps/signalboxd/tests/process_protocol_runtime.rs b/apps/signalboxd/tests/process_protocol_runtime.rs
index 8094467469..43d27a0a23 100644
--- a/apps/signalboxd/tests/process_protocol_runtime.rs
+++ b/apps/signalboxd/tests/process_protocol_runtime.rs
@@ -2075,7 +2075,6 @@ fn direct_compaction_request(
         session: SessionId::from_uuid(session_id.into_uuid()),
         requested_through_position,
         automatic_for_turn: None,
-        automatic_content_byte_target: None,
         defaults_version: SessionConfigurationDefaultsVersion::first(),
         selection: DirectModelSelection::from_uuid(Uuid::from_u128(1)),
         target: ResolvedProviderTarget::naming(ProviderModelIdentity::from_uuid(Uuid::from_u128(
@@ -7761,7 +7760,6 @@ async fn s01_s03_inv005_inv014_inv015_explicit_compaction_survives_restart_and_p
             session: SessionId::from_uuid(session_id.into_uuid()),
             requested_through_position: None,
             automatic_for_turn: None,
-            automatic_content_byte_target: None,
             defaults_version: SessionConfigurationDefaultsVersion::first(),
             selection: DirectModelSelection::from_uuid(Uuid::from_u128(1)),
             target: ResolvedProviderTarget::naming(ProviderModelIdentity::from_uuid(
@@ -7809,7 +7807,6 @@ async fn s01_s03_inv005_inv014_inv015_explicit_compaction_survives_restart_and_p
             session: SessionId::from_uuid(session_id.into_uuid()),
             requested_through_position: None,
             automatic_for_turn: None,
-            automatic_content_byte_target: None,
             defaults_version: SessionConfigurationDefaultsVersion::first(),
             selection: DirectModelSelection::from_uuid(Uuid::from_u128(1)),
             target: ResolvedProviderTarget::naming(ProviderModelIdentity::from_uuid(
@@ -8203,7 +8200,7 @@ async fn s01_s03_inv014_inv015_automatic_guard_compacts_before_ordinary_send()
             .replace("max_output_tokens = 256", "max_output_tokens = 1")
             .replace(
                 "context_window_tokens = 200000",
-                "context_window_tokens = 5",
+                "context_window_tokens = 4096",
             ),
     )?;
     let ordinary_runtime = RecordingCountedScriptedModel::following(
@@ -8212,7 +8209,7 @@ async fn s01_s03_inv014_inv015_automatic_guard_compacts_before_ordinary_send()
             "automatic guard current reply",
             TokenUsage::unreported(),
         )],
-        [40, 4],
+        [8192, 4],
     );
     let summary_text = String::from("automatic guard summary");
     let summary_runtime = ScriptedModel::single(completed_script(
@@ -8249,10 +8246,6 @@ async fn s01_s03_inv014_inv015_automatic_guard_compacts_before_ordinary_send()
                 signalbox_model_runtime::ConversationRole::User,
                 format!("Signalbox prior-conversation summary:\n{summary_text}"),
             ),
-            (
-                signalbox_model_runtime::ConversationRole::Assistant,
-                first_assistant.clone(),
-            ),
             (
                 signalbox_model_runtime::ConversationRole::User,
                 second_user.clone(),
@@ -8308,7 +8301,7 @@ async fn s01_s03_inv014_inv015_reported_usage_rechecks_compaction_headroom()
     )
     .await?;
     let saturated_usage = TokenUsage {
-        input_tokens: Some(50),
+        input_tokens: Some(5000),
         output_tokens: Some(0),
         cache_creation_input_tokens: None,
         cache_read_input_tokens: None,
@@ -8342,7 +8335,7 @@ async fn s01_s03_inv014_inv015_reported_usage_rechecks_compaction_headroom()
             .replace("max_output_tokens = 256", "max_output_tokens = 1")
             .replace(
                 "context_window_tokens = 200000",
-                "context_window_tokens = 50",
+                "context_window_tokens = 4096",
             ),
     )?;
     let runtime_models = configuration.runtime_model_catalog();
@@ -8450,11 +8443,11 @@ async fn s01_s03_inv014_inv015_failed_automatic_compaction_closes_turn_call_free
             .replace("max_output_tokens = 256", "max_output_tokens = 1")
             .replace(
                 "context_window_tokens = 200000",
-                "context_window_tokens = 5",
+                "context_window_tokens = 4096",
             ),
     )?;
     let ordinary_runtime =
-        RecordingCountedScriptedModel::following(std::iter::empty::<Script>(), [40, 40, 40]);
+        RecordingCountedScriptedModel::following(std::iter::empty::<Script>(), [8192, 8192, 8192]);
     let ordinary_probe = ordinary_runtime.clone();
     let summary_runtime = ScriptedModel::single(Script::delivering(
         TerminalEvidence::ProviderError(ProviderErrorEvidence {
diff --git a/crates/persistence/src/context_compaction.rs b/crates/persistence/src/context_compaction.rs
index 2025bc749d..679cb4f41b 100644
--- a/crates/persistence/src/context_compaction.rs
+++ b/crates/persistence/src/context_compaction.rs
@@ -1,6 +1,6 @@
 //! Durable explicit context-compaction command and call lifecycle.
 
-use std::{collections::BTreeMap, error::Error, fmt, num::NonZeroU64};
+use std::{collections::BTreeMap, error::Error, fmt};
 
 use rust_decimal::Decimal;
 use signalbox_application::{ClassifyOperatorFailure, OperatorFailureClass};
@@ -34,8 +34,6 @@ pub struct PrepareContextCompactionRequest {
     pub requested_through_position: Option<u64>,
     /// Queued turn whose context guard owns this automatic attempt.
     pub automatic_for_turn: Option<TurnId>,
-    /// Model-derived content-byte target for an automatic summary prefix.
-    pub automatic_content_byte_target: Option<NonZeroU64>,
     /// Current defaults epoch observed before entering the transaction.
     pub defaults_version: SessionConfigurationDefaultsVersion,
     /// Current direct model selection after freezing any alias.
@@ -78,6 +76,50 @@ pub struct PreparedContextCompaction {
     result_frontier: ContextFrontierId,
 }
 
+/// Read-only model-visible inventory used to choose an automatic boundary.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct AutomaticContextCompactionPreview {
+    source_frontier: ContextFrontierId,
+    members: Box<[AutomaticContextCompactionPreviewMember]>,
+}
+
+impl AutomaticContextCompactionPreview {
+    /// Returns the complete frontier whose projected members were observed.
+    pub const fn source_frontier(&self) -> ContextFrontierId {
+        self.source_frontier
+    }
+
+    /// Returns projected members in model-visible order.
+    pub fn members(&self) -> &[AutomaticContextCompactionPreviewMember] {
+        &self.members
+    }
+}
+
+/// One projected entry and whether it closes every preceding tool exchange.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct AutomaticContextCompactionPreviewMember {
+    position: u64,
+    reference: SemanticTranscriptEntryRef,
+    safe_boundary: bool,
+}
+
+impl AutomaticContextCompactionPreviewMember {
+    /// Returns the entry's one-based physical frontier position.
+    pub const fn position(self) -> u64 {
+        self.position
+    }
+
+    /// Returns the exact semantic entry reference.
+    pub const fn reference(self) -> SemanticTranscriptEntryRef {
+        self.reference
+    }
+
+    /// Reports whether a summary through this entry closes all tool exchanges.
+    pub const fn is_safe_boundary(self) -> bool {
+        self.safe_boundary
+    }
+}
+
 impl PreparedContextCompaction {
     /// Returns the command identity.
     pub const fn command(&self) -> DurableCommandId {
@@ -285,6 +327,34 @@ impl ContextCompactionRepository {
         .await
     }
 
+    /// Reads the current projected frontier without claiming a compaction.
+    ///
+    /// Automatic callers render this immutable inventory before choosing the
+    /// exact boundary they later commit. The prepare transaction reselects the
+    /// frontier and validates that boundary before any provider interaction.
+    pub async fn preview_automatic_range(
+        &self,
+        session: SessionId,
+    ) -> Result<Option<AutomaticContextCompactionPreview>, ContextCompactionRepositoryError> {
+        let mut transaction = self.pool.begin().await?;
+        let source = load_compaction_source(&mut transaction, session).await?;
+        let preview = match source {
+            Some(source) if source.member_count > 0 => {
+                let visible =
+                    load_projected_frontier_members(&mut transaction, session, source.frontier)
+                        .await?;
+                let members = preview_members(&visible)?;
+                Some(AutomaticContextCompactionPreview {
+                    source_frontier: source.frontier,
+                    members: members.into_boxed_slice(),
+                })
+            }
+            Some(_) | None => None,
+        };
+        transaction.rollback().await?;
+        Ok(preview)
+    }
+
     /// Commits InFlight before any provider interaction begins.
     ///
     /// An exact InFlight replay proves that an earlier ambiguous commit landed,
@@ -775,13 +845,56 @@ impl PreparedContextCompaction {
     }
 }
 
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct CompactionSource {
+    frontier: ContextFrontierId,
+    member_count: u64,
+}
+
+async fn load_compaction_source(
+    transaction: &mut sqlx::Transaction<'_, sqlx::Postgres>,
+    session: SessionId,
+) -> Result<Option<CompactionSource>, ContextCompactionRepositoryError> {
+    let row = sqlx::query(
+        "WITH candidate (frontier_id) AS (
+            SELECT turn_lifecycle_effective_terminal_frontier(session_id, turn_id)
+              FROM turn_lifecycle
+             WHERE session_id = $1
+               AND (state_kind = 'terminal' OR delegation_runtime_terminal)
+            UNION ALL
+            SELECT seed_context_frontier_id
+              FROM imported_session_seed
+             WHERE session_id = $1
+            UNION ALL
+            SELECT result_frontier_id
+              FROM context_compaction
+             WHERE session_id = $1
+         )
+         SELECT frontier.context_frontier_id, frontier.member_count
+           FROM candidate
+           JOIN context_frontier AS frontier
+             ON frontier.owning_session_id = $1
+            AND frontier.context_frontier_id = candidate.frontier_id
+          ORDER BY frontier.member_count DESC
+          LIMIT 1",
+    )
+    .bind(session_id_to_uuid(session))
+    .fetch_optional(&mut **transaction)
+    .await?;
+    row.map(|row| {
+        Ok(CompactionSource {
+            frontier: ContextFrontierId::from_uuid(row.try_get("context_frontier_id")?),
+            member_count: decode_u64(row.try_get("member_count")?, "source member count")?,
+        })
+    })
+    .transpose()
+}
+
 async fn prepare_in_transaction(
     transaction: &mut sqlx::Transaction<'_, sqlx::Postgres>,
     request: &PrepareContextCompactionRequest,
 ) -> Result<(bool, PrepareContextCompactionOutcome), ContextCompactionRepositoryError> {
-    if request.automatic_for_turn.is_some() != request.automatic_content_byte_target.is_some()
-        || request.automatic_for_turn.is_some() && request.requested_through_position.is_some()
-    {
+    if request.automatic_for_turn.is_some() && request.requested_through_position.is_none() {
         return Ok((false, PrepareContextCompactionOutcome::InvalidBoundary));
     }
     match lookup_command_on_connection(
@@ -956,38 +1069,12 @@ async fn prepare_in_transaction(
     if busy {
         return Ok((false, PrepareContextCompactionOutcome::Busy));
     }
-    let source = sqlx::query(
-        "WITH candidate (frontier_id) AS (
-            SELECT turn_lifecycle_effective_terminal_frontier(session_id, turn_id)
-              FROM turn_lifecycle
-             WHERE session_id = $1
-               AND (state_kind = 'terminal' OR delegation_runtime_terminal)
-            UNION ALL
-            SELECT seed_context_frontier_id
-              FROM imported_session_seed
-             WHERE session_id = $1
-            UNION ALL
-            SELECT result_frontier_id
-              FROM context_compaction
-             WHERE session_id = $1
-         )
-         SELECT frontier.context_frontier_id, frontier.member_count
-           FROM candidate
-           JOIN context_frontier AS frontier
-             ON frontier.owning_session_id = $1
-            AND frontier.context_frontier_id = candidate.frontier_id
-          ORDER BY frontier.member_count DESC
-          LIMIT 1",
-    )
-    .bind(session_id_to_uuid(request.session))
-    .fetch_optional(&mut **transaction)
-    .await?;
+    let source = load_compaction_source(transaction, request.session).await?;
     let Some(source) = source else {
         return Ok((false, PrepareContextCompactionOutcome::NoBoundary));
     };
-    let source_frontier = ContextFrontierId::from_uuid(source.try_get("context_frontier_id")?);
-    let member_count = decode_u64(source.try_get("member_count")?, "source member count")?;
-    if member_count == 0 {
+    let source_frontier = source.frontier;
+    if source.member_count == 0 {
         return Ok((false, PrepareContextCompactionOutcome::NoBoundary));
     }
     let predecessor = sqlx::query(
@@ -1017,10 +1104,7 @@ async fn prepare_in_transaction(
         Some(position) => visible
             .iter()
             .position(|member| member.position == position),
-        None => match request.automatic_content_byte_target {
-            Some(target) => bounded_safe_boundary(&visible, target.get()),
-            None => latest_safe_boundary(&visible),
-        },
+        None => latest_safe_boundary(&visible),
     };
     let Some(through_index) = through_index else {
         return Ok((false, PrepareContextCompactionOutcome::InvalidBoundary));
@@ -1189,7 +1273,6 @@ struct ProjectedFrontierMember {
     position: u64,
     reference: SemanticTranscriptEntryRef,
     payload_kind: String,
-    content_bytes: u64,
     summary_range: Option<(SemanticTranscriptEntryRef, SemanticTranscriptEntryRef)>,
 }
 
@@ -1201,33 +1284,6 @@ async fn load_projected_frontier_members(
     let rows = sqlx::query(
         "SELECT member.member_position, member.source_session_id,
                 member.semantic_entry_id, entry.payload_kind,
-                CASE entry.payload_kind
-                    WHEN 'imported_entry' THEN
-                        COALESCE(octet_length(imported.content_encoding), 0)
-                    WHEN 'origin_accepted_input' THEN
-                        COALESCE(octet_length(input.content_text), 0)
-                    WHEN 'steering_accepted_input' THEN
-                        COALESCE(octet_length(input.content_text), 0)
-                    WHEN 'context_summary' THEN
-                        COALESCE(octet_length(entry.context_summary_value), 0)
-                    WHEN 'assistant_text' THEN
-                        COALESCE(octet_length(entry.assistant_text_value), 0)
-                    WHEN 'assistant_tool_use' THEN
-                        COALESCE(octet_length(request.tool_name), 0)
-                        + COALESCE(octet_length(request.arguments_text), 0)
-                    WHEN 'tool_execution_result' THEN
-                        COALESCE(octet_length(attempt.result_text), 0)
-                        + COALESCE(octet_length(attempt.error_detail), 0)
-                    WHEN 'tool_denied' THEN
-                        COALESCE(octet_length(decision.denial_reason), 0)
-                    WHEN 'delegated_task' THEN
-                        COALESCE(octet_length(task.task_content), 0)
-                    WHEN 'delegation_message' THEN
-                        COALESCE(octet_length(message.content_text), 0)
-                    WHEN 'delegation_result' THEN
-                        COALESCE(octet_length(child_result.content_text), 0)
-                    ELSE 0
-                END::numeric AS content_bytes,
                 entry.context_summary_first_source_session_id,
                 entry.context_summary_first_entry_id,
                 entry.context_summary_through_source_session_id,
@@ -1236,29 +1292,6 @@ async fn load_projected_frontier_members(
            JOIN semantic_transcript_entry AS entry
              ON entry.source_session_id = member.source_session_id
             AND entry.semantic_entry_id = member.semantic_entry_id
-           LEFT JOIN accepted_input AS input
-             ON input.accepted_input_id = entry.origin_accepted_input_id
-            AND input.session_id = entry.source_session_id
-           LEFT JOIN imported_transcript_entry AS imported
-             ON imported.imported_conversation_id = entry.imported_conversation_id
-            AND imported.imported_transcript_entry_id =
-                entry.imported_transcript_entry_id
-           LEFT JOIN tool_request AS request
-             ON request.request_id = entry.assistant_tool_request_id
-            AND request.session_id = entry.source_session_id
-           LEFT JOIN tool_attempt AS attempt
-             ON attempt.attempt_id = entry.tool_result_attempt_id
-            AND attempt.session_id = entry.source_session_id
-           LEFT JOIN tool_approval_decision AS decision
-             ON decision.request_id = entry.tool_result_request_id
-           LEFT JOIN session_delegation_initial_task AS task
-             ON task.child_session_id = entry.source_session_id
-            AND task.semantic_entry_id = entry.semantic_entry_id
-           LEFT JOIN session_message AS message
-             ON message.message_id = entry.delegation_message_id
-           LEFT JOIN session_child_result AS child_result
-             ON child_result.spawning_tool_request_id =
-                entry.delegation_result_spawning_tool_request_id
           WHERE member.owning_session_id = $1
             AND member.context_frontier_id = $2
           ORDER BY member.member_position",
@@ -1307,7 +1340,6 @@ async fn load_projected_frontier_members(
                 SemanticTranscriptEntryId::from_uuid(row.try_get("semantic_entry_id")?),
             ),
             payload_kind,
-            content_bytes: decode_u64(row.try_get("content_bytes")?, "entry content bytes")?,
             summary_range,
         });
     }
@@ -1386,36 +1418,34 @@ fn range_closes_tool_exchanges(members: &[ProjectedFrontierMember]) -> bool {
     open_requests == 0
 }
 
-fn latest_safe_boundary(members: &[ProjectedFrontierMember]) -> Option<usize> {
-    let mut latest = None;
-    let mut open_requests = 0usize;
-    for (index, member) in members.iter().enumerate() {
+fn preview_members(
+    members: &[ProjectedFrontierMember],
+) -> Result<Vec<AutomaticContextCompactionPreviewMember>, ContextCompactionRepositoryError> {
+    let mut open_requests = 0_usize;
+    let mut preview = Vec::with_capacity(members.len());
+    for member in members {
         match member.payload_kind.as_str() {
             "assistant_tool_use" => open_requests = open_requests.saturating_add(1),
             "tool_execution_result" | "tool_denied" | "tool_closed_by_turn_end" => {
-                open_requests = open_requests.checked_sub(1)?;
+                open_requests = open_requests.checked_sub(1).ok_or(
+                    ContextCompactionCorruption::Inconsistent("context compaction tool exchange"),
+                )?;
             }
             _ => {}
         }
-        if open_requests == 0 {
-            latest = Some(index);
-        }
+        preview.push(AutomaticContextCompactionPreviewMember {
+            position: member.position,
+            reference: member.reference,
+            safe_boundary: open_requests == 0,
+        });
     }
-    latest
+    Ok(preview)
 }
 
-fn bounded_safe_boundary(
-    members: &[ProjectedFrontierMember],
-    content_byte_target: u64,
-) -> Option<usize> {
-    let total_weight = members.iter().fold(0_u64, |total, member| {
-        total.saturating_add(member.content_bytes.max(1))
-    });
-    let target_weight = total_weight.div_ceil(2).min(content_byte_target);
-    let mut through_weight = 0_u64;
-    let mut open_requests = 0_usize;
+fn latest_safe_boundary(members: &[ProjectedFrontierMember]) -> Option<usize> {
+    let mut latest = None;
+    let mut open_requests = 0usize;
     for (index, member) in members.iter().enumerate() {
-        through_weight = through_weight.saturating_add(member.content_bytes.max(1));
         match member.payload_kind.as_str() {
             "assistant_tool_use" => open_requests = open_requests.saturating_add(1),
             "tool_execution_result" | "tool_denied" | "tool_closed_by_turn_end" => {
@@ -1423,11 +1453,11 @@ fn bounded_safe_boundary(
             }
             _ => {}
         }
-        if through_weight >= target_weight && open_requests == 0 {
-            return Some(index);
+        if open_requests == 0 {
+            latest = Some(index);
         }
     }
-    None
+    latest
 }
 
 fn required<T>(
@@ -1573,7 +1603,7 @@ impl From<ContextCompactionCorruption> for ContextCompactionRepositoryError {
 #[cfg(test)]
 mod tests {
     use super::{
-        ProjectedFrontierMember, Uuid, bounded_safe_boundary, latest_safe_boundary,
+        ProjectedFrontierMember, Uuid, latest_safe_boundary, preview_members,
         project_frontier_members,
     };
     use signalbox_domain::{SemanticTranscriptEntryId, SemanticTranscriptEntryRef, SessionId};
@@ -1586,19 +1616,10 @@ mod tests {
     }
 
     fn ordinary(position: u64, reference: SemanticTranscriptEntryRef) -> ProjectedFrontierMember {
-        weighted_ordinary(position, reference, 1)
-    }
-
-    fn weighted_ordinary(
-        position: u64,
-        reference: SemanticTranscriptEntryRef,
-        content_bytes: u64,
-    ) -> ProjectedFrontierMember {
         ProjectedFrontierMember {
             position,
             reference,
             payload_kind: String::from("origin_accepted_input"),
-            content_bytes,
             summary_range: None,
         }
     }
@@ -1613,7 +1634,6 @@ mod tests {
             position,
             reference,
             payload_kind: String::from("context_summary"),
-            content_bytes: 1,
             summary_range: Some((first, through)),
         }
     }
@@ -1666,102 +1686,40 @@ mod tests {
     }
 
     #[test]
-    fn automatic_boundary_selects_first_safe_member_at_half_weight() {
-        let visible = vec![
-            ordinary(1, entry(0x7021)),
-            ordinary(2, entry(0x7022)),
-            ordinary(3, entry(0x7023)),
-            ordinary(4, entry(0x7024)),
-        ];
-
-        assert_eq!(bounded_safe_boundary(&visible, u64::MAX), Some(1));
-    }
-
-    #[test]
-    fn automatic_boundary_closes_a_tool_exchange_crossing_the_midpoint() {
+    fn automatic_preview_marks_only_closed_tool_exchange_boundaries_safe() {
         let visible = vec![
             ProjectedFrontierMember {
                 position: 1,
                 reference: entry(0x7031),
                 payload_kind: "assistant_tool_use".to_owned(),
-                content_bytes: 1,
                 summary_range: None,
             },
             ProjectedFrontierMember {
                 position: 2,
                 reference: entry(0x7032),
                 payload_kind: "assistant_tool_use".to_owned(),
-                content_bytes: 1,
                 summary_range: None,
             },
             ProjectedFrontierMember {
                 position: 3,
                 reference: entry(0x7033),
                 payload_kind: "tool_execution_result".to_owned(),
-                content_bytes: 1,
                 summary_range: None,
             },
             ProjectedFrontierMember {
                 position: 4,
                 reference: entry(0x7034),
                 payload_kind: "tool_execution_result".to_owned(),
-                content_bytes: 1,
                 summary_range: None,
             },
             ordinary(5, entry(0x7035)),
-            ordinary(6, entry(0x7036)),
-        ];
-
-        assert_eq!(bounded_safe_boundary(&visible, u64::MAX), Some(3));
-    }
-
-    #[test]
-    fn automatic_boundary_consumes_half_of_a_byte_heavy_tail() {
-        let visible = vec![
-            weighted_ordinary(1, entry(0x7041), 1),
-            weighted_ordinary(2, entry(0x7042), 1),
-            weighted_ordinary(3, entry(0x7043), 100),
-            weighted_ordinary(4, entry(0x7044), 100),
-        ];
-
-        assert_eq!(bounded_safe_boundary(&visible, u64::MAX), Some(2));
-    }
-
-    #[test]
-    fn automatic_boundary_stops_at_the_model_derived_content_budget() {
-        let visible = vec![
-            weighted_ordinary(1, entry(0x7051), 100),
-            weighted_ordinary(2, entry(0x7052), 100),
-            weighted_ordinary(3, entry(0x7053), 100),
-            weighted_ordinary(4, entry(0x7054), 100),
-            weighted_ordinary(5, entry(0x7055), 100),
-            weighted_ordinary(6, entry(0x7056), 100),
-        ];
-
-        assert_eq!(bounded_safe_boundary(&visible, 200), Some(1));
-    }
-
-    #[test]
-    fn automatic_boundary_closes_a_tool_exchange_crossing_the_model_budget() {
-        let visible = vec![
-            weighted_ordinary(1, entry(0x7061), 100),
-            ProjectedFrontierMember {
-                position: 2,
-                reference: entry(0x7062),
-                payload_kind: "assistant_tool_use".to_owned(),
-                content_bytes: 100,
-                summary_range: None,
-            },
-            ProjectedFrontierMember {
-                position: 3,
-                reference: entry(0x7063),
-                payload_kind: "tool_execution_result".to_owned(),
-                content_bytes: 100,
-                summary_range: None,
-            },
-            weighted_ordinary(4, entry(0x7064), 100),
         ];
+        let preview = preview_members(&visible).expect("the tool exchange is balanced");
 
-        assert_eq!(bounded_safe_boundary(&visible, 150), Some(2));
+        assert!(!preview[0].is_safe_boundary());
+        assert!(!preview[1].is_safe_boundary());
+        assert!(!preview[2].is_safe_boundary());
+        assert!(preview[3].is_safe_boundary());
+        assert!(preview[4].is_safe_boundary());
     }
 }
diff --git a/crates/persistence/tests/goal_postgres.rs b/crates/persistence/tests/goal_postgres.rs
index e1b56dbba2..5f27cef00c 100644
--- a/crates/persistence/tests/goal_postgres.rs
+++ b/crates/persistence/tests/goal_postgres.rs
@@ -4320,7 +4320,6 @@ async fn s18_inv015_inv032_logically_terminal_child_admits_compaction() -> Resul
             session: session(bound_child),
             requested_through_position: None,
             automatic_for_turn: None,
-            automatic_content_byte_target: None,
             defaults_version: SessionConfigurationDefaultsVersion::first(),
             selection: DirectModelSelection::from_uuid(Uuid::from_u128(0xfa22)),
             target: ResolvedProviderTarget::naming(ProviderModelIdentity::from_uuid(
diff --git a/crates/persistence/tests/postgres_integration/model_call_usage_and_interrupts.rs b/crates/persistence/tests/postgres_integration/model_call_usage_and_interrupts.rs
index 7c8cba9685..eae73401ff 100644
--- a/crates/persistence/tests/postgres_integration/model_call_usage_and_interrupts.rs
+++ b/crates/persistence/tests/postgres_integration/model_call_usage_and_interrupts.rs
@@ -271,7 +271,6 @@ async fn context_compaction_usage_is_available_to_pre_activation_compaction()
             session: fixture.session,
             requested_through_position: Some(1),
             automatic_for_turn: None,
-            automatic_content_byte_target: None,
             defaults_version: SessionConfigurationDefaultsVersion::first(),
             selection: DirectModelSelection::from_uuid(Uuid::from_u128(seed + 5)),
             target,
diff --git a/docs/open-questions.md b/docs/open-questions.md
index fe6995eb8c..d74f5a6b6f 100644
--- a/docs/open-questions.md
+++ b/docs/open-questions.md
@@ -142,48 +142,6 @@ specification diff. Accepted cross-component and wire contracts live in the
   whether an interrupt-only path may bypass `StopRequested` remains undecided.
   Later scope. (S07)
 
-### Automatic context compaction
-
-This is a blocking condition rather than an open design question. Automatic
-context compaction ships with a known defect on its primary path, accepted on
-the grounds that the code sits unused until something depends on it. That ground
-disappears the moment anything relies on it, so the condition is recorded here
-rather than only in the review thread that raised it.
-
-**The defect.** The compaction request wraps accumulated plain-text history in
-JSON with provenance metadata and reserves the same `max_output_tokens` as the
-ordinary call, and is never counted against `context_window_tokens`. It can
-therefore be *larger* than the input that already overflowed the window. The
-provider may reject the summary call for context overflow; that call is then
-terminalized, and the per-turn automatic marker prevents a second attempt.
-
-**The consequence.** A session that crosses its context window has its queued
-turn stalled with its single automatic attempt consumed and no path forward
-inside the running daemon — which is the exact situation automatic compaction
-exists to rescue. Nothing durable is corrupted, no summary boundary is written
-wrong, and no transcript entries are lost: the failed call is recorded as
-legitimate terminal non-Completed evidence. The session is stalled, not damaged.
-
-**The trigger is the common case, not an edge of it.** Compaction is invoked
-precisely when history is large. History large enough that wrapping it in JSON
-with metadata overflows the window is the middle of that condition rather than
-its boundary.
-
-**The condition.** Automatic context compaction must not be relied on until the
-summary call is guaranteed to fit. Anything built on top of it, and any workflow
-that assumes a long-running session will rescue itself, is blocked on that fix
-rather than merely improved by it. Explicit compaction is unaffected by this
-particular defect.
-
-**Shape of the fix.** Count the summary request against `context_window_tokens`
-before triggering it, or select a compaction strategy guaranteed to fit — for
-example bounding the history actually wrapped rather than reserving the full
-`max_output_tokens` on top of unbounded input. Scheduled as a follow-up pull
-request against a quiet `main` rather than inside the compaction stack.
-
-Raised as a review finding and dispositioned with this condition attached:
-https://github.com/KeenWill/signalbox/pull/314#discussion_r3670652441
-
 ## Session organization, visibility, and retention
 
 - **Creation-attributed default visibility.** The implemented visibility and
diff --git a/docs/spec/model-call-execution.md b/docs/spec/model-call-execution.md
index 5f93b59eb0..0ebbd2957d 100644
--- a/docs/spec/model-call-execution.md
+++ b/docs/spec/model-call-execution.md
@@ -16,9 +16,9 @@ headroom is verified against this PR
 successor frontier is verified against this PR
 (`agent/daemon-live-headroom-disjoint-suffix`). Dedicated-compaction usage as
 the next queued-turn baseline is verified against this PR
-(`agent/daemon-live-compaction-source-headroom`). Automatic compaction's
-model-bounded content-weighted boundary is verified against this PR
-(`agent/daemon-live-model-bounded-compaction`). Codex advisory output
+(`agent/daemon-live-compaction-source-headroom`). Automatic compaction's exact
+model-visible input boundary is verified against this PR
+(`agent/daemon-live-compaction-rendered-input-bound`). Codex advisory output
 reservation behavior is re-verified against this PR
 (`agent/daemon-live-codex-output-reservation`). Failed automatic-compaction
 terminal closure is verified against this PR
@@ -407,16 +407,18 @@ closed. The daemon retries database and ambiguous-commit outcomes at this seam;
 it does not start provider interaction until authorization is resolved. The
 automatic preparation path retries transient database failures while loading its
 selected transcript range, retaining the live `Prepared` call as provably unsent
-rather than consuming that queued turn's sole automatic attempt. It weights each
-model-visible entry by its durable content bytes, with unit weight for an empty
-entry, and selects the first safe boundary at or beyond the smaller of half the
-total weight and the selected model's context window after its configured output
-reservation. An open tool exchange extends the prefix through its first safe
-closing boundary. This keeps a few large entries from remaining indefinitely in
-a count-light tail without making the summary request repeat a complete
-oversized input merely because the visible history kept growing; an indivisible
-entry or tool exchange can still cross the derived target. An integrity failure
-still terminalizes the unsent call. After a successful provider result, the
+rather than consuming that queued turn's sole automatic attempt. Before that
+claim, it reads the projected model-visible inventory and renders each entry in
+the same compact JSON shape the summary model receives. It selects the first
+closed tool-exchange boundary at or beyond half the rendered range only while
+that exact JSON prefix, the configured compaction prompt, and the configured
+output reservation fit the selected model's context window. If an open tool
+exchange would cross the budget, selection falls back to the latest preceding
+safe boundary; no provider call is prepared when even the first safe prefix
+cannot fit. Preparation records that exact position. A second rendering after
+the claim prevents a concurrent frontier change from sending a range outside the
+same bound: an oversized mismatch terminalizes the still-unsent dedicated call.
+An integrity failure does the same. After a successful provider result, the
 daemon retains the summary and its usage in memory until the exact completion is
 durably applied or replayed.