@ai-devkit/agent-manager 0.19.1 → 0.21.0

package/src/__tests__/adapters/CodexAdapter.test.ts

@@ -95,6 +95,11 @@ describe('CodexAdapter', () => {
     });
 
     describe('detectAgents', () => {
+        async function useRealSessionMatcher(): Promise<void> {
+            const actualMatching = await vi.importActual<typeof import('../../utils/matching.js')>('../../utils/matching.js');
+            mockedMatchProcessesToSessions.mockImplementation(actualMatching.matchProcessesToSessions);
+        }
+
         it('should return empty list when no codex process is running', async () => {
             mockedListAgentProcesses.mockReturnValue([]);
 
@@ -190,6 +195,163 @@ describe('CodexAdapter', () => {
             fs.rmSync(tmpDir, { recursive: true, force: true });
         });
 
+        it('should match when session_meta timestamp and file birthtime both align with process start', async () => {
+            await useRealSessionMatcher();
+            const processStart = new Date('2026-03-18T15:00:00.000Z');
+            const sessionTimestamp = '2026-03-18T15:00:05.000Z';
+            const processes: ProcessInfo[] = [
+                {
+                    pid: 101,
+                    command: 'codex',
+                    cwd: '/repo-a',
+                    tty: 'ttys001',
+                    startTime: processStart,
+                },
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+
+            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codex-test-'));
+            const sessionsDir = path.join(tmpDir, 'sessions');
+            const dateDir = path.join(sessionsDir, '2026', '03', '18');
+            fs.mkdirSync(dateDir, { recursive: true });
+
+            const sessionFile = path.join(dateDir, 'sess-aligned.jsonl');
+            fs.writeFileSync(sessionFile, [
+                JSON.stringify({ type: 'session_meta', payload: { id: 'sess-aligned', timestamp: sessionTimestamp, cwd: '/repo-a' } }),
+                JSON.stringify({ type: 'event', timestamp: sessionTimestamp, payload: { type: 'token_count', message: 'Aligned session' } }),
+            ].join('\n'));
+
+            (adapter as any).codexSessionsDir = sessionsDir;
+            mockedBatchGetSessionFileBirthtimes.mockReturnValue([
+                {
+                    sessionId: 'sess-aligned',
+                    filePath: sessionFile,
+                    projectDir: dateDir,
+                    birthtimeMs: new Date(sessionTimestamp).getTime(),
+                    resolvedCwd: '',
+                },
+            ]);
+
+            const agents = await adapter.detectAgents();
+
+            expect(agents).toHaveLength(1);
+            expect(agents[0]).toMatchObject({
+                pid: 101,
+                sessionId: 'sess-aligned',
+                summary: 'Aligned session',
+            });
+
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        });
+
+        it('should match late-created session files using session_meta timestamp', async () => {
+            await useRealSessionMatcher();
+            const processStart = new Date('2026-03-18T15:00:00.000Z');
+            const sessionTimestamp = '2026-03-18T15:00:10.000Z';
+            const lateBirthtime = new Date('2026-03-18T15:05:30.000Z').getTime();
+            const processes: ProcessInfo[] = [
+                {
+                    pid: 102,
+                    command: 'codex',
+                    cwd: '/repo-a',
+                    tty: 'ttys001',
+                    startTime: processStart,
+                },
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+
+            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codex-test-'));
+            const sessionsDir = path.join(tmpDir, 'sessions');
+            const dateDir = path.join(sessionsDir, '2026', '03', '18');
+            fs.mkdirSync(dateDir, { recursive: true });
+
+            const sessionFile = path.join(dateDir, 'sess-late.jsonl');
+            fs.writeFileSync(sessionFile, [
+                JSON.stringify({ type: 'session_meta', payload: { id: 'sess-late', timestamp: sessionTimestamp, cwd: '/repo-a' } }),
+                JSON.stringify({ type: 'event', timestamp: sessionTimestamp, payload: { type: 'token_count', message: 'Late file session' } }),
+            ].join('\n'));
+
+            (adapter as any).codexSessionsDir = sessionsDir;
+            mockedBatchGetSessionFileBirthtimes.mockReturnValue([
+                {
+                    sessionId: 'sess-late',
+                    filePath: sessionFile,
+                    projectDir: dateDir,
+                    birthtimeMs: lateBirthtime,
+                    resolvedCwd: '',
+                },
+            ]);
+
+            const agents = await adapter.detectAgents();
+
+            expect(agents).toHaveLength(1);
+            expect(agents[0]).toMatchObject({
+                pid: 102,
+                sessionId: 'sess-late',
+                summary: 'Late file session',
+            });
+            expect(mockedMatchProcessesToSessions.mock.calls[0][1][0].birthtimeMs).toBe(new Date(sessionTimestamp).getTime());
+
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        });
+
+        it.each<[string, string | undefined]>([
+            ['missing', undefined],
+            ['invalid', 'not-a-date'],
+        ])('should fall back to file birthtime when session_meta timestamp is %s', async (_label, metaTimestamp) => {
+            await useRealSessionMatcher();
+            const processStart = new Date('2026-03-18T15:00:00.000Z');
+            const fileBirthtime = new Date('2026-03-18T15:00:20.000Z').getTime();
+            const processes: ProcessInfo[] = [
+                {
+                    pid: 103,
+                    command: 'codex',
+                    cwd: '/repo-a',
+                    tty: 'ttys001',
+                    startTime: processStart,
+                },
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+
+            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codex-test-'));
+            const sessionsDir = path.join(tmpDir, 'sessions');
+            const dateDir = path.join(sessionsDir, '2026', '03', '18');
+            fs.mkdirSync(dateDir, { recursive: true });
+
+            const payload: { id: string; cwd: string; timestamp?: string } = { id: `sess-${_label}`, cwd: '/repo-a' };
+            if (metaTimestamp !== undefined) {
+                payload.timestamp = metaTimestamp;
+            }
+
+            const sessionFile = path.join(dateDir, `sess-${_label}.jsonl`);
+            fs.writeFileSync(sessionFile, [
+                JSON.stringify({ type: 'session_meta', payload }),
+                JSON.stringify({ type: 'event', timestamp: '2026-03-18T15:00:30.000Z', payload: { type: 'token_count', message: `${_label} timestamp session` } }),
+            ].join('\n'));
+
+            (adapter as any).codexSessionsDir = sessionsDir;
+            mockedBatchGetSessionFileBirthtimes.mockReturnValue([
+                {
+                    sessionId: `sess-${_label}`,
+                    filePath: sessionFile,
+                    projectDir: dateDir,
+                    birthtimeMs: fileBirthtime,
+                    resolvedCwd: '',
+                },
+            ]);
+
+            const agents = await adapter.detectAgents();
+
+            expect(agents).toHaveLength(1);
+            expect(agents[0].sessionId).toBe(`sess-${_label}`);
+            expect(mockedMatchProcessesToSessions.mock.calls[0][1][0].birthtimeMs).toBe(fileBirthtime);
+
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        });
+
         it('should fall back to process-only for unmatched processes', async () => {
             const processes: ProcessInfo[] = [
                 { pid: 100, command: 'codex', cwd: '/repo-a', tty: 'ttys001', startTime: new Date() },
@@ -393,6 +555,127 @@ describe('CodexAdapter', () => {
                 fs.rmSync(tmpDir, { recursive: true, force: true });
             }
         });
+
+        it('should map a running Codex process from the hook session mapping', async () => {
+            const originalHome = process.env.HOME;
+            const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'codex-mapping-'));
+            process.env.HOME = tmpHome;
+
+            try {
+                const mappedAdapter = new CodexAdapter(new AgentRegistry(path.join(tmpHome, 'agents.json')));
+                const sessionsDir = path.join(tmpHome, '.codex', 'sessions');
+                const dateDir = path.join(sessionsDir, '2026', '06', '26');
+                const mappingPath = path.join(tmpHome, '.codex', 'ai-devkit', 'sessions.json');
+                const sessionFile = path.join(dateDir, 'rollout-2026-06-26T09-56-12-sess-mapped.jsonl');
+                const recentTs = new Date().toISOString();
+
+                fs.mkdirSync(dateDir, { recursive: true });
+                fs.mkdirSync(path.dirname(mappingPath), { recursive: true });
+                fs.writeFileSync(sessionFile, [
+                    JSON.stringify({ type: 'session_meta', payload: { id: 'sess-mapped', timestamp: recentTs, cwd: '/repo-mapped' } }),
+                    JSON.stringify({ type: 'event', timestamp: recentTs, payload: { type: 'agent_message', message: 'mapped conversation' } }),
+                ].join('\n'));
+                fs.writeFileSync(mappingPath, JSON.stringify({ 5151: sessionFile }));
+
+                const processes: ProcessInfo[] = [
+                    {
+                        pid: 5151,
+                        command: 'codex',
+                        cwd: '/repo-mapped',
+                        tty: 'ttys001',
+                        startTime: new Date('2026-06-26T09:56:12.000Z'),
+                    },
+                ];
+                mockedListAgentProcesses.mockReturnValue(processes);
+                mockedEnrichProcesses.mockReturnValue(processes);
+
+                const agents = await mappedAdapter.detectAgents();
+
+                expect(agents).toHaveLength(1);
+                expect(agents[0]).toMatchObject({
+                    type: 'codex',
+                    pid: 5151,
+                    sessionId: 'sess-mapped',
+                    projectPath: '/repo-mapped',
+                    summary: 'mapped conversation',
+                    sessionFilePath: sessionFile,
+                });
+                expect(mockedBatchGetSessionFileBirthtimes).not.toHaveBeenCalled();
+                expect(mockedMatchProcessesToSessions).not.toHaveBeenCalled();
+            } finally {
+                process.env.HOME = originalHome;
+                fs.rmSync(tmpHome, { recursive: true, force: true });
+            }
+        });
+
+        it('should fall back to legacy matching when mapped session file cannot be parsed', async () => {
+            const originalHome = process.env.HOME;
+            const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'codex-mapping-fallback-'));
+            process.env.HOME = tmpHome;
+
+            try {
+                const mappedAdapter = new CodexAdapter(new AgentRegistry(path.join(tmpHome, 'agents.json')));
+                const sessionsDir = path.join(tmpHome, '.codex', 'sessions');
+                const dateDir = path.join(sessionsDir, '2026', '06', '26');
+                const mappingPath = path.join(tmpHome, '.codex', 'ai-devkit', 'sessions.json');
+                const badSessionFile = path.join(dateDir, 'bad.jsonl');
+                const fallbackSessionFile = path.join(dateDir, 'fallback.jsonl');
+                const recentTs = new Date().toISOString();
+
+                fs.mkdirSync(dateDir, { recursive: true });
+                fs.mkdirSync(path.dirname(mappingPath), { recursive: true });
+                fs.writeFileSync(badSessionFile, '{not-json');
+                fs.writeFileSync(fallbackSessionFile, [
+                    JSON.stringify({ type: 'session_meta', payload: { id: 'sess-fallback', timestamp: recentTs, cwd: '/repo-fallback' } }),
+                    JSON.stringify({ type: 'event', timestamp: recentTs, payload: { type: 'token_count', message: 'fallback conversation' } }),
+                ].join('\n'));
+                fs.writeFileSync(mappingPath, JSON.stringify({ 6161: badSessionFile }));
+
+                const processes: ProcessInfo[] = [
+                    {
+                        pid: 6161,
+                        command: 'codex',
+                        cwd: '/repo-fallback',
+                        tty: 'ttys001',
+                        startTime: new Date('2026-06-26T09:56:12.000Z'),
+                    },
+                ];
+                const fallbackSession: SessionFile = {
+                    sessionId: 'sess-fallback',
+                    filePath: fallbackSessionFile,
+                    projectDir: dateDir,
+                    birthtimeMs: new Date('2026-06-26T09:56:15.000Z').getTime(),
+                    resolvedCwd: '',
+                };
+                mockedListAgentProcesses.mockReturnValue(processes);
+                mockedEnrichProcesses.mockReturnValue(processes);
+                mockedBatchGetSessionFileBirthtimes.mockReturnValue([fallbackSession]);
+                mockedMatchProcessesToSessions.mockReturnValue([
+                    {
+                        process: processes[0],
+                        session: { ...fallbackSession, resolvedCwd: '/repo-fallback' },
+                        deltaMs: 3000,
+                    },
+                ]);
+
+                const agents = await mappedAdapter.detectAgents();
+
+                expect(agents).toHaveLength(1);
+                expect(agents[0]).toMatchObject({
+                    pid: 6161,
+                    sessionId: 'sess-fallback',
+                    summary: 'fallback conversation',
+                    sessionFilePath: fallbackSessionFile,
+                });
+                expect(mockedMatchProcessesToSessions).toHaveBeenCalledWith(
+                    [processes[0]],
+                    expect.arrayContaining([expect.objectContaining({ filePath: fallbackSessionFile })]),
+                );
+            } finally {
+                process.env.HOME = originalHome;
+                fs.rmSync(tmpHome, { recursive: true, force: true });
+            }
+        });
     });
 
     describe('detectAgents — registry cache short-circuit', () => {
@@ -602,6 +885,133 @@ describe('CodexAdapter', () => {
             const { sessions } = discoverSessions(processes);
             expect(sessions[0].resolvedCwd).toBe('');
         });
+
+        it('should use session_meta timestamp as the matching birthtime when valid', () => {
+            const sessionsDir = path.join(tmpDir, 'sessions');
+            (adapter as any).codexSessionsDir = sessionsDir;
+            const discoverSessions = (adapter as any).discoverSessions.bind(adapter);
+
+            const dateDir = path.join(sessionsDir, '2026', '03', '18');
+            fs.mkdirSync(dateDir, { recursive: true });
+
+            const sessionFile = path.join(dateDir, 'sess-meta-time.jsonl');
+            const metaTimestamp = '2026-03-18T15:00:05.000Z';
+            fs.writeFileSync(sessionFile,
+                JSON.stringify({ type: 'session_meta', payload: { id: 'sess-meta-time', timestamp: metaTimestamp, cwd: '/repo-a' } }),
+            );
+
+            mockedBatchGetSessionFileBirthtimes.mockReturnValue([
+                {
+                    sessionId: 'sess-meta-time',
+                    filePath: sessionFile,
+                    projectDir: dateDir,
+                    birthtimeMs: new Date('2026-03-18T15:05:30.000Z').getTime(),
+                    resolvedCwd: '',
+                },
+            ]);
+
+            const { sessions } = discoverSessions([
+                { pid: 1, command: 'codex', cwd: '/repo-a', tty: '', startTime: new Date('2026-03-18T15:00:00Z') },
+            ]);
+
+            expect(sessions[0].resolvedCwd).toBe('/repo-a');
+            expect(sessions[0].birthtimeMs).toBe(new Date(metaTimestamp).getTime());
+        });
+
+        it('should tolerate malformed session_meta and unreadable files', () => {
+            const sessionsDir = path.join(tmpDir, 'sessions');
+            (adapter as any).codexSessionsDir = sessionsDir;
+            const discoverSessions = (adapter as any).discoverSessions.bind(adapter);
+
+            const dateDir = path.join(sessionsDir, '2026', '03', '18');
+            fs.mkdirSync(dateDir, { recursive: true });
+
+            const malformedFile = path.join(dateDir, 'malformed.jsonl');
+            const missingFile = path.join(dateDir, 'missing.jsonl');
+            fs.writeFileSync(malformedFile, '{not valid json');
+
+            mockedBatchGetSessionFileBirthtimes.mockReturnValue([
+                {
+                    sessionId: 'malformed',
+                    filePath: malformedFile,
+                    projectDir: dateDir,
+                    birthtimeMs: 1710800324000,
+                    resolvedCwd: '',
+                },
+                {
+                    sessionId: 'missing',
+                    filePath: missingFile,
+                    projectDir: dateDir,
+                    birthtimeMs: 1710800325000,
+                    resolvedCwd: '',
+                },
+            ]);
+
+            const result = discoverSessions([
+                { pid: 1, command: 'codex', cwd: '/repo', tty: '', startTime: new Date('2026-03-18T15:00:00Z') },
+            ]);
+
+            expect(result.sessions).toHaveLength(2);
+            expect(result.sessions[0].resolvedCwd).toBe('');
+            expect(result.sessions[1].resolvedCwd).toBe('');
+            expect(result.contentCache.has(malformedFile)).toBe(true);
+            expect(result.contentCache.has(missingFile)).toBe(false);
+        });
+    });
+
+    describe('findSessionFileById', () => {
+        let tmpDir: string;
+        let sessionsDir: string;
+        const sessionId = 'aaaaaaaa-bbbb-4ccc-dddd-eeeeeeeeeeee';
+
+        beforeEach(() => {
+            tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codex-resume-find-'));
+            sessionsDir = path.join(tmpDir, 'sessions');
+            fs.mkdirSync(path.join(sessionsDir, '2026', '03', '18'), { recursive: true });
+            (adapter as any).codexSessionsDir = sessionsDir;
+        });
+
+        afterEach(() => {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        });
+
+        function writeResumeSession(timestamp?: string): string {
+            const filePath = path.join(sessionsDir, '2026', '03', '18', `${sessionId}.jsonl`);
+            const payload: { id: string; cwd: string; timestamp?: string } = { id: sessionId, cwd: '/repo-a' };
+            if (timestamp !== undefined) {
+                payload.timestamp = timestamp;
+            }
+            fs.writeFileSync(filePath, JSON.stringify({ type: 'session_meta', payload }));
+            return filePath;
+        }
+
+        it('should return session_meta timestamp as birthtimeMs when valid', () => {
+            const metaTimestamp = '2026-03-18T15:00:05.000Z';
+            writeResumeSession(metaTimestamp);
+            const findSessionFileById = (adapter as any).findSessionFileById.bind(adapter);
+
+            const session = findSessionFileById(sessionId);
+
+            expect(session).toMatchObject({
+                sessionId,
+                resolvedCwd: '/repo-a',
+                birthtimeMs: new Date(metaTimestamp).getTime(),
+            });
+        });
+
+        it.each<[string, string | undefined]>([
+            ['missing', undefined],
+            ['invalid', 'not-a-date'],
+        ])('should fall back to stat birthtimeMs when session_meta timestamp is %s', (_label, metaTimestamp) => {
+            const sessionFile = writeResumeSession(metaTimestamp);
+            const stat = fs.statSync(sessionFile);
+            const findSessionFileById = (adapter as any).findSessionFileById.bind(adapter);
+
+            const session = findSessionFileById(sessionId);
+
+            expect(session).not.toBeNull();
+            expect(session.birthtimeMs).toBe(stat.birthtimeMs);
+        });
     });
 
     describe('helper methods', () => {

package/src/adapters/CodexAdapter.ts

@@ -4,10 +4,11 @@
  * Detects running Codex agents by:
  * 1. Finding running codex processes via shared listAgentProcesses()
  * 2. Enriching with CWD and start times via shared enrichProcesses()
- * 3. Discovering session files from ~/.codex/sessions/YYYY/MM/DD/ via shared batchGetSessionFileBirthtimes()
- * 4. Setting resolvedCwd from session_meta first line
- * 5. Matching sessions to processes via shared matchProcessesToSessions()
- * 6. Extracting summary from last event entry in session JSONL
+ * 3. Matching exact PID-to-session metadata from ~/.codex/ai-devkit/sessions.json
+ * 4. Discovering session files from ~/.codex/sessions/YYYY/MM/DD/ via shared batchGetSessionFileBirthtimes()
+ * 5. Setting resolvedCwd from session_meta first line
+ * 6. Matching sessions to processes via shared matchProcessesToSessions()
+ * 7. Extracting summary from last event entry in session JSONL
  */
 
 import * as fs from 'fs';
@@ -58,6 +59,16 @@ interface DirectMatchResult {
     failedProcesses: ProcessInfo[];
 }
 
+interface MappingMatch {
+    process: ProcessInfo;
+    filePath: string;
+}
+
+interface MappingMatchResult {
+    agents: AgentInfo[];
+    fallback: ProcessInfo[];
+}
+
 export class CodexAdapter implements AgentAdapter {
     readonly type = 'codex' as const;
 
@@ -66,11 +77,13 @@ export class CodexAdapter implements AgentAdapter {
     private static readonly PROCESS_START_DAY_WINDOW_DAYS = 1;
 
     private codexSessionsDir: string;
+    private sessionMappingPath: string;
     private registry: AgentRegistry;
 
     constructor(registry: AgentRegistry = AgentRegistry.default()) {
         const homeDir = process.env.HOME || process.env.USERPROFILE || '';
         this.codexSessionsDir = path.join(homeDir, '.codex', 'sessions');
+        this.sessionMappingPath = path.join(homeDir, '.codex', 'ai-devkit', 'sessions.json');
         this.registry = registry;
     }
 
@@ -88,12 +101,14 @@ export class CodexAdapter implements AgentAdapter {
         const { cachedAgents, remaining } = this.tryRegistryCache(processes);
         if (remaining.length === 0) return cachedAgents;
 
-        const { direct, fallback } = this.tryResumeMatching(remaining);
+        const mappingResult = this.mapSessionMappingMatches(remaining);
+        const { direct, fallback } = this.tryResumeMatching(mappingResult.fallback);
         const directResult = this.mapDirectMatches(direct);
         const { sessions, contentCache } = this.discoverSessions(fallback);
         if (sessions.length === 0) {
             return [
                 ...cachedAgents,
+                ...mappingResult.agents,
                 ...directResult.agents,
                 ...directResult.failedProcesses.map((p) => this.mapProcessOnlyAgent(p)),
                 ...fallback.map((p) => this.mapProcessOnlyAgent(p)),
@@ -127,7 +142,84 @@ export class CodexAdapter implements AgentAdapter {
             agents.push(this.mapProcessOnlyAgent(proc));
         }
 
-        return [...cachedAgents, ...agents];
+        return [...cachedAgents, ...mappingResult.agents, ...agents];
+    }
+
+    private mapSessionMappingMatches(processes: ProcessInfo[]): MappingMatchResult {
+        const { matches, fallback } = this.matchFromSessionMapping(processes);
+        const agents: AgentInfo[] = [];
+
+        for (const match of matches) {
+            const sessionData = this.parseSession(undefined, match.filePath);
+            if (sessionData) {
+                agents.push(this.mapSessionToAgent(sessionData, match.process, match.filePath));
+            } else {
+                fallback.push(match.process);
+            }
+        }
+
+        return { agents, fallback };
+    }
+
+    private matchFromSessionMapping(processes: ProcessInfo[]): {
+        matches: MappingMatch[];
+        fallback: ProcessInfo[];
+    } {
+        const mapping = this.readSessionMapping();
+        if (mapping.size === 0) return { matches: [], fallback: processes };
+
+        const matches: MappingMatch[] = [];
+        const fallback: ProcessInfo[] = [];
+
+        for (const proc of processes) {
+            const filePath = mapping.get(proc.pid);
+            if (!filePath || !this.isTrustedSessionPath(filePath) || !fs.existsSync(filePath)) {
+                fallback.push(proc);
+                continue;
+            }
+
+            matches.push({ process: proc, filePath });
+        }
+
+        return { matches, fallback };
+    }
+
+    private readSessionMapping(): Map<number, string> {
+        const content = safeReadFile(this.sessionMappingPath);
+        if (content === undefined) return new Map();
+
+        let parsed: unknown;
+        try {
+            parsed = JSON.parse(content);
+        } catch {
+            return new Map();
+        }
+
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return new Map();
+
+        const map = new Map<number, string>();
+        for (const [key, value] of Object.entries(parsed)) {
+            const pid = this.toPid(key);
+            if (pid !== null && typeof value === 'string' && value) {
+                map.set(pid, value);
+            }
+        }
+
+        return map;
+    }
+
+    private toPid(value: unknown): number | null {
+        if (typeof value === 'number' && Number.isInteger(value) && value > 0) return value;
+        if (typeof value !== 'string' || !/^\d+$/.test(value)) return null;
+
+        const parsed = Number(value);
+        return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : null;
+    }
+
+    private isTrustedSessionPath(filePath: string): boolean {
+        const resolvedRoot = path.resolve(this.codexSessionsDir);
+        const resolvedPath = path.resolve(filePath);
+        return resolvedPath === resolvedRoot || resolvedPath.startsWith(`${resolvedRoot}${path.sep}`);
     }
 
     private tryRegistryCache(processes: ProcessInfo[]): {
@@ -215,13 +307,14 @@ export class CodexAdapter implements AgentAdapter {
 
                 const stat = safeStat(filePath);
                 if (!stat) continue;
+                const metaTimestampMs = this.parseMetaTimestampMs(parsed.payload?.timestamp);
 
                 return {
                     sessionId,
                     filePath,
                     projectDir: path.dirname(filePath),
-                    birthtimeMs: stat.birthtimeMs,
-                    resolvedCwd: parsed.payload.cwd || '',
+                    birthtimeMs: metaTimestampMs ?? stat.birthtimeMs,
+                    resolvedCwd: parsed.payload?.cwd || '',
                 };
             } catch {
                 continue;
@@ -290,6 +383,10 @@ export class CodexAdapter implements AgentAdapter {
                     const parsed = JSON.parse(firstLine);
                     if (parsed.type === 'session_meta') {
                         file.resolvedCwd = parsed.payload?.cwd || '';
+                        const metaTimestampMs = this.parseMetaTimestampMs(parsed.payload?.timestamp);
+                        if (metaTimestampMs !== null) {
+                            file.birthtimeMs = metaTimestampMs;
+                        }
                     }
                 }
             } catch {
@@ -468,6 +565,16 @@ export class CodexAdapter implements AgentAdapter {
         return Number.isNaN(timestamp.getTime()) ? null : timestamp;
     }
 
+    private parseMetaTimestampMs(value?: string): number | null {
+        if (typeof value !== 'string') return null;
+
+        const timestamp = this.parseTimestamp(value);
+        if (!timestamp) return null;
+
+        const timestampMs = timestamp.getTime();
+        return Number.isFinite(timestampMs) ? timestampMs : null;
+    }
+
     private determineStatus(session: CodexSession): AgentStatus {
         const diffMs = Date.now() - session.lastActive.getTime();
         const diffMinutes = diffMs / 60000;