Task 11: conversation integration tests (8/8 passing) + latency benchmarks (all budgets met) + performance report

CONVERSATIONAL_INTELLIGENCE.md

@@ -0,0 +1,59 @@
+# WO-Conversational-Intelligence — Performance Report
+
+Real measured results, not projected or invented. Generated by running the
+production code paths directly.
+
+## Test coverage
+
+- 89 unit tests across all 10 modules (mood_stream, state_machine,
+  anticipation, interest_model, knowledge_updater, persona_injection,
+  response_tuning, autonomy_calibration, partnership_tracker, prompt_builder)
+- 8 integration tests (`miranda-nodes/tests/conversation_integration_tests.rs`)
+  exercising real cross-module composition: raw input -> mood -> state ->
+  moves -> role -> prompt, using the actual production functions end to end,
+  not mocks.
+- Both non-negotiable invariants verified passing:
+  - `floor_categories_never_resolve_to_autonomous_under_any_interview_input`
+  - `banned_pattern_corpus_is_rejected_at_100_percent`
+
+Run with: `cargo test -p miranda-nodes conversation::` and
+`cargo test -p miranda-nodes --test conversation_integration_tests`.
+
+## Latency benchmarks
+
+Measured by `miranda-nodes/src/bin/conversation-benchmarks.rs`, 200
+iterations per measurement, real production function calls (no mocked
+timing). Run with: `cargo run -p miranda-nodes --bin conversation-benchmarks`.
+
+**Note on build profile:** the numbers below are from a debug build
+(`cargo run`, not `cargo run --release`). This environment's `duckdb-sys`
+dependency triggers a from-scratch native C++ recompile under the release
+profile (independent from the debug-profile cache), which was not completed
+in this session due to time constraints. Debug-mode numbers are reported
+honestly as debug-mode numbers — they are the real measured cost of an
+unoptimized build, not a release-grade figure. All four targets pass with
+enormous margin even unoptimized, which is itself useful signal: these are
+lightweight, allocation-light computations, not the bottleneck in the
+pipeline.
+
+| Component | Budget | Measured (debug build) | Result |
+|---|---|---|---|
+| Mood classification | 50ms | 0.0012ms | PASS |
+| State transition | 10ms | 0.0007ms | PASS |
+| Anticipatory move generation | 150ms | 0.0005ms | PASS |
+| Full prompt assembly | 300ms | 0.0063ms | PASS |
+
+All four budgets met by 3-4 orders of magnitude, even without release
+optimizations. The dominant cost in a real conversation turn will be LLM
+inference itself (Bedrock/local model call), not this layer.
+
+## Known limitations
+
+- Benchmark numbers are debug-build measurements (see note above). A
+  release-mode re-run is straightforward once the duckdb-sys release
+  compile has been done once (subsequent release builds reuse the cache).
+- `anticipation.rs`'s confidence scoring is a hand-authored heuristic
+  (state match + mood alignment + entity recurrence), not a trained ranker
+  — disclosed in the module's own doc comments. The confidence *gate*
+  (Property 1) is real and structurally enforced regardless of how scores
+  are produced.

miranda-nodes/src/bin/conversation-benchmarks.rs

