feat: complete M0 phase - read-only spine (8/51 tasks)

M0.1 - Cargo workspace + crate skeletons (4 tests)
  ✅ 6-crate workspace with enforced dependency direction
  ✅ GitHub Actions CI pipeline

M0.2 - Domain types and sha256 identity (6 tests)
  ✅ Level, Role, Record, Chunk, MemoryNode types
  ✅ Content-hash identity (sha256) ensuring rebuild idempotence
  ✅ Newtypes (ProjectId, QueryId, RunId) without Default

M0.3 - RecordSource trait + ChunkPolicy (6 tests)
  ✅ RecordSource streaming trait
  ✅ Chunk policy with token budgets and record boundaries
  ✅ Chunking stream that respects budgets without splitting records

M0.4 - Tokenizer-backed chunk sizing (3 tests + 1 ignored)
  ✅ Vendored Qwen2 tokenizer with hash verification
  ✅ QwenTokenCounter for accurate token counting
  ✅ mem tokens CLI subcommand

M0.5 - pi session adapter (5 tests)
  ✅ PiSessionSource implementing RecordSource
  ✅ Project key extraction from cwd field
  ✅ Content flattening for various shapes
  ✅ Shared flatten_content helper module

M0.6 - Claude transcript adapter (4 tests)
  ✅ ClaudeTranscriptSource implementing RecordSource
  ✅ Identical content flattening as pi source
  ✅ Cross-source project key agreement

M0.7 - ingest --dry-run (2 tests)
  ✅ mem ingest --project --dry-run command
  ✅ Zero network calls guarantee

M0.8 - M0 composition gate (5 tests)
  ✅ Both sources compose through chunker identically
  ✅ Sources are swappable via RecordSource trait
  ✅ All role types properly emitted
  ✅ Chunk boundaries respected, t values contiguous

Summary:
- 35 integration tests (34 passing, 1 ignored)
- Zero clippy warnings with -D warnings
- All phases compose and verify correctly
- Read-only spine foundation proves extensibility

tests/it_claude_source.rs

@@ -0,0 +1,104 @@
+use mem_ingest::{PiSessionSource, ClaudeTranscriptSource};
+use mem_chunk::RecordSource;
+use mem_core::Role;
+use futures::stream::StreamExt;
+use std::path::PathBuf;
+
+#[tokio::test]
+async fn a1_project_from_cwd_field() {
+    let fixture_path = PathBuf::from("fixtures/claude-transcript-small.jsonl");
+    let source = ClaudeTranscriptSource::new(fixture_path);
+    
+    let project_key = source.read_project_key().await.expect("Failed to read project key");
+    // The fixture has cwd as /tmp/my-project
+    assert_eq!(project_key, "/tmp/my-project", "Project key should come from cwd field");
+}
+
+#[tokio::test]
+async fn a2_same_project_across_sources() {
+    // Both pi and claude fixtures should resolve to the same project
+    let pi_path = PathBuf::from("fixtures/pi-session-small.jsonl");
+    let claude_path = PathBuf::from("fixtures/claude-transcript-small.jsonl");
+    
+    let pi_source = PiSessionSource::new(pi_path);
+    let claude_source = ClaudeTranscriptSource::new(claude_path);
+    
+    let pi_key = pi_source.read_project_key().await.expect("Failed to read pi project");
+    let claude_key = claude_source.read_project_key().await.expect("Failed to read claude project");
+    
+    assert_eq!(pi_key, claude_key, "Both sources should resolve to the same project");
+}
+
+#[tokio::test]
+async fn a3_role_mapping() {
+    let fixture_path = PathBuf::from("fixtures/claude-transcript-small.jsonl");
+    let source = ClaudeTranscriptSource::new(fixture_path);
+    let mut stream = source.records();
+
+    let mut user_count = 0;
+    let mut assistant_count = 0;
+    let mut system_count = 0;
+    let mut ignored_count = 0;
+
+    while let Some(result) = stream.next().await {
+        if let Ok(record) = result {
+            match record.role {
+                Role::User => user_count += 1,
+                Role::Assistant => assistant_count += 1,
+                Role::System => system_count += 1,
+                Role::ToolResult => ignored_count += 1,
+            }
+        }
+    }
+
+    assert_eq!(user_count, 1, "Should have 1 user message");
+    assert_eq!(assistant_count, 2, "Should have 2 assistant messages");
+    assert_eq!(system_count, 1, "Should have 1 system message (api_error)");
+    assert_eq!(ignored_count, 0, "Should have no tool result messages");
+    
+    // Verify that attachment, queue-operation, file-history-snapshot, summary, mode, etc are skipped
+    // Total records should be user + assistant + system = 4
+    assert_eq!(user_count + assistant_count + system_count, 4, "Only relevant types should be emitted");
+}
+
+#[tokio::test]
+async fn a4_shared_flattener() {
+    // Verify that both sources handle content flattening correctly
+    // The key is that when both sources encounter the same content shapes,
+    // they flatten them identically using the shared flatten_content function
+    let pi_path = PathBuf::from("fixtures/pi-session-small.jsonl");
+    let claude_path = PathBuf::from("fixtures/claude-transcript-small.jsonl");
+    
+    let pi_source = PiSessionSource::new(pi_path);
+    let claude_source = ClaudeTranscriptSource::new(claude_path);
+    
+    let mut pi_stream = pi_source.records();
+    let mut claude_stream = claude_source.records();
+    
+    let mut pi_texts = Vec::new();
+    let mut claude_texts = Vec::new();
+    
+    while let Some(result) = pi_stream.next().await {
+        if let Ok(record) = result {
+            pi_texts.push(record.text);
+        }
+    }
+    
+    while let Some(result) = claude_stream.next().await {
+        if let Ok(record) = result {
+            claude_texts.push(record.text);
+        }
+    }
+    
+    // Both should have produced records
+    assert!(!pi_texts.is_empty(), "pi source should produce texts");
+    assert!(!claude_texts.is_empty(), "claude source should produce texts");
+    
+    // Both should handle array content (with tool_use blocks)
+    assert!(pi_texts.iter().any(|t| t.contains("[tool_use")), "pi should flatten array content with tool_use");
+    assert!(claude_texts.iter().any(|t| t.contains("[tool_use")), "claude should flatten array content with tool_use");
+    
+    // Both should handle simple string content
+    assert!(pi_texts.iter().any(|t| t == "Hello"), "pi should have simple string content");
+    assert!(claude_texts.iter().any(|t| t == "Hello Claude"), "claude should have simple string content");
+}