deepstrike 0.2.75__tar.gz → 0.2.77__tar.gz

{deepstrike-0.2.75 → deepstrike-0.2.77}/Cargo.lock

@@ -254,7 +254,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-core"
-version = "0.2.75"
+version = "0.2.77"
 dependencies = [
  "compact_str",
  "deepstrike-tokenizer",
@@ -268,7 +268,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-node"
-version = "0.2.75"
+version = "0.2.77"
 dependencies = [
  "compact_str",
  "deepstrike-core",
@@ -280,7 +280,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-py"
-version = "0.2.75"
+version = "0.2.77"
 dependencies = [
  "compact_str",
  "deepstrike-core",
@@ -291,7 +291,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-sdk"
-version = "0.2.75"
+version = "0.2.77"
 dependencies = [
  "async-stream",
  "async-trait",
@@ -328,7 +328,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-tokenizer"
-version = "0.2.75"
+version = "0.2.77"
 dependencies = [
  "pretty_assertions",
  "tiktoken-rs",
@@ -336,7 +336,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-wasm"
-version = "0.2.75"
+version = "0.2.77"
 dependencies = [
  "compact_str",
  "deepstrike-core",

{deepstrike-0.2.75 → deepstrike-0.2.77}/Cargo.toml

@@ -3,13 +3,13 @@ resolver = "2"
 members = ["crates/deepstrike-core", "crates/deepstrike-tokenizer", "crates/deepstrike-py"]
 
 [workspace.package]
-version = "0.2.75"
+version = "0.2.77"
 edition = "2024"
 repository = "https://github.com/kongusen/deepstrike"
 
 [workspace.dependencies]
-deepstrike-core = { path = "crates/deepstrike-core", version = "0.2.75" }
-deepstrike-tokenizer = { path = "crates/deepstrike-tokenizer", version = "0.2.75" }
+deepstrike-core = { path = "crates/deepstrike-core", version = "0.2.77" }
+deepstrike-tokenizer = { path = "crates/deepstrike-tokenizer", version = "0.2.77" }
 notify = "6"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"

{deepstrike-0.2.75 → deepstrike-0.2.77}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepstrike
-Version: 0.2.75
+Version: 0.2.77
 Requires-Dist: httpx>=0.27
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: anyio>=4.0

{deepstrike-0.2.75 → deepstrike-0.2.77}/crates/deepstrike-core/src/context/manager.rs

@@ -367,11 +367,14 @@ impl ContextManager {
     /// from *this* value, so it must NOT discount paged content (else collapse → rho drops →
     /// un-collapse would oscillate).
     pub fn rho(&self) -> f64 {
-        self.pressure.pressure(
+        let observed = self.pressure.pressure(
             &self.partitions,
             &self.engine,
             self.last_observed_prompt_tokens,
-        )
+        );
+        // A provider sees a selected projection, not the entire resident history. Its smaller
+        // count must not suppress compaction while the unselected history still triggers renewal.
+        observed.max(self.pressure.pressure(&self.partitions, &self.engine, None))
     }
 
     pub fn set_observed_prompt_tokens(&mut self, tokens: u32) {
@@ -427,6 +430,10 @@ impl ContextManager {
             target_tokens,
             &self.engine,
         );
+        if result.0 > 0 || !result.2.is_empty() {
+            // The measurement describes the request before this rewrite, not the new context.
+            self.last_observed_prompt_tokens = None;
+        }
         if let Some(ts) = now_ms {
             self.last_compact_ms = Some(ts);
         }
@@ -475,6 +482,7 @@ impl ContextManager {
             .renewal
             .renew(&self.partitions, self.max_tokens, &self.engine);
         self.sprint += 1;
+        self.last_observed_prompt_tokens = None;
         // History was rebuilt wholesale — drop handles anchored to messages it no longer carries,
         // and start a fresh collapse generation (P0-C) since the whole prefix changed.
         self.prune_orphaned_handles();
@@ -1250,6 +1258,20 @@ mod tests {
     use crate::types::message::CoreMessage;
     use crate::types::skill::SkillMetadata;
 
+    #[test]
+    fn low_provider_usage_does_not_hide_resident_history_pressure() {
+        let mut mgr = ContextManager::with_config(
+            1_000,
+            ContextConfig::default(),
+            ContextTokenEngine::char_approx(),
+        );
+        mgr.push_history(CoreMessage::user("large history"), 1_100);
+        mgr.set_observed_prompt_tokens(10);
+        assert_eq!(mgr.should_compress(), PressureAction::AutoCompact);
+        mgr.compress(PressureAction::AutoCompact);
+        assert!(!mgr.should_renew());
+    }
+
     #[test]
     fn preparation_freezes_state_plan_and_render_identity() {
         let mut mgr = ContextManager::new(100_000);

{deepstrike-0.2.75 → deepstrike-0.2.77}/crates/deepstrike-core/src/context/renewal.rs

@@ -61,31 +61,25 @@ impl RenewalPolicy {
         // History: carry recent turns up to carryover budget.
         let carryover_budget = config.carryover_tokens(max_tokens);
         let mut remaining = carryover_budget;
-        let mut carried: Vec<_> = partitions
-            .history
-            .messages
-            .iter()
-            .enumerate()
-            .rev()
-            .take_while(|(index, _msg)| {
-                let t = partitions.history.measured_tokens(*index, engine);
-                if t <= remaining {
-                    remaining = remaining.saturating_sub(t);
-                    true
-                } else {
-                    false
-                }
-            })
-            .map(|(index, msg)| {
-                (
-                    msg.clone(),
-                    partitions.history.measured_tokens(index, engine),
-                )
-            })
-            .collect();
-        carried.reverse();
-        for (msg, t) in carried {
-            renewed.history.push(msg, t);
+        let messages = &partitions.history.messages;
+        let mut start = messages.len();
+        // Carry whole conversational transactions, so a budget boundary cannot strand a result
+        // without its assistant call (or omit one result of a parallel call batch).
+        for unit in super::units::unit_boundaries(messages).into_iter().rev() {
+            let tokens = unit.clone().fold(0u32, |sum, index| {
+                sum.saturating_add(partitions.history.measured_tokens(index, engine))
+            });
+            if tokens > remaining {
+                break;
+            }
+            remaining = remaining.saturating_sub(tokens);
+            start = unit.start;
+        }
+        for (index, msg) in messages.iter().enumerate().skip(start) {
+            renewed.history.push(
+                msg.clone(),
+                partitions.history.measured_tokens(index, engine),
+            );
         }
 
         renewed
@@ -147,6 +141,33 @@ mod tests {
         assert!(renewed.history.token_count <= 100);
     }
 
+    #[test]
+    fn renewal_never_carries_a_tool_result_without_its_call() {
+        use crate::types::message::{ContentPart, ToolCall};
+        let mut ctx = ContextPartitions::new(&ContextConfig::default());
+        ctx.history.push(CoreMessage::user("read"), 10);
+        let mut call = CoreMessage::assistant("");
+        call.tool_calls.push(ToolCall {
+            id: "call-1".into(),
+            name: "read".into(),
+            arguments: serde_json::json!({}),
+        });
+        ctx.history.push(call, 80);
+        ctx.history.push(
+            CoreMessage::tool(vec![ContentPart::ToolResult {
+                call_id: "call-1".into(),
+                output: "result".into(),
+                is_error: false,
+                durable_content: None,
+            }]),
+            40,
+        );
+        let renewed = make_policy(0.1).renew(&ctx, 1_000, &ContextTokenEngine::char_approx());
+        assert!(crate::context::units::strict_tool_pairing_is_valid(
+            &renewed.history.messages
+        ));
+    }
+
     #[test]
     fn renewal_clears_task_scratchpad_keeps_goal() {
         let cfg = ContextConfig::default();

{deepstrike-0.2.75 → deepstrike-0.2.77}/crates/deepstrike-core/src/context/token_engine.rs

@@ -44,7 +44,7 @@ impl TokenCounter for CharApproxCounter {
 /// implementation applies the same 0.25 tokens/char divisor to every script). This wraps
 /// `deepstrike-tokenizer`'s real cl100k BPE tokenizer (previously an orphaned crate — not a
 /// workspace member, zero call sites anywhere) and adds a fixed margin on top. That only
-/// guarantees a value above the selected `cl100k_base` estimate; it does not prove that the
+/// guarantees a value above its chunked `cl100k_base` estimate; it does not prove that the
 /// result is conservative for every provider model. Native Anthropic/Gemini token counts take
 /// precedence where callers explicitly request them.
 pub struct FallbackEstimator {
@@ -69,17 +69,54 @@ impl Default for FallbackEstimator {
     }
 }
 
+/// Bound BPE merge work for long unbroken tool output. Chunk boundaries are UTF-8-safe and
+/// deterministic; boundary merges are deliberately sacrificed by this heuristic estimator.
+fn estimation_chunks(mut text: &str) -> impl Iterator<Item = &str> {
+    std::iter::from_fn(move || {
+        if text.is_empty() {
+            return None;
+        }
+        let mut end = text.len().min(1_024);
+        while !text.is_char_boundary(end) {
+            end -= 1;
+        }
+        let (chunk, rest) = text.split_at(end);
+        text = rest;
+        Some(chunk)
+    })
+}
+
 impl TokenCounter for FallbackEstimator {
     fn count(&self, text: &str) -> u32 {
-        let raw = self.tokenizer.count(text) as f64;
-        ((raw * self.safety_margin).ceil() as u32).max(1)
+        let raw = estimation_chunks(text).fold(0u32, |sum, chunk| {
+            sum.saturating_add(self.tokenizer.count(chunk))
+        });
+        ((raw as f64 * self.safety_margin).ceil() as u32).max(1)
     }
 
     fn truncate<'a>(&self, text: &'a str, max_tokens: u32) -> &'a str {
         // Budget in *raw* BPE tokens so that, after the margin is applied by `count`, the
         // truncated text's reported count still fits within `max_tokens`.
         let raw_budget = ((max_tokens as f64) / self.safety_margin).floor() as u32;
-        self.tokenizer.truncate(text, raw_budget)
+        let mut remaining = raw_budget;
+        let mut end = 0;
+        for chunk in estimation_chunks(text) {
+            let tokens = self.tokenizer.count(chunk);
+            if tokens <= remaining {
+                remaining -= tokens;
+                end += chunk.len();
+            } else {
+                let mut prefix_end = self.tokenizer.truncate(chunk, remaining).len();
+                // Retokenizing a prefix can change its last merge. Enforce the same count budget
+                // on the returned prefix, without ever processing another unbounded string.
+                while prefix_end > 0 && self.tokenizer.count(&chunk[..prefix_end]) > remaining {
+                    prefix_end = chunk[..prefix_end].char_indices().next_back().unwrap().0;
+                }
+                end += prefix_end;
+                break;
+            }
+        }
+        &text[..end]
     }
 }
 
@@ -101,7 +138,12 @@ impl ContextTokenEngine {
     /// [`FallbackEstimator`]), replacing the previous `char_approx()` default that
     /// underestimated CJK-heavy text by 40-70%.
     pub fn fallback_estimator() -> Self {
-        Self(Arc::new(FallbackEstimator::default()))
+        static COUNTER: std::sync::OnceLock<Arc<dyn TokenCounter>> = std::sync::OnceLock::new();
+        Self(
+            COUNTER
+                .get_or_init(|| Arc::new(FallbackEstimator::default()))
+                .clone(),
+        )
     }
 
     pub fn count(&self, text: &str) -> u32 {
@@ -186,6 +228,31 @@ fn modality_estimate_tokens(part: &ContentPart) -> Option<u32> {
 #[cfg(test)]
 mod tests {
     use super::*;
+
+    #[test]
+    fn default_engines_share_the_immutable_bpe_tables() {
+        let first = ContextTokenEngine::fallback_estimator();
+        let second = ContextTokenEngine::fallback_estimator();
+        assert!(
+            Arc::ptr_eq(&first.0, &second.0),
+            "starting or restoring an operation must not reload the tokenizer tables"
+        );
+    }
+
+    #[test]
+    fn large_unbroken_estimates_are_bounded_and_truncation_remains_utf8_safe() {
+        let estimator = FallbackEstimator::default();
+        let started = std::time::Instant::now();
+        assert!(estimator.count(&"y".repeat(100 * 1024)) > 20_000);
+        assert!(
+            started.elapsed() < std::time::Duration::from_secs(10),
+            "100 KiB of unbroken tool output must not stall the host for tens of seconds"
+        );
+        let text = "核实需求与运行结果🙂".repeat(2_000);
+        let truncated = estimator.truncate(&text, 2_000);
+        assert!(text.starts_with(truncated));
+        assert!(estimator.count(truncated) <= 2_000);
+    }
     use crate::types::message::{ContentPart, CoreMessage};
 
     fn engine() -> ContextTokenEngine {

{deepstrike-0.2.75 → deepstrike-0.2.77}/crates/deepstrike-core/src/runtime/kernel/wire/driver/events.rs

@@ -325,7 +325,7 @@ impl CanonicalOperationDriver {
                 attempt_id: completed.attempt_id.clone(),
                 request_seq: seq as u32,
             });
-            match self.apply_syscall(context, &causation, request, &mut index) {
+            match self.apply_syscall(context, &causation, request, &mut index, &effects) {
                 Ok(outcome) => effects.extend(outcome.effects),
                 Err(SyscallRefusal::Fault(fault)) => self.note_rejection(
                     SyscallRejection::new(

{deepstrike-0.2.75 → deepstrike-0.2.77}/crates/deepstrike-core/src/runtime/kernel/wire/driver/provider.rs

@@ -118,7 +118,9 @@ impl CanonicalOperationDriver {
         let mut round_caller: Option<TaskId> = None;
         for (causation, call) in &derived {
             let outcome = match decode_syscall(call) {
-                Ok(request) => self.apply_syscall(context, causation, &request, &mut index),
+                Ok(request) => {
+                    self.apply_syscall(context, causation, &request, &mut index, &effects)
+                }
                 Err(rejection) => Err(SyscallRefusal::Rejected(rejection)),
             };
             match outcome {

{deepstrike-0.2.75 → deepstrike-0.2.77}/crates/deepstrike-core/src/runtime/kernel/wire/driver/syscall.rs

@@ -9,6 +9,7 @@ impl CanonicalOperationDriver {
         causation: &SyscallCausation,
         request: &SyscallRequest,
         effect_index: &mut u32,
+        planned_effects: &[KernelEffect],
     ) -> Result<SyscallOutcome, SyscallRefusal> {
         let caller = causation_task(causation);
         let quarantined = self
@@ -53,6 +54,17 @@ impl CanonicalOperationDriver {
                     )
                 } else {
                     self.enter_nested_workflow(context, &submit.spec, effect_index)
+                        .map_err(|refusal| match refusal {
+                            SyscallRefusal::Fault(fault)
+                                if fault.code == KernelFaultCode::InvalidAuthority =>
+                            {
+                                SyscallRefusal::Rejected(SyscallRejection::new(
+                                    "start_workflow",
+                                    fault.message,
+                                ))
+                            }
+                            other => other,
+                        })
                 }
             }
             SyscallRequest::AppendWorkflowNodes(append) => {
@@ -99,9 +111,13 @@ impl CanonicalOperationDriver {
             SyscallRequest::RequestMemoryWrite(write) => {
                 self.plan_memory_write(context, causation, &write.proposal, effect_index)
             }
-            SyscallRequest::RequestMemoryQuery(query) => {
-                self.plan_memory_query(context, causation, &query.query, effect_index)
-            }
+            SyscallRequest::RequestMemoryQuery(query) => self.plan_memory_query(
+                context,
+                causation,
+                &query.query,
+                effect_index,
+                planned_effects,
+            ),
             SyscallRequest::PageIn(page_in) => {
                 self.plan_page_in(context, &caller, &page_in.handle_id, effect_index)
             }
@@ -450,6 +466,7 @@ impl CanonicalOperationDriver {
         causation: &SyscallCausation,
         proposal: &super::super::syscall::MemoryQueryProposal,
         effect_index: &mut u32,
+        planned_effects: &[KernelEffect],
     ) -> Result<SyscallOutcome, SyscallRefusal> {
         let Some(binding) = context.config.memory_access.clone() else {
             return Err(SyscallRefusal::Rejected(SyscallRejection::new(
@@ -469,6 +486,30 @@ impl CanonicalOperationDriver {
         // and a model cannot widen it by asking for more.
         let ceiling = context.config.memory_policy.retrieval_top_k;
         let requested_k = proposal.limit.unwrap_or(ceiling).clamp(1, ceiling);
+        if let Some(pending) = context
+            .pending
+            .iter()
+            .chain(planned_effects)
+            .find_map(|effect| match &effect.effect {
+                EffectKind::QueryMemory(query) => Some(query),
+                _ => None,
+            })
+        {
+            if pending.binding == binding
+                && pending.query.text == proposal.text
+                && pending.query.kinds == proposal.kinds
+                && pending.requested_k == requested_k
+            {
+                return Ok(SyscallOutcome {
+                    ack: Some("Reusing the identical pending memory query; its results will arrive before the next turn.".into()),
+                    ..Default::default()
+                });
+            }
+            return Err(SyscallRefusal::Rejected(SyscallRejection::new(
+                "query_memory",
+                "A different memory query is already pending. Retry this query after its result arrives.",
+            )));
+        }
         let authored = AuthoredMemoryQuery {
             binding_id: binding.binding_id.clone(),
             text: proposal.text.clone(),

{deepstrike-0.2.75 → deepstrike-0.2.77}/crates/deepstrike-core/src/runtime/kernel/wire/driver/tests.rs

@@ -41,6 +41,32 @@ use crate::scheduler::tcb::TaskLifecycle;
 
 const OPERATION: &str = "op-driver-1";
 
+#[test]
+fn resolved_context_policy_reaches_the_semantic_engine() {
+    let mut config = ConfigDefaults::default().baseline;
+    config.execution_policy.max_context_tokens = 1_000;
+    config.context_policy.target_after_compress_ppm = Ppm::new(500_000).unwrap();
+    config.context_policy.renewal_carryover_ppm = Ppm::new(400_000).unwrap();
+    config.context_policy.preserve_recent_turns = 5;
+    config.context_policy.idle_micro_compact_minutes = 17;
+    let mut engine = build_engine(&config);
+    assert_eq!(engine.ctx.config.target_after_compress, 0.5);
+    assert_eq!(engine.ctx.config.carryover_ratio, 0.4);
+    assert_eq!(engine.ctx.plan_compaction_params().1, 5);
+    assert_eq!(engine.ctx.config.micro_compact_idle_minutes, 17);
+    for i in 0..6 {
+        engine
+            .ctx
+            .push_history(CoreMessage::user(format!("turn {i}")), 100);
+    }
+    engine.ctx.renew();
+    assert_eq!(
+        engine.ctx.partitions.history.messages.len(),
+        4,
+        "the renewal component must use the installed 40% policy rather than its 5% default"
+    );
+}
+
 // -----------------------------------------------------------------------------------------
 // §8.2 host loop: prepare → (CAS append) → commit → fold
 // -----------------------------------------------------------------------------------------
@@ -2826,6 +2852,89 @@ fn a_memory_query_is_clamped_to_the_operations_retrieval_policy() {
     assert_eq!(effect.binding.binding_id.as_str(), "mem-binding-1");
 }
 
+#[test]
+fn parallel_memory_queries_reuse_or_refuse_without_terminating_the_turn() {
+    for duplicate in [true, false] {
+        let (mut runtime, provider) = agent_awaiting_provider();
+        let queried = runtime.submit(&provider_result(
+            "in-parallel-recall",
+            1_700_000_002_000,
+            &provider,
+            vec![
+                tool_call("call-1", "memory", json!({"query": "past briefs"})),
+                tool_call(
+                    "call-2",
+                    "memory",
+                    json!({"query": if duplicate { "past briefs" } else { "other projects" }}),
+                ),
+            ],
+        ));
+        assert_eq!(kinds(&queried), vec![EffectKindTag::QueryMemory]);
+        assert!(runtime.tx.terminal().is_none());
+        let history = &runtime
+            .driver
+            .engine()
+            .unwrap()
+            .ctx
+            .partitions
+            .history
+            .messages;
+        let result = history.iter().find_map(|message| {
+            let Content::Parts(parts) = &message.content else {
+                return None;
+            };
+            parts.iter().find_map(|part| match part {
+                ContentPart::ToolResult {
+                    call_id, is_error, ..
+                } if call_id == "call-2" => Some(*is_error),
+                _ => None,
+            })
+        });
+        assert_eq!(result, Some(!duplicate));
+        assert!(crate::context::units::strict_tool_pairing_is_valid(history));
+        let restored = Runtime::restore_with(None, &runtime.journal);
+        assert_eq!(
+            restored.pending_effect_kinds(),
+            vec![EffectKindTag::QueryMemory]
+        );
+        let resumed = runtime.submit(&resolved(
+            "in-recall-done",
+            1_700_000_003_000,
+            &sole_effect(&queried).effect_id,
+            EffectSuccess::MemoryQueried(MemoryQueriedSuccess { recalls: vec![] }),
+        ));
+        assert_eq!(kinds(&resumed), vec![EffectKindTag::CallProvider]);
+    }
+}
+
+#[test]
+fn workflow_focus_refusal_is_answered_to_the_model() {
+    let (mut runtime, provider) = agent_awaiting_provider();
+    // Exercise the focus guard independently of the active-DAG flatten path. A stale focus
+    // must produce a model-visible denial rather than poison the whole provider resolution.
+    runtime.driver.focus = Some(ExecutionFocus::workflow_controller(
+        WorkflowId::new("existing-workflow").unwrap(),
+        Some(root_task_id()),
+    ));
+    let resumed = runtime.submit(&provider_result(
+        "in-second-workflow",
+        1_700_000_002_000,
+        &provider,
+        vec![tool_call(
+            "call-1",
+            "start_workflow",
+            serde_json::to_value(two_node_spec()).unwrap(),
+        )],
+    ));
+    assert_eq!(kinds(&resumed), vec![EffectKindTag::CallProvider]);
+    assert!(runtime.tx.terminal().is_none());
+    assert!(
+        history_text(&runtime)
+            .iter()
+            .any(|text| text.contains("workflows do not stack"))
+    );
+}
+
 /// §7.6 + §15.3 · a provider turn that mixes an effect-publishing syscall (`memory`) with host
 /// tool calls publishes BOTH effects in one step — different kinds, so DEC-3 admits them
 /// together — and the host consumes them one pending effect at a time. Resolving the syscall's

{deepstrike-0.2.75 → deepstrike-0.2.77}/crates/deepstrike-core/src/runtime/kernel/wire/driver.rs

@@ -3037,6 +3037,31 @@ fn build_engine(config: &ResolvedOperationConfig) -> LoopStateMachine {
         max_total_tokens: execution.max_total_tokens.get(),
         max_wall_ms: execution.max_wall_ms.map(WireU64::get),
     });
+    let context = &config.context_policy;
+    let thresholds = &context.pressure_thresholds_ppm;
+    engine
+        .ctx
+        .apply_context_policy(&crate::context::policy::ContextPolicy {
+            pressure_thresholds_ppm: crate::context::policy::PressureThresholdsPpm {
+                snip: thresholds.snip.get(),
+                micro: thresholds.micro.get(),
+                collapse: thresholds.collapse.get(),
+                auto: thresholds.auto.get(),
+                renewal: thresholds.renewal.get(),
+            },
+            target_after_compress_ppm: context.target_after_compress_ppm.get(),
+            preserve_recent_turns: context.preserve_recent_turns,
+            renewal_carryover_ppm: context.renewal_carryover_ppm.get(),
+            collapse_old_assistant_narration: context.collapse_old_assistant_narration,
+            idle_micro_compact_minutes: context.idle_micro_compact_minutes,
+        });
+    engine
+        .ctx
+        .set_prompt_budget(crate::context::config::PromptBudgetConfig {
+            prompt_overhead_tokens: context.prompt_budget.prompt_overhead_tokens,
+            output_reserve_tokens: context.prompt_budget.output_reserve_tokens,
+            safety_margin_tokens: context.prompt_budget.safety_margin_tokens,
+        });
     if let Some(grant) = config.budget_grant.clone() {
         engine.set_budget_grant(grant);
     }

{deepstrike-0.2.75 → deepstrike-0.2.77}/crates/deepstrike-core/src/scheduler/state_machine/mod.rs

@@ -1152,6 +1152,25 @@ impl LoopStateMachine {
             );
         }
 
+        // Preloaded transcripts are already durable in the host's session log. Compact them
+        // before the first render instead of selecting a nearly full prompt while retaining the
+        // entire oversized history internally. No archive effect may precede an agent's first
+        // provider effect; the summary and the retained history are part of this atomic start.
+        if self.session_history_baseline > 0 && self.ctx.rho() > self.ctx.config.snip_threshold {
+            let action = crate::context::pressure::PressureAction::ContextCollapse;
+            let (saved, summary, archived, invalidates_prefix_at) = self.ctx.compress(action);
+            if saved > 0 || summary.is_some() {
+                self.observations.push(KernelObservation::Compressed {
+                    turn: self.turn,
+                    action: action.into(),
+                    rho_after: self.ctx.rho(),
+                    summary,
+                    archived_count: archived.len() as u32,
+                    invalidates_prefix_at,
+                });
+            }
+            self.session_history_baseline = self.ctx.partitions.history.messages.len();
+        }
         let user_msg = "Proceed with the task described in [TASK STATE].".to_string();
 
         // User message goes into history so it appears at the correct chronological

{deepstrike-0.2.75 → deepstrike-0.2.77}/crates/deepstrike-core/src/scheduler/state_machine/tests.rs

@@ -6759,3 +6759,32 @@ fn spc_005_06_three_layer_grant_invariant_operation_to_a_to_a1_a2() {
         })
     );
 }
+#[test]
+fn preloaded_history_leaves_headroom_for_the_new_run() {
+    let mut sm = LoopStateMachine::new(SchedulerBudget {
+        max_tokens: 2_000,
+        max_turns: 10,
+        max_total_tokens: 100_000,
+        max_wall_ms: None,
+    });
+    sm.ctx = crate::context::manager::ContextManager::with_config(
+        2_000,
+        crate::context::config::ContextConfig::default(),
+        crate::context::token_engine::ContextTokenEngine::char_approx(),
+    );
+    let messages = (0..40)
+        .map(|i| CoreMessage::user(format!("turn {i}: {}", "detail ".repeat(40))))
+        .collect();
+    sm.preload_history(messages);
+    let task = RuntimeTask::new("continue");
+    sm.start(task);
+    assert!(
+        sm.ctx.partitions.total_tokens(&sm.ctx.engine) < 1_500,
+        "preloaded history should compact toward 65%, not fill the next prompt"
+    );
+    assert!(
+        sm.observations
+            .iter()
+            .any(|obs| matches!(obs, KernelObservation::Compressed { .. }))
+    );
+}

{deepstrike-0.2.75 → deepstrike-0.2.77}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "deepstrike"
-version = "0.2.75"
+version = "0.2.77"
 requires-python = ">=3.10"
 readme = "README.md"
 license = {file = "LICENSE"}