@@ -0,0 +1,106 @@
+//! Task 11 — Conversation Intelligence latency benchmarks.
+//!
+//! Measures real wall-clock timing for the four budgets design.md calls
+//! out: mood classification (<50ms), state transition (<10ms),
+//! anticipatory move generation (<150ms), and full prompt assembly
+//! (<300ms). Every measurement below calls the real production function
+//! — no mocked timing, no invented numbers — and the binary exits
+//! non-zero if any budget is exceeded, so it can gate a build the same
+//! way `verify-60fps` does for WO-3.
+//!
+//! ```text
+//! cargo run --release -p miranda-nodes --bin conversation-benchmarks
+//! ```
+//!
+//! Build in release for a measurement that reflects the shipped
+//! pipeline's actual cost, not an unoptimized debug build.
+
+use std::process::ExitCode;
+use std::time::Instant;
+
+use chrono::Utc;
+
+use miranda_nodes::conversation::anticipation::AnticipationEngine;
+use miranda_nodes::conversation::mood_stream::MoodStreamProcessor;
+use miranda_nodes::conversation::persona_injection::Role;
+use miranda_nodes::conversation::prompt_builder::{build_prompt, RetrievedContext, DEFAULT_TOKEN_BUDGET};
+use miranda_nodes::conversation::state_machine::{StateMachine, Turn};
+
+const MOOD_BUDGET_MS: f64 = 50.0;
+const STATE_TRANSITION_BUDGET_MS: f64 = 10.0;
+const ANTICIPATION_BUDGET_MS: f64 = 150.0;
+const PROMPT_ASSEMBLY_BUDGET_MS: f64 = 300.0;
+const ITERATIONS: u32 = 200;
+
+fn measure_ms<F: FnMut()>(iterations: u32, mut f: F) -> f64 {
+    let start = Instant::now();
+    for _ in 0..iterations {
+        f();
+    }
+    let elapsed = start.elapsed();
+    (elapsed.as_secs_f64() * 1000.0) / iterations as f64
+}
+
+fn main() -> ExitCode {
+    println!("=== Conversation Intelligence Latency Benchmarks ===");
+    println!("({ITERATIONS} iterations per measurement, average reported)\n");
+
+    let mut all_passed = true;
+
+    // Mood classification — real MoodStreamProcessor::process_chunk call.
+    let mut mood_proc = MoodStreamProcessor::new();
+    let sample_text = "this keeps crashing with a stack trace, still debugging it";
+    let mood_avg_ms = measure_ms(ITERATIONS, || {
+        let _ = mood_proc.process_chunk(sample_text);
+    });
+    report("Mood classification", mood_avg_ms, MOOD_BUDGET_MS, &mut all_passed);
+    let mood = mood_proc.current();
+
+    // State transition — real StateMachine::transition call.
+    let mut state_machine = StateMachine::new();
+    let entities = vec!["stack trace".to_string()];
+    let state_avg_ms = measure_ms(ITERATIONS, || {
+        let _ = state_machine.transition(&mood, &entities, None);
+    });
+    report("State transition", state_avg_ms, STATE_TRANSITION_BUDGET_MS, &mut all_passed);
+    let state = state_machine.state;
+
+    // Anticipatory move generation — real AnticipationEngine::generate_moves call.
+    let engine = AnticipationEngine::new();
+    let history = vec![
+        Turn { text: "let's verify this fix works".to_string(), timestamp: Utc::now() },
+        Turn { text: "still seeing the exception".to_string(), timestamp: Utc::now() },
+    ];
+    let anticipation_avg_ms = measure_ms(ITERATIONS, || {
+        let _ = engine.generate_moves(state, &mood, &history);
+    });
+    report("Anticipatory move generation", anticipation_avg_ms, ANTICIPATION_BUDGET_MS, &mut all_passed);
+    let moves = engine.generate_moves(state, &mood, &history);
+
+    // Full prompt assembly — real build_prompt call with realistic inputs.
+    let memory = vec![
+        RetrievedContext { text: "we discussed the ring buffer design last week".to_string() },
+        RetrievedContext { text: "the SIMD solver budget is 150 microseconds per frame".to_string() },
+    ];
+    let prompt_avg_ms = measure_ms(ITERATIONS, || {
+        let _ = build_prompt(Role::PeerReviewer, state, &mood, &memory, &moves, None, DEFAULT_TOKEN_BUDGET);
+    });
+    report("Full prompt assembly", prompt_avg_ms, PROMPT_ASSEMBLY_BUDGET_MS, &mut all_passed);
+
+    println!();
+    if all_passed {
+        println!("All latency budgets met.");
+        ExitCode::SUCCESS
+    } else {
+        println!("One or more latency budgets exceeded.");
+        ExitCode::FAILURE
+    }
+}
+
+fn report(label: &str, measured_ms: f64, budget_ms: f64, all_passed: &mut bool) {
+    let status = if measured_ms <= budget_ms { "PASS" } else { "FAIL" };
+    if measured_ms > budget_ms {
+        *all_passed = false;
+    }
+    println!("{label:35} {measured_ms:8.4}ms  (budget {budget_ms:.1}ms)  [{status}]");
+}

miranda-nodes/tests/conversation_integration_tests.rs

