fix: detect Codex session via state_*.sqlite threads table

Codex >= ~0.118 moved session state from per-session rollout JSONL files
to a SQLite database (~/.codex/state_*.sqlite). Long-lived sessions keep
the same thread ID and just bump updated_at — no new rollout file is
written, causing the rollout walker (now Method 4) to miss them.

Add Method 3: query the threads table directly, filtering by cwd and
preferring recently-updated unarchived threads. The DB file is found via
python3 glob (no ls -t pipe), opened read-only to avoid contention with
a running Codex writer.

- Renumber rollout JSONL walker from Method 3 to Method 4
- Add unit tests: cwd match, cwd miss, archived exclusion, dedup across
  panes, and priority over rollout JSONL fallback

Based on analysis of the Codex source (codex-rs/state/) confirming
the threads table schema and update semantics.

Co-authored-by: Thomas Andersen <MrVampy@users.noreply.github.com>

Author: timvw

scripts/save-assistant-sessions.sh

@@ -177,9 +177,90 @@ get_codex_session() {
 		return
 	fi
 
-	# Method 3: Codex rollout session files (newer Codex versions).
-	# Newer releases persist session metadata under ~/.codex/sessions/*/*.jsonl
-	# and include a session_meta record with both id and cwd.
+	# Method 3: Codex thread state DB (Codex >= ~0.118 persist state in
+	# SQLite: ~/.codex/state_*.sqlite, table `threads`, columns id/cwd/
+	# updated_at/archived).  This is the canonical current source — codex
+	# writes a `threads` row per session and bumps `updated_at` on every
+	# user turn.  A long-lived session that started days ago keeps its
+	# same `id` in this table even though no new rollout JSONL is ever
+	# written, which is exactly the case Method 4 misses.
+	#
+	# Strategy: among threads matching our process's cwd that are unarchived
+	# and have been updated during this process's lifetime, pick the most
+	# recently updated one that isn't already assigned to another pane.
+	#
+	# The DB file is versioned (state_5.sqlite, bumping on schema changes).
+	# We glob for state_*.sqlite inside python3 (avoids `ls -t` pipe and
+	# handles spaces in paths cleanly) and pick the newest by mtime.
+	if [ -n "$cwd" ] && command -v python3 >/dev/null 2>&1; then
+		local etimes
+		etimes=$(ps -o etimes= -p "$child_pid" 2>/dev/null | tr -d ' ' || true)
+		sid=$(
+			USED_CODEX_SESSION_IDS="$USED_CODEX_SESSION_IDS" python3 - "$HOME/.codex" "$cwd" "$etimes" <<'PY'
+import glob, os, sqlite3, sys, time
+
+codex_home = sys.argv[1]
+cwd = sys.argv[2]
+etimes_raw = sys.argv[3].strip()
+used = {sid for sid in os.environ.get("USED_CODEX_SESSION_IDS", "").split("\t") if sid}
+
+# Find the newest state_*.sqlite by mtime.
+dbs = sorted(glob.glob(os.path.join(codex_home, "state_*.sqlite")),
+             key=os.path.getmtime, reverse=True)
+if not dbs:
+    sys.exit(0)
+
+process_start = None
+if etimes_raw.isdigit():
+    process_start = time.time() - int(etimes_raw)
+
+# Open read-only so we never conflict with a running codex writer.
+try:
+    con = sqlite3.connect(f"file:{dbs[0]}?mode=ro", uri=True)
+except sqlite3.Error:
+    sys.exit(0)
+
+try:
+    cur = con.cursor()
+    cur.execute(
+        "SELECT id, updated_at FROM threads "
+        "WHERE cwd = ? AND archived = 0 "
+        "ORDER BY updated_at DESC",
+        (cwd,),
+    )
+    rows = cur.fetchall()
+finally:
+    con.close()
+
+# Prefer threads whose last update happened after the process started
+# (rules out stale threads in the same cwd). Fall back to most-recent
+# overall if nothing qualifies — covers the edge case where a session
+# was spawned but hasn't had any user turns yet.
+def pick(rows, require_after_start):
+    for sid, updated_at in rows:
+        if sid in used:
+            continue
+        if require_after_start and process_start is not None and updated_at < process_start:
+            continue
+        return sid
+    return None
+
+sid = pick(rows, require_after_start=True) or pick(rows, require_after_start=False)
+if sid:
+    print(sid)
+PY
+		)
+		if [ -n "$sid" ]; then
+			echo "$sid"
+			return
+		fi
+	fi
+
+	# Method 4: Codex rollout session files (Codex ~0.100-0.117 wrote
+	# these; newer versions have moved to SQLite, see Method 3).
+	# Releases in that window persisted session metadata under
+	# ~/.codex/sessions/*/*.jsonl and included a session_meta record
+	# with both id and cwd.
 	# We rank candidates by:
 	# - matching cwd
 	# - preferring session IDs not already assigned during this save

test/run-tests.sh

@@ -1002,9 +1002,102 @@ assert_eq "Codex resume extraction" "ses_codex_789" "$(get_codex_session 99999 "
 assert_eq "Codex resume with path" "ses_codex_789" "$(get_codex_session 99999 "/usr/bin/codex resume ses_codex_789")"
 assert_eq "Codex bare (no resume)" "" "$(get_codex_session 99999 "codex")"
 
-# --- Codex: rollout session files (Method 3) ---
-# Newer Codex versions write session metadata to ~/.codex/sessions/*/*.jsonl
-# instead of session-tags.jsonl. Test that get_codex_session can find them.
+# --- Codex: state_*.sqlite thread DB (Method 3) ---
+# Codex >= ~0.118 persists thread state in SQLite. The save script queries
+# the threads table by cwd, preferring recently-updated unarchived threads.
+
+echo ""
+echo "=== Codex state DB: thread lookup via state_*.sqlite ==="
+echo ""
+
+STATEDB_TEST_DIR=$(mktemp -d)
+mkdir -p "$STATEDB_TEST_DIR/.codex"
+
+# Create a test state DB with the threads table
+python3 - "$STATEDB_TEST_DIR/.codex/state_5.sqlite" <<'DBSETUP'
+import sqlite3, sys, time
+db = sys.argv[1]
+conn = sqlite3.connect(db)
+conn.execute('''CREATE TABLE threads (
+    id TEXT PRIMARY KEY,
+    rollout_path TEXT NOT NULL,
+    created_at INTEGER NOT NULL,
+    updated_at INTEGER NOT NULL,
+    source TEXT NOT NULL,
+    model_provider TEXT NOT NULL,
+    cwd TEXT NOT NULL,
+    title TEXT NOT NULL,
+    sandbox_policy TEXT NOT NULL,
+    approval_mode TEXT NOT NULL,
+    tokens_used INTEGER NOT NULL DEFAULT 0,
+    has_user_event INTEGER NOT NULL DEFAULT 0,
+    archived INTEGER NOT NULL DEFAULT 0,
+    archived_at INTEGER
+)''')
+now = int(time.time())
+# Active thread matching test cwd — updated recently
+conn.execute('''INSERT INTO threads (id, rollout_path, created_at, updated_at, source,
+    model_provider, cwd, title, sandbox_policy, approval_mode)
+    VALUES (?, '', ?, ?, 'cli', 'openai', '/tmp/statedb-project', 'active', 'relaxed', 'auto')''',
+    ('ses_statedb_active', now - 3600, now - 10))
+# Older thread same cwd — should lose to the active one
+conn.execute('''INSERT INTO threads (id, rollout_path, created_at, updated_at, source,
+    model_provider, cwd, title, sandbox_policy, approval_mode)
+    VALUES (?, '', ?, ?, 'cli', 'openai', '/tmp/statedb-project', 'old', 'relaxed', 'auto')''',
+    ('ses_statedb_old', now - 86400, now - 86400))
+# Archived thread same cwd — should be excluded
+conn.execute('''INSERT INTO threads (id, rollout_path, created_at, updated_at, source,
+    model_provider, cwd, title, sandbox_policy, approval_mode, archived, archived_at)
+    VALUES (?, '', ?, ?, 'cli', 'openai', '/tmp/statedb-project', 'archived', 'relaxed', 'auto', 1, ?)''',
+    ('ses_statedb_archived', now - 7200, now - 5, now - 5))
+# Thread in different cwd — should not match
+conn.execute('''INSERT INTO threads (id, rollout_path, created_at, updated_at, source,
+    model_provider, cwd, title, sandbox_policy, approval_mode)
+    VALUES (?, '', ?, ?, 'cli', 'openai', '/tmp/other-project', 'other', 'relaxed', 'auto')''',
+    ('ses_statedb_other', now - 100, now - 1))
+conn.commit()
+conn.close()
+DBSETUP
+
+ORIG_HOME="$HOME"
+HOME="$STATEDB_TEST_DIR"
+
+# Should find the most recently updated active thread for the matching cwd
+statedb_sid=$(get_codex_session $$ "codex" "/tmp/statedb-project")
+assert_eq "Codex state DB: finds active thread by cwd" "ses_statedb_active" "$statedb_sid"
+
+# Should NOT match a different cwd
+statedb_miss=$(get_codex_session $$ "codex" "/tmp/nonexistent")
+assert_eq "Codex state DB: no match for different cwd" "" "$statedb_miss"
+
+# Dedup: after claiming ses_statedb_active, next call should get ses_statedb_old
+USED_CODEX_SESSION_IDS=""
+statedb_first=$(get_codex_session $$ "codex" "/tmp/statedb-project")
+register_codex_session_id "$statedb_first"
+statedb_second=$(get_codex_session $$ "codex" "/tmp/statedb-project")
+
+if [ -n "$statedb_first" ] && [ -n "$statedb_second" ] && [ "$statedb_first" != "$statedb_second" ]; then
+	pass "Codex state DB dedup: two calls get distinct sessions ($statedb_first vs $statedb_second)"
+else
+	fail "Codex state DB dedup: expected distinct sessions, got '$statedb_first' and '$statedb_second'"
+fi
+USED_CODEX_SESSION_IDS=""
+
+# Should prefer state DB (Method 3) over rollout JSONL (Method 4) when both exist
+mkdir -p "$STATEDB_TEST_DIR/.codex/sessions/2026/04/23"
+cat >"$STATEDB_TEST_DIR/.codex/sessions/2026/04/23/rollout-statedb-test.jsonl" <<'ROLLOUT'
+{"timestamp":"2026-04-23T10:00:00.000Z","type":"session_meta","payload":{"id":"ses_rollout_loser","timestamp":"2026-04-23T10:00:00.000Z","cwd":"/tmp/statedb-project","originator":"codex_cli_rs","cli_version":"0.116.0"}}
+ROLLOUT
+
+statedb_priority=$(get_codex_session $$ "codex" "/tmp/statedb-project")
+assert_eq "Codex state DB takes priority over rollout JSONL" "ses_statedb_active" "$statedb_priority"
+
+HOME="$ORIG_HOME"
+rm -rf "$STATEDB_TEST_DIR"
+
+# --- Codex: rollout session files (Method 4) ---
+# Codex ~0.100-0.117 wrote session metadata to ~/.codex/sessions/*/*.jsonl.
+# Newer versions use SQLite (Method 3). Test the JSONL fallback.
 
 ROLLOUT_TEST_DIR=$(mktemp -d)
 mkdir -p "$ROLLOUT_TEST_DIR/.codex/sessions/2026/03/24"