Fix tests

headroom/learn/scanner.py

@@ -434,9 +434,7 @@ def _greedy_path_decode(base: Path, parts: list[str]) -> Path | None:
         return None
 
     try:
-        children = sorted(
-            child for child in base.iterdir() if child.is_dir() and not child.name.startswith(".")
-        )
+        children = sorted(child for child in base.iterdir() if child.is_dir())
     except OSError:
         return None
 
@@ -496,6 +494,12 @@ class CodexScanner(ConversationScanner):
         self.codex_dir = codex_dir or Path.home() / ".codex"
         self.sessions_dir = self.codex_dir / "sessions"
 
+    def _iter_session_files(self, root: Path | None = None) -> list[Path]:
+        """Return all known Codex session files, including nested rollouts."""
+        search_root = root or self.sessions_dir
+        session_files = list(search_root.rglob("*.json")) + list(search_root.rglob("*.jsonl"))
+        return sorted(path for path in session_files if path.is_file())
+
     def discover_projects(self) -> list[ProjectInfo]:
         """Codex doesn't organize by project — return a single 'codex' project.
 
@@ -505,7 +509,7 @@ class CodexScanner(ConversationScanner):
         if not self.sessions_dir.exists():
             return []
 
-        session_files = list(self.sessions_dir.glob("*.json"))
+        session_files = self._iter_session_files()
         if not session_files:
             return []
 
@@ -526,13 +530,19 @@ class CodexScanner(ConversationScanner):
     def scan_project(self, project: ProjectInfo) -> list[SessionData]:
         """Scan all Codex session JSON files."""
         sessions = []
-        for json_path in sorted(project.data_path.glob("*.json")):
+        for json_path in self._iter_session_files(project.data_path):
             session = self._scan_session(json_path)
             if session and session.tool_calls:
                 sessions.append(session)
         return sessions
 
     def _scan_session(self, json_path: Path) -> SessionData | None:
+        """Parse a single Codex session file."""
+        if json_path.suffix == ".jsonl":
+            return self._scan_jsonl_session(json_path)
+        return self._scan_json_session(json_path)
+
+    def _scan_json_session(self, json_path: Path) -> SessionData | None:
         """Parse a single Codex session file."""
         try:
             with open(json_path) as f:
@@ -623,3 +633,121 @@ class CodexScanner(ConversationScanner):
                 )
 
         return SessionData(session_id=session_id, tool_calls=tool_calls)
+
+    def _scan_jsonl_session(self, jsonl_path: Path) -> SessionData | None:
+        """Parse a modern Codex rollout session stored as JSONL."""
+        session_id = jsonl_path.stem
+        func_calls: dict[str, tuple[str, dict]] = {}
+        tool_calls: list[ToolCall] = []
+        msg_index = 0
+
+        try:
+            with open(jsonl_path) as f:
+                for line in f:
+                    try:
+                        entry = json.loads(line)
+                    except json.JSONDecodeError:
+                        continue
+
+                    if entry.get("type") == "session_meta":
+                        payload = entry.get("payload", {})
+                        if isinstance(payload, dict):
+                            session_id = payload.get("id", session_id)
+                        continue
+
+                    if entry.get("type") != "response_item":
+                        continue
+
+                    payload = entry.get("payload", {})
+                    if not isinstance(payload, dict):
+                        continue
+
+                    msg_index += 1
+                    item_type = payload.get("type", "")
+
+                    if item_type in ("function_call", "custom_tool_call"):
+                        call_id = payload.get("call_id", "")
+                        name = payload.get("name", "")
+                        parsed = self._parse_codex_arguments(payload)
+                        name, parsed = self._normalize_codex_tool(name, parsed)
+                        if call_id and name:
+                            func_calls[call_id] = (name, parsed)
+                        continue
+
+                    if item_type not in ("function_call_output", "custom_tool_call_output"):
+                        continue
+
+                    call_id = payload.get("call_id", "")
+                    if call_id not in func_calls:
+                        continue
+
+                    name, inp = func_calls[call_id]
+                    result_content = self._parse_codex_output(payload.get("output", ""))
+                    is_err = is_error_content(result_content)
+                    error_cat = classify_error(result_content) if is_err else ErrorCategory.UNKNOWN
+
+                    tool_calls.append(
+                        ToolCall(
+                            name=name,
+                            tool_call_id=call_id,
+                            input_data=inp,
+                            output=result_content,
+                            is_error=is_err,
+                            error_category=error_cat,
+                            msg_index=msg_index,
+                            output_bytes=len(result_content.encode("utf-8")),
+                        )
+                    )
+
+        except OSError as e:
+            logger.debug("Failed to read Codex session %s: %s", jsonl_path, e)
+            return None
+
+        if not tool_calls:
+            return None
+
+        return SessionData(session_id=session_id, tool_calls=tool_calls)
+
+    def _parse_codex_arguments(self, payload: dict) -> dict:
+        """Parse arguments for either legacy or rollout Codex tool calls."""
+        raw_args = payload.get("arguments", payload.get("input", ""))
+        if isinstance(raw_args, str):
+            try:
+                parsed = json.loads(raw_args)
+                return parsed if isinstance(parsed, dict) else {"raw": raw_args}
+            except (json.JSONDecodeError, TypeError):
+                return {"raw": raw_args}
+        if isinstance(raw_args, dict):
+            return raw_args
+        return {"raw": str(raw_args)}
+
+    def _normalize_codex_tool(self, name: str, parsed: dict) -> tuple[str, dict]:
+        """Normalize modern Codex tool names to the cross-agent schema."""
+        if name == "shell" and "command" in parsed:
+            cmd = parsed["command"]
+            if isinstance(cmd, list):
+                parsed["command"] = cmd[-1] if cmd else ""
+            return "Bash", parsed
+
+        if name == "exec_command" and "cmd" in parsed:
+            parsed = dict(parsed)
+            parsed["command"] = parsed.get("cmd", "")
+            return "Bash", parsed
+
+        return name, parsed
+
+    def _parse_codex_output(self, output_raw: object) -> str:
+        """Parse tool output from Codex rollout records."""
+        if isinstance(output_raw, str):
+            try:
+                parsed_out = json.loads(output_raw)
+            except (json.JSONDecodeError, TypeError):
+                return output_raw
+
+            if isinstance(parsed_out, dict):
+                if "output" in parsed_out:
+                    return str(parsed_out["output"])
+                return json.dumps(parsed_out)
+            return output_raw
+
+        return str(output_raw)

tests/test_learn/test_integration.py

@@ -123,6 +123,9 @@ class TestFalsePositiveFiltering:
 CLAUDE_DIR = Path.home() / ".claude" / "projects"
 CODEX_DIR = Path.home() / ".codex" / "sessions"
 HAS_API_KEY = bool(os.environ.get("ANTHROPIC_API_KEY"))
+HAS_CODEX_DATA = CODEX_DIR.exists() and (
+    any(CODEX_DIR.rglob("*.json")) or any(CODEX_DIR.rglob("*.jsonl"))
+)
 
 
 @pytest.mark.skipif(not CLAUDE_DIR.exists(), reason="No Claude Code data")
@@ -193,7 +196,7 @@ class TestClaudeCodeIntegration:
         }
         with patch("headroom.learn.analyzer._call_llm", return_value=mock_response):
             sessions = scanner.scan_project(best)
-            result = SessionAnalyzer().analyze(best, sessions)
+            result = SessionAnalyzer(model="gpt-4o").analyze(best, sessions)
             recs = result.recommendations
 
             writer = ClaudeCodeWriter()
@@ -240,7 +243,7 @@ class TestDecodeProjectPath:
         assert result == tmp_path / "GitHub.nosync"
 
 
-@pytest.mark.skipif(not CODEX_DIR.exists(), reason="No Codex data")
+@pytest.mark.skipif(not HAS_CODEX_DATA, reason="No Codex data")
 class TestCodexIntegration:
     """Integration tests against real Codex session data."""