Fix duckdb list-column binding and neo4j retry test; 164/164 tests passing

HANDOFF.md

@@ -350,3 +350,27 @@ These are minimal compiling stubs, not final implementations. Once `cargo build
 3. Begin replacing the 14 stub files' placeholder logic with real implementations per `wo-conversational-intelligence` and `wo-model-forge` design docs — starting with the two non-negotiable invariant modules: `autonomy_calibration.rs` and `partnership_tracker.rs`.
 4. User's manual step still outstanding (needs interactive sudo, cannot be done via agent): CUPS purge commands provided earlier in session.
 
+
+---
+
+## Session Status Update — Sep 4, 2026, 10:15 CDT — ALL TESTS PASSING
+
+### Verified via real test run: 164 passed, 0 failed, 2 ignored (`cargo test -p miranda-nodes`)
+
+Two real bugs found and fixed after the build cleared:
+
+1. **`duckdb_writer.rs`** — `duckdb-rs` 1.10505.0 does not support binding native `LIST` parameters (confirmed by tracing the panic to `ToSqlConversionFailure("binding List parameters is not yet supported")` in the driver source). Fixed by storing the `entities` and `mood_contexts` columns as JSON-encoded `VARCHAR` instead of DuckDB `VARCHAR[]`, serialized/deserialized with `serde_json`. Schema updated in both the test's inline schema and the real `scripts/duckdb-init.sh`.
+2. **`neo4j_writer.rs`** — the `exhausts_retries_against_unreachable_host` test asserted `connect().await.is_err()`, but `neo4rs::Graph::new` pools connections lazily and does not fail at connect time against a closed port. Rewrote the test to actually exercise `write_conversation`'s retry loop (3 retries, 5ms backoff) and assert `Neo4jError::RetriesExhausted { attempts: 3, .. }` — this is the real behavior the module needs to guarantee per design.md's error-handling contract (JSONL log is source of truth if graph writes are exhausted).
+
+Both fixes verified with real `cargo test` output, not code-review confidence.
+
+### Verified test coverage includes
+- Memory: mood classifier (latency + accuracy), neo4j writer (schema shape + real retry exhaustion), duckdb writer (real temp-DB round trip)
+- Conversation: solver (SIMD blendshape/viseme DSP — 20+ tests covering additivity, attack/release timing, band selectivity, determinism, autonomic-channel isolation), viseme mapping, 60Hz dispatcher cadence
+- Real-time verification: `tests/rt_verification.rs` — 60fps acceptance criteria against a real shared-memory bus, velocity clamping on frames read back from shm
+
+### Next Steps
+1. `cargo build --workspace` to confirm no other crate broke.
+2. Begin real implementations for the 14 stub files (currently placeholders), starting with `autonomy_calibration.rs` and `partnership_tracker.rs` (the two non-negotiable invariant modules).
+3. User's outstanding manual step: CUPS purge (needs interactive sudo, commands provided earlier).
+

miranda-nodes/src/memory/duckdb_writer.rs

@@ -12,7 +12,7 @@
 //! rather than held open across awaits here.
 
 use chrono::{DateTime, Utc};
-use duckdb::{params, Connection, types::Value};
+use duckdb::{params, Connection};
 
 use super::entity_extractor::Entity;
 use super::mood_classifier::MoodState;
@@ -56,7 +56,12 @@ impl DuckDbWriter {
         let conn = self.connect()?;
 
         let entity_names: Vec<String> = entities.iter().map(|e| e.entity_name.clone()).collect();
-        let entity_names_value = Value::List(entity_names.into_iter().map(Value::Text).collect());
+        // duckdb-rs does not yet support binding native LIST parameters
+        // (`ToSqlConversionFailure("binding List parameters is not yet
+        // supported")`), so list columns are stored as JSON-encoded
+        // VARCHAR instead of DuckDB VARCHAR[] and decoded on read.
+        let entity_names_json =
+            serde_json::to_string(&entity_names).unwrap_or_else(|_| "[]".to_string());
 
         conn.execute(
             "INSERT INTO events (event_id, timestamp, event_type, user_message, \
@@ -69,7 +74,7 @@ impl DuckDbWriter {
                 event_type,
                 user_message,
                 miranda_response,
-                entity_names_value,
+                entity_names_json,
                 mood_state.as_str(),
                 mood_state.color_hex(),
                 Option::<String>::None,
@@ -89,7 +94,8 @@ impl DuckDbWriter {
                     entity.entity_type.as_str(),
                     timestamp.to_rfc3339(),
                     timestamp.to_rfc3339(),
-                    Value::List(vec![Value::Text(mood_state.as_str().to_string())]),
+                    serde_json::to_string(&vec![mood_state.as_str().to_string()])
+                        .unwrap_or_else(|_| "[]".to_string()),
                 ],
             )?;
         }
