fix(gemini): cwd filter + summary .jsonl dispatch

Close the last four Gemini parity gaps surfaced in v0.14.0 user validation.

Bug 1 — `list --agent gemini --cwd <abspath>` returned `[]`.
`resolve_gemini_chat_dirs_for_listing` only accepted an exact hash-dir
match for the abspath, so a named-scope layout (e.g. `~/.gemini/tmp/play/
chats/`) was silently excluded whenever the user passed `--cwd
/Users/.../play`. The resolver now also scans named-scope slugs and
keeps any whose slug equals the abspath's final segment, is embedded as
`/<slug>/`, or appears as trailing `/<slug>`. Hex-hash-shaped slugs stay
gated on exact hash match.

Bug 2 — `summary --agent gemini` reported `message_count: 0` for a
session that `read` walked without issue. The summary line walker
extracted `role = message.role || json.type` but only mapped `"user"`
and `"assistant"` / `"human"`. Gemini's `type: "gemini"` (and `"model"`)
fell through. Now `"gemini"` and `"model"` normalize to `"assistant"`
at the walker, matching the existing read-path mapping. Single-document
Gemini `.json` sessions are expanded into synthetic JSONL-shaped lines
so the walker works uniformly across both Gemini layouts.

Bugs 3 & 4 — `timeline --cwd` excluding Gemini and `doctor --cwd`
reporting `sessions_gemini: warn` were cascades from Bug 1; both go
through `adapter.list_sessions(Some(cwd), ...)` and now pass.

Rust and Node implementations are updated in lockstep. Conformance gets
two new cases: `summary-gemini-jsonl` for the jsonl summary path and
`list-gemini-cwd` for the lenient cwd filter. Cargo tests go 146 → 149
(one cwd-filter test, two summary tests covering .jsonl + single-doc
.json). Goldens updated: summary-gemini.json (message_count 0 → 1) and
timeline.json (Gemini entries now visible under `/workspace/demo`).

Release notes appended under the existing v0.14.0 Fixed subhead.

Author: cote-star

RELEASE_NOTES.md

