fix: replace 128K context_limit hardcode with per-agent lookup

Constitution Article V.3 is explicit — each model has different physics,
don't guess at 128K. Pressure calculation now reads from the agent's
`llm_config.context_window` (which inherits per-model defaults via
ModelConfig.context_limit).

- ConsciousnessEngine::calculate_pressure now takes `context_limit: usize`
- New `pressure_for_session` async helper looks up the agent's
  context_window once and computes pressure
- backend/local.rs: bifrost_pressure takes `context_limit`; loop pulls
  agent.llm_config.context_window once at the top
- api/handlers.rs uses pressure_for_session

128_000 only remains as a last-resort fallback if the agent isn't
findable; existing per-agent and per-model config flows now drive
the value.

src/api/handlers.rs

@@ -293,7 +293,7 @@ async fn handle_conversation_stream(
             // Update pressure
             let mut session = server.sessions.get_mut(&conversation_id)
                 .ok_or_else(|| anyhow::anyhow!("Session disappeared"))?;
-            let pressure = server.consciousness.calculate_pressure(&session.messages);
+            let pressure = server.consciousness.pressure_for_session(&session).await;
             session.context_pressure = pressure;
             drop(session);
         }

src/backend/local.rs

@@ -42,12 +42,12 @@ fn pressure_to_max_tokens(pressure: f32, output_limit: u32) -> Option<u32> {
 
 /// Mirror of `ConsciousnessEngine::calculate_pressure` for the in-loop
 /// BifrostMessage shape, so we can recompute pressure as tool results
-/// accumulate inside a single turn. The 128k limit matches the existing
-/// hardcode in consciousness_engine.rs; per-model context_limit lives in
-/// Constitution V.3 and is still a TODO.
-fn bifrost_pressure(counter: &TokenCounter, messages: &[BifrostMessage]) -> f32 {
+/// accumulate inside a single turn. `context_limit` comes from the
+/// agent's `llm_config.context_window` (Constitution V.3 — per-model
+/// physics, no hardcoded 128K).
+fn bifrost_pressure(counter: &TokenCounter, messages: &[BifrostMessage], context_limit: usize) -> f32 {
     let tokens: usize = messages.iter().map(|m| counter.count(&m.content)).sum();
-    let limit = 128_000;
+    let limit = context_limit.max(1);
     (tokens as f32 / limit as f32).min(1.0)
 }
 
@@ -580,6 +580,7 @@ async fn run_turn(
     let model = agent.llm_config.model.clone();
     let temperature = agent.llm_config.temperature;
     let inter_round_delay = Duration::from_millis(agent.llm_config.inter_round_delay_ms);
+    let context_limit = agent.llm_config.context_window as usize;
 
     // Resolve the model's configured output limit for pressure scaling
     let output_limit = {
@@ -627,7 +628,7 @@ async fn run_turn(
     let counter = TokenCounter::new();
 
     loop {
-        let pressure = bifrost_pressure(&counter, &messages);
+        let pressure = bifrost_pressure(&counter, &messages, context_limit);
         let max_tokens = pressure_to_max_tokens(pressure, output_limit);
         let _ = tx.send(Ok(BackendEvent::ContextPressure(pressure))).await;
 
@@ -831,7 +832,7 @@ async fn run_turn(
     if let Some(mut session) = server.sessions.get_mut(&conversation_id) {
         let pressure = server
             .consciousness
-            .calculate_pressure(&session.messages);
+            .calculate_pressure(&session.messages, context_limit);
         session.context_pressure = pressure;
     }
 

src/server/consciousness_engine.rs

@@ -89,7 +89,7 @@ impl ConsciousnessEngine {
         response: &str,
     ) -> anyhow::Result<Vec<ConsciousnessEvent>> {
         let mut events = Vec::new();
-        let pressure = self.calculate_pressure(&session.messages);
+        let pressure = self.pressure_for_session(session).await;
 
         // ── N+25 reflection (placeholder until reflection module lands) ──
         if session.turn_count % 25 == 0 && session.turn_count > 0 {
@@ -461,7 +461,17 @@ Resolve entries: `[YYYY-MM-DD HH:MM] RESOLVED — note`"#;
         Ok(Vec::new())
     }
 
-    pub fn calculate_pressure(&self, messages: &[ConversationMessage]) -> f32 {
+    /// Compute context pressure as tokens-used / context_limit.
+    ///
+    /// `context_limit` comes from the agent's `llm_config.context_window`
+    /// (falls back to model config, then a configured default). The
+    /// Constitution (Article V.3) requires per-model physics — no
+    /// hardcoded 128K here.
+    pub fn calculate_pressure(
+        &self,
+        messages: &[ConversationMessage],
+        context_limit: usize,
+    ) -> f32 {
         let tokens: usize = messages
             .iter()
             .flat_map(|m| &m.blocks)
@@ -471,9 +481,25 @@ Resolve entries: `[YYYY-MM-DD HH:MM] RESOLVED — note`"#;
             })
             .map(|t| self.counter.count(t))
             .sum();
-        let limit = 128_000;
+        let limit = context_limit.max(1);
         (tokens as f32 / limit as f32).min(1.0)
     }
+
+    /// Async convenience: look up the agent's context_limit from its
+    /// `llm_config.context_window` (falling back to 128K only when the
+    /// agent isn't found), then compute pressure.
+    pub async fn pressure_for_session(
+        &self,
+        session: &crate::server::session_manager::Session,
+    ) -> f32 {
+        let limit = self
+            .agents
+            .get(&session.agent_id)
+            .await
+            .map(|a| a.llm_config.context_window as usize)
+            .unwrap_or(128_000);
+        self.calculate_pressure(&session.messages, limit)
+    }
 }
 
 /// Parse Aster's structured YAML-like observations into [`InboxItem`]s.