@@ -139,7 +145,7 @@ mod tests {
                 event_type VARCHAR NOT NULL,
                 user_message VARCHAR NOT NULL,
                 miranda_response VARCHAR NOT NULL,
-                entities VARCHAR[],
+                entities VARCHAR,
                 mood_state VARCHAR NOT NULL,
                 mood_rgb VARCHAR,
                 mood_hsl VARCHAR
@@ -150,7 +156,7 @@ mod tests {
                 first_mention TIMESTAMP NOT NULL,
                 last_mention TIMESTAMP NOT NULL,
                 mention_count INTEGER NOT NULL DEFAULT 1,
-                mood_contexts VARCHAR[],
+                mood_contexts VARCHAR,
                 PRIMARY KEY (entity_name, entity_type)
             );",
         )

miranda-nodes/src/memory/neo4j_writer.rs

@@ -264,15 +264,34 @@ mod tests {
     }
 
     /// Real integration test exercising retry-with-backoff against a
-    /// deliberately unreachable Bolt address, verifying the writer
-    /// exhausts retries and returns an error instead of hanging or
+    /// deliberately unreachable Bolt address. `neo4rs::Graph::new` pools
+    /// connections lazily, so `connect()` itself succeeds even against a
+    /// closed port; the actual failure only surfaces once a query is
+    /// attempted. This verifies `write_conversation`'s retry loop runs to
+    /// `max_retries` and returns `RetriesExhausted` instead of hanging or
     /// silently succeeding.
     #[tokio::test]
     async fn exhausts_retries_against_unreachable_host() {
-        let connect = Neo4jWriter::connect("bolt://127.0.0.1:1", "neo4j", "mirandamemory").await;
-        // neo4rs may fail fast at connect time against a closed port,
-        // which itself proves the error path works without needing the
-        // write-level retry loop.
-        assert!(connect.is_err());
+        let writer = Neo4jWriter::connect("bolt://127.0.0.1:1", "neo4j", "mirandamemory")
+            .await
+            .expect("Graph::new pools lazily and should not fail before a query is run")
+            .with_retry_policy(3, Duration::from_millis(5));
+
+        let entities: Vec<Entity> = Vec::new();
+        let record = ConversationRecord {
+            conversation_id: uuid::Uuid::new_v4(),
+            timestamp: Utc::now(),
+            user_message: "unreachable host test",
+            miranda_response: "n/a",
+            mood_state: MoodState::Curiosity,
+            intimacy_level: None,
+            entities: &entities,
+        };
+
+        let result = writer.write_conversation(&record).await;
+        match result {
+            Err(Neo4jError::RetriesExhausted { attempts, .. }) => assert_eq!(attempts, 3),
+            other => panic!("expected RetriesExhausted after 3 attempts, got {other:?}"),
+        }
     }
 }

scripts/duckdb-init.sh

@@ -27,7 +27,7 @@ CREATE TABLE IF NOT EXISTS events (
     event_type          VARCHAR NOT NULL,
     user_message        VARCHAR NOT NULL,
     miranda_response     VARCHAR NOT NULL,
-    entities             VARCHAR[],
+    entities             VARCHAR,
     mood_state           VARCHAR NOT NULL,
     mood_rgb             VARCHAR,
     mood_hsl             VARCHAR
@@ -39,7 +39,7 @@ CREATE TABLE IF NOT EXISTS entities (
     first_mention        TIMESTAMP NOT NULL,
     last_mention         TIMESTAMP NOT NULL,
     mention_count        INTEGER NOT NULL DEFAULT 1,
-    mood_contexts        VARCHAR[],
+    mood_contexts        VARCHAR,
     PRIMARY KEY (entity_name, entity_type)
 );