@@ -58,6 +58,22 @@ v0.14.0 ships the thirteen-pass hardening effort planned in `research/agent-cont
   for every Gemini session. The scope directory name (e.g. `play`) is now returned as the cwd
   hint, so `chorus read --agent gemini --cwd <X>` filtering works for named scopes.
   Hex-hash scopes still return the hash (lossy; users can set `--chats-dir` to pin).
+- **Gemini adapter: lenient `--cwd <abspath>` filter in listings.** `chorus list --agent gemini
+  --cwd /abs/path` previously hashed the abspath and returned `[]` whenever a matching hash
+  directory didn't exist — which is the common case because Gemini CLI actually uses named
+  scopes (e.g. `~/.gemini/tmp/play/chats/`). The listing resolver now also accepts a named
+  scope whose slug equals the cwd's final segment or appears as `/<slug>/` or trailing
+  `/<slug>` within the abspath. This cascades into `chorus timeline --cwd` and
+  `chorus doctor --cwd` (both of which go through `list_sessions`), so `sessions_gemini` now
+  reports `pass` and timeline entries include Gemini when the abspath matches a named scope.
+  Hex-hash scopes are still resolved only by exact hash match.
+- **Gemini adapter: `summary` understands Gemini's role vocabulary.** `chorus summary --agent
+  gemini` used to report `message_count: 0` for `.jsonl` sessions even when `read` returned
+  multi-message content on the same file. The summary walker's role detector now maps
+  `type: "gemini"` and `type: "model"` to `assistant` (matching the existing read-path
+  mapping), and single-document `.json` sessions are expanded into synthetic line-shaped
+  entries so the walker works uniformly across both Gemini layouts. Rust and Node implementations
+  apply the same fix.
 
 ### Known Limitations
 

cli/src/agents.rs

@@ -1465,17 +1465,66 @@ fn resolve_gemini_chat_dirs(chats_dir: Option<&str>, cwd: &str) -> Result<Vec<Pa
 }
 
 fn resolve_gemini_chat_dirs_for_listing(cwd: Option<&str>) -> Result<Vec<PathBuf>> {
+    let tmp_base = gemini_tmp_base_dir();
+
     if let Some(scope) = cwd {
         let normalized_cwd = normalize_path(scope)?;
         let scoped_hash = hash_path(&normalized_cwd);
-        let dir = gemini_tmp_base_dir().join(scoped_hash).join("chats");
-        if dir.exists() {
-            return Ok(vec![dir]);
+
+        // Exact hash match (Gemini CLI's canonical layout for scoped sessions).
+        let exact = tmp_base.join(&scoped_hash).join("chats");
+        let mut ordered: Vec<PathBuf> = Vec::new();
+        let mut seen: std::collections::HashSet<PathBuf> = std::collections::HashSet::new();
+        if exact.exists() {
+            seen.insert(exact.clone());
+            ordered.push(exact);
+        }
+
+        // Lenient fallback: match scope-slug directories against the abspath.
+        // Gemini also lays sessions under `~/.gemini/tmp/<slug>/chats/` where
+        // <slug> is a short, human-named scope (e.g. `play`, `sandbox`). We
+        // accept a slug if the abspath ends with `/<slug>` or contains
+        // `/<slug>/`, or if the abspath's final segment equals the slug. Hex
+        // hash-shaped scopes are excluded from the lenient match (they are
+        // either an exact hash match handled above or a different project).
+        let cwd_str = normalized_cwd.to_string_lossy().to_string();
+        let final_segment = normalized_cwd
+            .file_name()
+            .and_then(|n| n.to_str())
+            .map(|s| s.to_string());
+        if let Ok(entries) = fs::read_dir(&tmp_base) {
+            for entry in entries.flatten() {
+                let path = entry.path();
+                if !path.is_dir() {
+                    continue;
+                }
+                let slug = match path.file_name().and_then(|n| n.to_str()) {
+                    Some(s) => s.to_string(),
+                    None => continue,
+                };
+                // Skip hash-shaped slugs — only exact-hash match is valid.
+                let is_hex_hash = slug.len() >= 40 && slug.chars().all(|c| c.is_ascii_hexdigit());
+                if is_hex_hash {
+                    continue;
+                }
+                let slug_pat_contains = format!("/{}/", slug);
+                let slug_pat_suffix = format!("/{}", slug);
+                let lenient_match = final_segment.as_deref() == Some(slug.as_str())
+                    || cwd_str.contains(&slug_pat_contains)
+                    || cwd_str.ends_with(&slug_pat_suffix);
+                if !lenient_match {
+                    continue;
+                }
+                let chats = path.join("chats");
+                if chats.exists() && seen.insert(chats.clone()) {
+                    ordered.push(chats);
+                }
+            }
         }
-        return Ok(Vec::new());
+
+        return Ok(ordered);
     }
 
-    let tmp_base = gemini_tmp_base_dir();
     let mut ordered = Vec::new();
     if let Ok(entries) = fs::read_dir(&tmp_base) {
         for entry in entries.flatten() {
@@ -3795,4 +3844,66 @@ mod tests {
         assert_eq!(cwd3, serde_json::Value::String("abc".into()));
         assert_eq!(hash3, None);
     }
+
+    /// Bug 1 regression: `--cwd <abspath>` should match a named-scope slug
+    /// (e.g. `play`) when the abspath's final segment or an embedded path
+    /// component equals the slug. Before the fix, `list_gemini_sessions`
+    /// would hash the abspath and look for the hashed directory only —
+    /// missing the actual named-scope layout Gemini CLI uses.
+    #[test]
+    fn gemini_list_lenient_cwd_filter_matches_named_scope() {
+        let _guard = gemini_list_env_lock();
+        let fixture = gemini_list_fixture("lenient_cwd");
+        // Mixed: named `play` scope with a .jsonl session + an unrelated
+        // `work` scope with a .json session. A cwd whose final segment is
+        // `play` should return only the play session.
+        let play_chats = fixture.join("play").join("chats");
+        std::fs::create_dir_all(&play_chats).unwrap();
+        std::fs::write(
+            play_chats.join("session-live.jsonl"),
+            "{\"sessionId\":\"live\"}\n{\"type\":\"gemini\",\"content\":\"hi\"}\n",
+        )
+        .unwrap();
+
+        let work_chats = fixture.join("work").join("chats");
+        std::fs::create_dir_all(&work_chats).unwrap();
+        std::fs::write(
+            work_chats.join("session-other.json"),
+            serde_json::json!({ "messages": [] }).to_string(),
+        )
+        .unwrap();
+
+        std::env::set_var("CHORUS_GEMINI_TMP_DIR", &fixture);
+
+        // Case 1: --cwd ending in `/play` picks only the play scope.
+        let out = super::list_gemini_sessions(Some("/Users/testuser/sandbox/play"), 10)
+            .expect("list_gemini_sessions play");
+        let ids: Vec<String> = out
+            .iter()
+            .map(|e| e["session_id"].as_str().unwrap_or("").to_string())
+            .collect();
+        assert_eq!(out.len(), 1, "expected 1 play session, got: {:?}", ids);
+        assert_eq!(ids[0], "session-live");
+
+        // Case 2: --cwd with `/play/` embedded (deeper subdir) also picks play.
+        let out2 = super::list_gemini_sessions(
+            Some("/Users/testuser/sandbox/play/agent-chorus"),
+            10,
+        )
+        .expect("list_gemini_sessions play subdir");
+        assert_eq!(out2.len(), 1);
+        assert_eq!(out2[0]["session_id"].as_str(), Some("session-live"));
+
+        // Case 3: --cwd unrelated to any slug returns empty.
+        let out3 = super::list_gemini_sessions(Some("/Users/testuser/elsewhere"), 10)
+            .expect("list_gemini_sessions unrelated");
+        assert!(
+            out3.is_empty(),
+            "unrelated cwd should return no sessions, got: {:?}",
+            out3,
+        );
+
+        std::env::remove_var("CHORUS_GEMINI_TMP_DIR");
+        let _ = std::fs::remove_dir_all(&fixture);
+    }
 }

cli/src/summary.rs

@@ -168,9 +168,30 @@ pub fn build_summary(
     let source_path = session.source.clone();
     let session_warnings = session.warnings.clone();
 
-    // Now parse the raw file for summary extraction
+    // Now parse the raw file for summary extraction.
+    //
+    // Extension dispatch: .jsonl files parse line-by-line; Gemini also writes
+    // single-document .json files (older CLI layout) whose contents won't
+    // survive the per-line JSON parser. For those, walk `session.messages`
+    // and `session.history` and re-serialize each entry as a synthetic JSONL
+    // line so the downstream walker can consume them unchanged.
     let path = Path::new(&source_path);
-    let lines = agents::read_jsonl_lines(path).unwrap_or_default();
+    let is_single_doc_json = path
+        .extension()
+        .and_then(|e| e.to_str())
+        .map(|e| e.eq_ignore_ascii_case("json"))
+        .unwrap_or(false);
+    let lines: Vec<String> = if is_single_doc_json {
+        match std::fs::read_to_string(path) {
+            Ok(raw) => match serde_json::from_str::<Value>(&raw) {
+                Ok(doc) => synthesize_gemini_jsonl_lines(&doc),
+                Err(_) => Vec::new(),
+            },
+            Err(_) => Vec::new(),
+        }
+    } else {
+        agents::read_jsonl_lines(path).unwrap_or_default()
+    };
 
     let mut user_requests: Vec<String> = Vec::new();
     let mut tool_call_counts: BTreeMap<String, usize> = BTreeMap::new();
@@ -226,12 +247,20 @@ pub fn build_summary(
 
         // Claude-format messages
         let message = json.get("message").unwrap_or(&json);
-        let role = message
+        let raw_role = message
             .get("role")
             .or_else(|| json.get("type"))
             .and_then(|v| v.as_str())
             .unwrap_or("")
             .to_lowercase();
+        // Normalize Gemini's role vocabulary: `type: "gemini"` and
+        // `type: "model"` both map to `assistant`. Without this, Gemini
+        // .jsonl sessions produce message_count: 0 in the summary even
+        // though `read` returns a non-empty content.
+        let role = match raw_role.as_str() {
+            "gemini" | "model" => "assistant".to_string(),
+            other => other.to_string(),
+        };
 
         if role == "user" || role == "human" {
             let content = message
@@ -336,6 +365,61 @@ pub fn build_summary(
     })
 }
 
+/// Expand a single-document Gemini session into synthetic JSONL-shaped lines.
+///
+/// Accepts both historical Gemini schemas:
+///   - `{ "messages": [ { "type": "user"|"gemini"|..., "content": ... } ] }`
+///   - `{ "history":  [ { "role": "user"|"model", "parts": [...] } ] }`
+///
+/// Each returned string is a compact JSON object the summary walker can parse
+/// like a regular .jsonl line. Non-text and malformed entries are skipped.
+fn synthesize_gemini_jsonl_lines(doc: &Value) -> Vec<String> {
+    let mut out = Vec::new();
+    if let Some(messages) = doc.get("messages").and_then(|v| v.as_array()) {
+        for msg in messages {
+            if msg.is_object() {
+                if let Ok(s) = serde_json::to_string(msg) {
+                    out.push(s);
+                }
+            }
+        }
+        return out;
+    }
+    if let Some(history) = doc.get("history").and_then(|v| v.as_array()) {
+        for turn in history {
+            // Normalize `{role,parts}` into `{type,content}` so the walker's
+            // role+content extraction path applies unchanged.
+            let role = turn
+                .get("role")
+                .and_then(|v| v.as_str())
+                .unwrap_or("")
+                .to_lowercase();
+            let mapped_type = if role == "user" { "user" } else { "gemini" };
+            let text = if let Some(arr) = turn.get("parts").and_then(|v| v.as_array()) {
+                arr.iter()
+                    .filter_map(|p| p.get("text").and_then(|t| t.as_str()))
+                    .collect::<Vec<&str>>()
+                    .join("\n")
+            } else if let Some(s) = turn.get("parts").and_then(|v| v.as_str()) {
+                s.to_string()
+            } else {
+                String::new()
+            };
+            if text.is_empty() {
+                continue;
+            }
+            let synth = serde_json::json!({
+                "type": mapped_type,
+                "content": text,
+            });
+            if let Ok(s) = serde_json::to_string(&synth) {
+                out.push(s);
+            }
+        }
+    }
+    out
+}
+
 /// Extract tool call counts from a Claude-style content array.
 fn extract_tool_call_summary(content: &[Value], counts: &mut BTreeMap<String, usize>) {
     for block in content {
@@ -449,3 +533,105 @@ fn capitalize(s: &str) -> String {
         Some(c) => c.to_uppercase().collect::<String>() + chars.as_str(),
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::utils::hash_path;
+
+    fn summary_env_lock() -> std::sync::MutexGuard<'static, ()> {
+        use std::sync::{Mutex, OnceLock};
+        static LOCK: OnceLock<Mutex<()>> = OnceLock::new();
+        LOCK.get_or_init(|| Mutex::new(()))
+            .lock()
+            .unwrap_or_else(|e| e.into_inner())
+    }
+
+    fn fresh_fixture(name: &str) -> std::path::PathBuf {
+        let dir = std::env::temp_dir().join(format!("chorus_summary_{}", name));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(&dir).expect("create fixture dir");
+        dir
+    }
+
+    /// Bug 2 regression: Gemini .jsonl session produces a non-zero
+    /// `message_count` in the summary output. Before the fix, the summary
+    /// walker treated `type: "gemini"` as a non-role and returned 0 even
+    /// though `read` returned 27+ messages on the same file.
+    #[test]
+    fn gemini_summary_counts_assistant_messages_from_jsonl() {
+        let _guard = summary_env_lock();
+        let fixture = fresh_fixture("gemini_jsonl_count");
+        // Use the hash layout so the default resolve path finds the session
+        // when we pass --cwd /tmp/fake-project.
+        let fake_cwd_str = "/tmp/fake-project";
+        let fake_cwd = std::path::PathBuf::from(fake_cwd_str);
+        let scoped_hash = hash_path(&fake_cwd);
+        let chats = fixture.join(&scoped_hash).join("chats");
+        std::fs::create_dir_all(&chats).unwrap();
+        // Header + two assistant messages + one user message +
+        // a `$set` metadata event to exercise skipping.
+        let jsonl = concat!(
+            "{\"sessionId\":\"test-session\"}\n",
+            "{\"id\":\"u1\",\"type\":\"user\",\"content\":\"hello there\",\"timestamp\":\"2026-04-24T17:48:52.144Z\"}\n",
+            "{\"$set\":{\"lastUpdated\":\"2026-04-24T17:48:52.145Z\"}}\n",
+            "{\"id\":\"g1\",\"type\":\"gemini\",\"content\":\"first reply\",\"timestamp\":\"2026-04-24T17:48:59.748Z\"}\n",
+            "{\"id\":\"g2\",\"type\":\"gemini\",\"content\":\"second reply\",\"timestamp\":\"2026-04-24T17:49:10.000Z\"}\n",
+        );
+        std::fs::write(chats.join("session-test.jsonl"), jsonl).unwrap();
+
+        std::env::set_var("CHORUS_GEMINI_TMP_DIR", &fixture);
+        let res = super::build_summary("gemini", None, fake_cwd_str, None)
+            .expect("build_summary");
+        std::env::remove_var("CHORUS_GEMINI_TMP_DIR");
+
+        assert_eq!(res.message_count, 2, "expected 2 assistant messages");
+        assert_eq!(
+            res.user_requests.len(),
+            1,
+            "expected 1 user request captured, got {:?}",
+            res.user_requests
+        );
+        assert!(
+            res.last_response_snippet.as_deref().unwrap_or("").contains("second reply"),
+            "last snippet should come from the last gemini message: {:?}",
+            res.last_response_snippet,
+        );
+
+        let _ = std::fs::remove_dir_all(&fixture);
+    }
+
+    /// Also verify the single-document .json path still summarizes correctly
+    /// after the extension dispatch was introduced.
+    #[test]
+    fn gemini_summary_counts_assistant_messages_from_single_doc_json() {
+        let _guard = summary_env_lock();
+        let fixture = fresh_fixture("gemini_json_count");
+        let fake_cwd_str = "/tmp/fake-project-json";
+        let fake_cwd = std::path::PathBuf::from(fake_cwd_str);
+        let scoped_hash = hash_path(&fake_cwd);
+        let chats = fixture.join(&scoped_hash).join("chats");
+        std::fs::create_dir_all(&chats).unwrap();
+        let doc = serde_json::json!({
+            "sessionId": "json-session",
+            "messages": [
+                { "type": "user", "content": "q1" },
+                { "type": "gemini", "content": "a1" },
+                { "type": "user", "content": "q2" },
+                { "type": "gemini", "content": "a2" },
+                { "type": "gemini", "content": "a3" },
+            ],
+        });
+        std::fs::write(chats.join("session-test.json"), doc.to_string()).unwrap();
+
+        std::env::set_var("CHORUS_GEMINI_TMP_DIR", &fixture);
+        let res = super::build_summary("gemini", None, fake_cwd_str, None)
+            .expect("build_summary");
+        std::env::remove_var("CHORUS_GEMINI_TMP_DIR");
+
+        assert_eq!(res.message_count, 3, "expected 3 assistant messages");
+        assert_eq!(res.user_requests.len(), 2);
+
+        let _ = std::fs::remove_dir_all(&fixture);
+    }
+}