@@ -0,0 +1,215 @@
+//! Task 11 — WO-Conversational-Intelligence integration tests.
+//!
+//! Exercises the real pipeline described in design.md's architecture
+//! diagram end-to-end: raw input -> mood -> state -> anticipatory moves
+//! -> role detection -> partnership tracking -> assembled prompt. Every
+//! module called here is the real implementation from `miranda-nodes`,
+//! not a mock — this is what proves the pieces actually compose, not
+//! just that each compiles and passes its own unit tests in isolation.
+
+use chrono::Utc;
+
+use miranda_nodes::conversation::anticipation::AnticipationEngine;
+use miranda_nodes::conversation::autonomy_calibration::{
+    self as autonomy, ActionCategory, AutonomyLevel, FloorCategory,
+};
+use miranda_nodes::conversation::interest_model::{InterestModel, Sentiment};
+use miranda_nodes::conversation::mood_stream::MoodStreamProcessor;
+use miranda_nodes::conversation::partnership_tracker::{check_progress, extract_goal};
+use miranda_nodes::conversation::persona_injection::detect_role;
+use miranda_nodes::conversation::prompt_builder::{build_prompt, RetrievedContext, DEFAULT_TOKEN_BUDGET};
+use miranda_nodes::conversation::state_machine::{detect_cue, StateMachine, Turn};
+
+/// Requirement 1.3/2.1-2.5 integration: a debugging-flavored message
+/// stream should drive mood -> state -> role all the way through to a
+/// prompt that reflects the Debugging state and PeerReviewer role.
+#[test]
+fn debugging_conversation_flows_end_to_end_into_the_assembled_prompt() {
+    let mut mood_proc = MoodStreamProcessor::new();
+    let mut state_machine = StateMachine::new();
+
+    let message = "this keeps crashing with a stack trace every single time and it's driving me crazy";
+    let mood = mood_proc.process_chunk(message);
+
+    let entities = vec!["stack trace".to_string()];
+    let cue = detect_cue(message);
+    let state = state_machine.transition(&mood, &entities, cue);
+
+    let role = detect_role(message, state, &mood);
+
+    let prompt = build_prompt(role, state, &mood, &[], &[], None, DEFAULT_TOKEN_BUDGET);
+
+    assert!(
+        format!("{state:?}") == "Debugging",
+        "expected Debugging state from a stack-trace message, got {state:?}"
+    );
+    assert!(prompt.contains("Debugging"), "prompt should reflect the real transitioned state: {prompt}");
+    assert!(prompt.contains("You are Miranda"));
+}
+
+/// Requirement 3.1-3.4 integration: anticipatory moves generated from a
+/// real state machine + mood stream (not hand-constructed fixtures) still
+/// respect the confidence gate, and feed into the assembled prompt when
+/// present.
+#[test]
+fn anticipatory_moves_from_a_real_debugging_session_respect_the_confidence_gate_and_reach_the_prompt() {
+    let mut mood_proc = MoodStreamProcessor::new();
+    let mut state_machine = StateMachine::new();
+    let engine = AnticipationEngine::new();
+
+    let turns = vec![
+        Turn { text: "let's verify this fix works".to_string(), timestamp: Utc::now() },
+        Turn { text: "still seeing the exception".to_string(), timestamp: Utc::now() },
+    ];
+
+    let mood = mood_proc.process_chunk("still seeing the exception, need to verify the fix");
+    let state = state_machine.transition(&mood, &["exception".to_string()], None);
+
+    let moves = engine.generate_moves(state, &mood, &turns);
+    for mv in &moves {
+        assert!(mv.confidence >= miranda_nodes::conversation::anticipation::CONFIDENCE_THRESHOLD);
+    }
+
+    let prompt = build_prompt(
+        miranda_nodes::conversation::persona_injection::Role::PeerReviewer,
+        state,
+        &mood,
+        &[],
+        &moves,
+        None,
+        DEFAULT_TOKEN_BUDGET,
+    );
+
+    if !moves.is_empty() {
+        assert!(prompt.contains("Possible proactive moves"));
+    }
+}
+
+/// Requirement 4.1-4.3 integration: curiosity questions generated from
+/// real interest tracking respect the rate limit across simulated turns.
+#[test]
+fn curiosity_rate_limit_holds_across_a_real_multi_turn_session() {
+    let mut model = InterestModel::new();
+    let t0 = Utc::now();
+
+    for i in 0..5 {
+        model.record_mention(
+            &["Gaussian splatting".to_string()],
+            Sentiment::Positive,
+            t0 + chrono::Duration::minutes(i * 2),
+        );
+    }
+
+    let first = model.next_curiosity_question(t0 + chrono::Duration::minutes(11));
+    assert!(first.is_some(), "expected a curiosity question after 5 mentions");
+
+    // Within the same hour, a second call must not produce another one.
+    let second = model.next_curiosity_question(t0 + chrono::Duration::minutes(30));
+    assert!(second.is_none(), "curiosity questions must be rate-limited to <=1/hour");
+}
+
+/// Requirement 5.1-5.2 integration: a correction detected mid-session
+/// applies to the very next response, verified by round-tripping through
+/// the real `KnowledgeUpdater` + `PromptContext`.
+#[test]
+fn in_session_correction_applies_to_the_next_response() {
+    use miranda_nodes::conversation::knowledge_updater::{KnowledgeUpdater, PromptContext};
+
+    let session_id = uuid::Uuid::new_v4();
+    let mut updater = KnowledgeUpdater::new(session_id);
+
+    let correction = updater
+        .detect_correction("the renderer is WebGPU", "actually, it's Sumerian Hosts for pipeline 1")
+        .expect("expected a real correction to be detected");
+    updater.store_correction("renderer", correction);
+
+    let mut ctx = PromptContext::default();
+    updater.apply_session_knowledge(&mut ctx);
+
+    assert!(ctx.session_facts.get("renderer").unwrap().fact.contains("Sumerian Hosts"));
+}
+
+/// Requirement 6.1-6.3 integration: role detection driven by a real
+/// state machine transition (not a hand-picked `State` value).
+#[test]
+fn role_detection_follows_from_a_real_state_transition() {
+    let mut state_machine = StateMachine::new();
+    let mood = miranda_nodes::conversation::mood_stream::MoodVector {
+        frustration: 0.1,
+        curiosity: 0.1,
+        engagement: 0.5,
+        fatigue: 0.1,
+        excitement: 0.1,
+    };
+    let state = state_machine.transition(&mood, &["bug".to_string()], None);
+    let role = detect_role("this is still broken", state, &mood);
+    assert_eq!(format!("{role:?}"), "PeerReviewer");
+}
+
+/// design.md Property 2 / Requirement 7.4, the hard gate re-verified at
+/// integration scope: no interview input combination, run through the
+/// real `run_calibration_interview`, can produce `Autonomous` for a
+/// floor category.
+#[test]
+fn autonomy_floor_invariant_holds_through_the_real_interview_flow() {
+    let thresholds = autonomy::run_calibration_interview(|_| Some(AutonomyLevel::Autonomous));
+
+    for floor in [
+        FloorCategory::DestructiveAtScale,
+        FloorCategory::ProductionImpacting,
+        FloorCategory::HighBlastRadius,
+    ] {
+        assert_eq!(
+            autonomy::get_threshold(&thresholds, ActionCategory::Floor(floor)),
+            AutonomyLevel::ExplicitConfirm
+        );
+    }
+}
+
+/// Requirement 8.1-8.4 integration: a goal extracted from a real message
+/// is tracked and later acknowledged, and the acknowledgment always
+/// passes the banned-pattern filter — verified end-to-end rather than
+/// unit-testing extraction and filtering separately.
+#[test]
+fn partnership_goal_extraction_and_progress_acknowledgment_round_trip() {
+    let goal = extract_goal("I want to finish the WebGPU renderer this week")
+        .expect("expected a real goal to be extracted");
+
+    let turns = vec![Turn {
+        text: "the WebGPU renderer is finished now, it works".to_string(),
+        timestamp: Utc::now(),
+    }];
+
+    let ack = check_progress(&goal, &turns).expect("expected a real progress acknowledgment");
+    assert!(
+        miranda_nodes::conversation::partnership_tracker::passes_banned_filter(&ack.text),
+        "acknowledgment must pass the banned-pattern filter: {}",
+        ack.text
+    );
+}
+
+/// Requirement 9.1/9.3 integration: the full pipeline's output, built
+/// from real mood/state/role/moves/memory context together, respects
+/// the token budget and truncation order under a real tight budget.
+#[test]
+fn full_pipeline_prompt_respects_token_budget_under_real_pressure() {
+    let mut mood_proc = MoodStreamProcessor::new();
+    let mut state_machine = StateMachine::new();
+    let engine = AnticipationEngine::new();
+
+    let message = "let's verify this test passes, still debugging the ring buffer issue";
+    let mood = mood_proc.process_chunk(message);
+    let state = state_machine.transition(&mood, &["test".to_string()], None);
+    let role = detect_role(message, state, &mood);
+
+    let history = vec![Turn { text: message.to_string(), timestamp: Utc::now() }];
+    let moves = engine.generate_moves(state, &mood, &history);
+
+    let memory = vec![RetrievedContext { text: "we discussed the ring buffer design last week".to_string() }];
+
+    let tight_prompt = build_prompt(role, state, &mood, &memory, &moves, None, 20);
+    let full_prompt = build_prompt(role, state, &mood, &memory, &moves, None, DEFAULT_TOKEN_BUDGET);
+
+    assert!(tight_prompt.len() <= full_prompt.len());
+    assert!(tight_prompt.contains("ring buffer") || tight_prompt.contains("You are Miranda"));
+}