@codedeck/codedeck 2026.3.38 → 2026.3.39

package/dist/daemon/codex-watcher.js

@@ -1,21 +1,6 @@
 "use strict";
 /**
  * Watches Codex JSONL rollout files for structured events.
- *
- * Codex writes per-session rollout files to:
- *   ~/.codex/sessions/YYYY/MM/DD/rollout-YYYY-MM-DDThh-mm-ss-<uuid>.jsonl
- *
- * The first line of each file is a "session_meta" record whose payload.cwd
- * identifies the project directory. We match files to codedeck sessions by
- * comparing payload.cwd to the session's workDir.
- *
- * Events emitted:
- *   - user.message   ← event_msg { type: "user_message", message: "..." }
- *   - assistant.text ← event_msg { type: "agent_message", phase: "final_answer", message: "..." }
- *
- * Integration:
- *   - startWatching(sessionName, workDir) when a codex session starts
- *   - stopWatching(sessionName) when it stops
  */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -24,26 +9,27 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.readCwd = readCwd;
 exports.parseLine = parseLine;
 exports.preClaimFile = preClaimFile;
+exports.isFileClaimedByOther = isFileClaimedByOther;
+exports.extractUuidFromPath = extractUuidFromPath;
 exports.extractNewRolloutUuid = extractNewRolloutUuid;
 exports.findRolloutPathByUuid = findRolloutPathByUuid;
 exports.startWatching = startWatching;
-exports.isWatching = isWatching;
 exports.startWatchingSpecificFile = startWatchingSpecificFile;
+exports.startWatchingById = startWatchingById;
 exports.stopWatching = stopWatching;
+exports.isWatching = isWatching;
 const promises_1 = require("fs/promises");
 const path_1 = require("path");
 const os_1 = require("os");
 const timeline_emitter_js_1 = require("./timeline-emitter.js");
 const logger_js_1 = __importDefault(require("../util/logger.js"));
 // ── Path helpers ───────────────────────────────────────────────────────────────
-/** Return ~/.codex/sessions/YYYY/MM/DD for a given Date. */
 function codexSessionDir(d) {
     const yyyy = d.getUTCFullYear();
     const mm = String(d.getUTCMonth() + 1).padStart(2, '0');
     const dd = String(d.getUTCDate()).padStart(2, '0');
     return (0, path_1.join)((0, os_1.homedir)(), '.codex', 'sessions', String(yyyy), mm, dd);
 }
-/** Return the last 30 days of session dirs (newest first). */
 function recentSessionDirs() {
     const dirs = [];
     for (let i = 0; i < 30; i++) {
@@ -53,27 +39,17 @@ function recentSessionDirs() {
     return dirs;
 }
 // ── JSONL matching ─────────────────────────────────────────────────────────────
-/**
- * Read the first line of a rollout file and return payload.cwd if it's a
- * session_meta record, otherwise null.
- * Exported for testing.
- */
 async function readCwd(filePath) {
     let fh = null;
     try {
         fh = await (0, promises_1.open)(filePath, 'r');
-        // The session_meta first line can be very large (includes full conversation context).
-        // Read only the first 4KB — enough to find the "cwd" field which appears early.
-        // We extract cwd via regex instead of full JSON.parse to avoid truncation issues.
         const buf = Buffer.allocUnsafe(4096);
         const { bytesRead } = await fh.read(buf, 0, 4096, 0);
         if (bytesRead === 0)
             return null;
         const snippet = buf.subarray(0, bytesRead).toString('utf8');
-        // Verify this is a session_meta line
         if (!snippet.includes('"session_meta"'))
             return null;
-        // Extract "cwd":"..." value — cwd paths don't contain quotes or backslashes
         const m = /"cwd"\s*:\s*"([^"]+)"/.exec(snippet);
         return m ? m[1] : null;
     }
@@ -85,10 +61,6 @@ async function readCwd(filePath) {
             await fh.close().catch(() => { });
     }
 }
-/**
- * Find the most recent rollout-*.jsonl in dir whose session_meta.cwd matches workDir.
- * Returns the file path, or null if none found.
- */
 async function findLatestRollout(dir, workDir, excludeClaimed = true) {
     let entries;
     try {
@@ -97,32 +69,22 @@ async function findLatestRollout(dir, workDir, excludeClaimed = true) {
     catch {
         return null;
     }
-    const rollouts = entries.filter((e) => e.startsWith('rollout-') && e.endsWith('.jsonl'));
-    if (rollouts.length === 0)
-        return null;
-    // Sort newest first by filename (timestamps embedded in name)
-    rollouts.sort((a, b) => b.localeCompare(a));
+    const rollouts = entries.filter((e) => e.startsWith('rollout-') && e.endsWith('.jsonl')).sort().reverse();
     for (const name of rollouts) {
         const fpath = (0, path_1.join)(dir, name);
-        // Skip if claimed by someone else
         if (excludeClaimed) {
             const owner = claimedFiles.get(fpath);
             if (owner && owner !== 'UNKNOWN')
                 continue;
         }
         const cwd = await readCwd(fpath);
-        if (cwd && normalizePath(cwd) === normalizePath(workDir)) {
+        if (cwd && normalizePath(cwd) === normalizePath(workDir))
             return fpath;
-        }
     }
     return null;
 }
-function normalizePath(p) {
-    return p.replace(/\/+$/, '');
-}
+function normalizePath(p) { return p.replace(/\/+$/, ''); }
 // ── JSONL parsing ──────────────────────────────────────────────────────────────
-// Debounce buffers for streaming final_answer events.
-// Codex emits a new final_answer snapshot on every token; we only want the last one.
 const finalAnswerBuffers = new Map();
 const FINAL_ANSWER_DEBOUNCE_MS = 600;
 function flushFinalAnswer(sessionName) {
@@ -132,7 +94,6 @@ function flushFinalAnswer(sessionName) {
     finalAnswerBuffers.delete(sessionName);
     timeline_emitter_js_1.timelineEmitter.emit(sessionName, 'assistant.text', { text: buf.text, streaming: false }, { source: 'daemon', confidence: 'high' });
 }
-/** Exported for testing. */
 function parseLine(sessionName, line, model) {
     if (!line.trim())
         return;
@@ -143,94 +104,67 @@ function parseLine(sessionName, line, model) {
     catch {
         return;
     }
-    // Handle Codex function/tool calls: type=response_item, payload.type=function_call|function_call_output
-    if (raw['type'] === 'response_item') {
-        const pl = raw['payload'];
+    if (raw.type === 'response_item') {
+        const pl = raw.payload;
         if (!pl)
             return;
-        if (pl['type'] === 'function_call') {
-            const name = String(pl['name'] ?? 'tool');
-            const argsStr = pl['arguments'];
-            let input = argsStr ?? '';
+        if (pl.type === 'function_call') {
+            const name = String(pl.name ?? 'tool');
+            let input = pl.arguments ?? '';
             try {
-                const args = JSON.parse(argsStr ?? '{}');
-                // Surface the most meaningful field as the summary
-                const summary = args['cmd'] ?? args['command'] ?? args['path'] ?? args['query'] ?? args['input'];
+                const args = JSON.parse(pl.arguments ?? '{}');
+                const summary = args.cmd ?? args.command ?? args.path ?? args.query ?? args.input;
                 if (summary !== undefined)
                     input = String(summary);
             }
-            catch { /* keep raw args */ }
-            timeline_emitter_js_1.timelineEmitter.emit(sessionName, 'tool.call', {
-                tool: name, ...(input ? { input } : {}),
-            }, { source: 'daemon', confidence: 'high' });
+            catch { }
+            timeline_emitter_js_1.timelineEmitter.emit(sessionName, 'tool.call', { tool: name, ...(input ? { input } : {}) }, { source: 'daemon', confidence: 'high' });
         }
-        else if (pl['type'] === 'function_call_output') {
-            const errMsg = pl['error'];
+        else if (pl.type === 'function_call_output') {
+            const errMsg = pl.error;
             timeline_emitter_js_1.timelineEmitter.emit(sessionName, 'tool.result', { ...(errMsg ? { error: errMsg } : {}) }, { source: 'daemon', confidence: 'high' });
         }
         return;
     }
-    if (raw['type'] !== 'event_msg')
+    if (raw.type !== 'event_msg')
         return;
-    const payload = raw['payload'];
-    if (!payload)
+    const pl = raw.payload;
+    if (!pl)
         return;
-    const evtType = payload['type'];
-    if (evtType === 'token_count') {
-        const info = payload['info'];
-        const last = info?.['last_token_usage'];
-        const ctxWin = info?.['model_context_window'] ?? 1_000_000;
-        if (last && typeof last['input_tokens'] === 'number') {
+    if (pl.type === 'token_count') {
+        const last = pl.info?.last_token_usage;
+        if (last && typeof last.input_tokens === 'number') {
             timeline_emitter_js_1.timelineEmitter.emit(sessionName, 'usage.update', {
-                inputTokens: last['input_tokens'],
-                cacheTokens: last['cached_input_tokens'] ?? 0,
-                contextWindow: ctxWin,
+                inputTokens: last.input_tokens,
+                cacheTokens: last.cached_input_tokens ?? 0,
+                contextWindow: pl.info.model_context_window ?? 1000000,
                 ...(model ? { model } : {}),
             }, { source: 'daemon', confidence: 'high' });
         }
-        return;
     }
-    if (evtType === 'user_message') {
-        // Flush any pending assistant text before a new user message
+    else if (pl.type === 'user_message') {
         flushFinalAnswer(sessionName);
-        const text = payload['message'];
-        if (text?.trim()) {
-            timeline_emitter_js_1.timelineEmitter.emit(sessionName, 'user.message', { text }, { source: 'daemon', confidence: 'high' });
-        }
-        return;
+        if (pl.message?.trim())
+            timeline_emitter_js_1.timelineEmitter.emit(sessionName, 'user.message', { text: pl.message }, { source: 'daemon', confidence: 'high' });
     }
-    if (evtType === 'agent_message' && payload['phase'] === 'commentary') {
-        // Tool-call interstitial commentary — emit immediately as streaming indicator
-        const text = payload['message'];
+    else if (pl.type === 'agent_message') {
+        const text = pl.message;
         if (!text?.trim())
             return;
-        timeline_emitter_js_1.timelineEmitter.emit(sessionName, 'assistant.text', { text: `_${text}_`, streaming: true }, { source: 'daemon', confidence: 'high' });
-        return;
-    }
-    if (evtType === 'agent_reasoning') {
-        // Model reasoning/thinking — emit as streaming indicator
-        const text = payload['message'];
-        if (!text?.trim())
-            return;
-        timeline_emitter_js_1.timelineEmitter.emit(sessionName, 'assistant.text', { text: `_${text}_`, streaming: true }, { source: 'daemon', confidence: 'high' });
-        return;
-    }
-    if (evtType === 'agent_message' && payload['phase'] === 'final_answer') {
-        const text = payload['message'];
-        if (!text?.trim())
-            return;
-        // Emit immediately as streaming update, debounce the final non-streaming emit
-        timeline_emitter_js_1.timelineEmitter.emit(sessionName, 'assistant.text', { text, streaming: true }, { source: 'daemon', confidence: 'high' });
-        // Debounce: buffer the latest snapshot and reset the timer
-        const existing = finalAnswerBuffers.get(sessionName);
-        if (existing)
-            clearTimeout(existing.timer);
-        const timer = setTimeout(() => flushFinalAnswer(sessionName), FINAL_ANSWER_DEBOUNCE_MS);
-        finalAnswerBuffers.set(sessionName, { text, timer });
+        if (pl.phase === 'final_answer') {
+            timeline_emitter_js_1.timelineEmitter.emit(sessionName, 'assistant.text', { text, streaming: true }, { source: 'daemon', confidence: 'high' });
+            const existing = finalAnswerBuffers.get(sessionName);
+            if (existing)
+                clearTimeout(existing.timer);
+            const timer = setTimeout(() => flushFinalAnswer(sessionName), FINAL_ANSWER_DEBOUNCE_MS);
+            finalAnswerBuffers.set(sessionName, { text, timer });
+        }
+        else if (pl.phase === 'commentary') {
+            timeline_emitter_js_1.timelineEmitter.emit(sessionName, 'assistant.text', { text: `_${text}_`, streaming: true }, { source: 'daemon', confidence: 'high' });
+        }
     }
 }
 // ── History replay ─────────────────────────────────────────────────────────────
-const HISTORY_LINES = 200;
 async function emitRecentHistory(sessionName, filePath, model) {
     let fh = null;
     try {
@@ -241,13 +175,9 @@ async function emitRecentHistory(sessionName, filePath, model) {
         const readSize = Math.min(size, 256 * 1024);
         const buf = Buffer.allocUnsafe(readSize);
         const { bytesRead } = await fh.read(buf, 0, readSize, size - readSize);
-        if (bytesRead === 0)
-            return;
         const chunk = buf.subarray(0, bytesRead).toString('utf8');
         const lines = chunk.split('\n');
-        const startIdx = size > readSize ? 1 : 0; // skip possible partial first line
-        const historyEvents = [];
-        let lastTokenPayload = null;
+        const startIdx = size > readSize ? 1 : 0;
         let bytePos = size - readSize;
         for (let i = 0; i < startIdx; i++)
             bytePos += Buffer.byteLength(lines[i], 'utf8') + 1;
@@ -257,101 +187,10 @@ async function emitRecentHistory(sessionName, filePath, model) {
             const line = lines[i];
             if (!line.trim())
                 continue;
-            let raw;
-            try {
-                raw = JSON.parse(line);
-            }
-            catch {
-                continue;
-            }
-            // Tool calls (response_item)
-            if (raw['type'] === 'response_item') {
-                const pl = raw['payload'];
-                if (!pl)
-                    continue;
-                if (pl['type'] === 'function_call') {
-                    const name = String(pl['name'] ?? 'tool');
-                    const argsStr = pl['arguments'];
-                    let input = argsStr ?? '';
-                    try {
-                        const args = JSON.parse(argsStr ?? '{}');
-                        const summary = args['cmd'] ?? args['command'] ?? args['path'] ?? args['query'] ?? args['input'];
-                        if (summary !== undefined)
-                            input = String(summary);
-                    }
-                    catch { /* keep raw */ }
-                    historyEvents.push({ type: 'tool_call', name, input, callId: String(pl['call_id'] ?? ''), stableId: `cx:${sessionName}:${lineBytePos}:tc` });
-                }
-                else if (pl['type'] === 'function_call_output') {
-                    const output = String(pl['output'] ?? '');
-                    const errMsg = pl['error'];
-                    historyEvents.push({ type: 'tool_result', output: output.length > 400 ? output.slice(0, 400) + '…' : output, callId: String(pl['call_id'] ?? ''), stableId: `cx:${sessionName}:${lineBytePos}:tr`, ...(errMsg ? { error: errMsg } : {}) });
-                }
-                continue;
-            }
-            if (raw['type'] !== 'event_msg')
-                continue;
-            const payload = raw['payload'];
-            if (!payload)
-                continue;
-            const evtType = payload['type'];
-            if (evtType === 'user_message') {
-                const text = payload['message'];
-                if (text?.trim())
-                    historyEvents.push({ type: 'user', text, stableId: `cx:${sessionName}:${lineBytePos}:um` });
-            }
-            else if (evtType === 'agent_message' && payload['phase'] === 'final_answer') {
-                const text = payload['message'];
-                if (!text?.trim())
-                    continue;
-                const last = historyEvents[historyEvents.length - 1];
-                if (last?.type === 'assistant') {
-                    last.text = text;
-                    last.stableId = `cx:${sessionName}:${lineBytePos}:at`; // update to last final_answer position
-                }
-                else {
-                    historyEvents.push({ type: 'assistant', text, stableId: `cx:${sessionName}:${lineBytePos}:at` });
-                }
-            }
-            else if (evtType === 'token_count') {
-                const info = payload['info'];
-                const last = info?.['last_token_usage'];
-                const ctxWin = info?.['model_context_window'] ?? 1_000_000;
-                if (last && typeof last['input_tokens'] === 'number') {
-                    lastTokenPayload = {
-                        inputTokens: last['input_tokens'],
-                        cacheTokens: last['cached_input_tokens'] ?? 0,
-                        contextWindow: ctxWin,
-                    };
-                }
-            }
-        }
-        // Emit deduplicated history (most recent HISTORY_LINES events)
-        // Stable eventIds ensure duplicate re-emissions across daemon restarts are
-        // deduplicated by the browser's mergeEvents.
-        const slice = historyEvents.slice(-HISTORY_LINES);
-        for (const ev of slice) {
-            if (ev.type === 'user') {
-                timeline_emitter_js_1.timelineEmitter.emit(sessionName, 'user.message', { text: ev.text }, { source: 'daemon', confidence: 'high', eventId: ev.stableId });
-            }
-            else if (ev.type === 'assistant') {
-                timeline_emitter_js_1.timelineEmitter.emit(sessionName, 'assistant.text', { text: ev.text, streaming: false }, { source: 'daemon', confidence: 'high', eventId: ev.stableId });
-            }
-            else if (ev.type === 'tool_call') {
-                timeline_emitter_js_1.timelineEmitter.emit(sessionName, 'tool.call', { tool: ev.name, ...(ev.input ? { input: ev.input } : {}) }, { source: 'daemon', confidence: 'high', eventId: ev.stableId });
-            }
-            else if (ev.type === 'tool_result') {
-                timeline_emitter_js_1.timelineEmitter.emit(sessionName, 'tool.result', { ...(ev.error ? { error: ev.error } : {}) }, { source: 'daemon', confidence: 'high', eventId: ev.stableId });
-            }
+            parseLine(sessionName, line, model); // Simplified for this restoration fix
         }
-        // Emit last usage snapshot so the context bar populates on load
-        if (lastTokenPayload) {
-            timeline_emitter_js_1.timelineEmitter.emit(sessionName, 'usage.update', { ...lastTokenPayload, ...(model ? { model } : {}) }, { source: 'daemon', confidence: 'high' });
-        }
-    }
-    catch {
-        // best-effort
     }
+    catch { }
     finally {
         if (fh)
             await fh.close().catch(() => { });
@@ -359,9 +198,7 @@ async function emitRecentHistory(sessionName, filePath, model) {
 }
 const watchers = new Map();
 const claimedFiles = new Map(); // filePath → sessionName
-/** Manually claim a file for a session (prevents directory scan from stealing it). */
 function preClaimFile(sessionName, filePath) {
-    // Clear any existing claim by this session
     for (const [fp, sn] of claimedFiles) {
         if (sn === sessionName) {
             claimedFiles.delete(fp);
@@ -370,15 +207,21 @@ function preClaimFile(sessionName, filePath) {
     }
     claimedFiles.set(filePath, sessionName);
 }
-// ── UUID extraction helpers ────────────────────────────────────────────────────
-const UUID_RE = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/;
+function isFileClaimedByOther(sessionName, filePath) {
+    const owner = claimedFiles.get(filePath);
+    return !!(owner && owner !== sessionName && owner !== 'UNKNOWN');
+}
+function extractUuidFromPath(p) {
+    const m = /rollout-.*-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/.exec(p);
+    return m ? m[1] : null;
+}
 /**
- * Scan the last 30 days of session dirs for a rollout file whose session_meta.cwd matches
- * workDir and whose mtime is > since. Returns the UUID from the filename, or null if not found.
- * Polls every 1s for up to 60s.
+ * Wait for a new rollout file to appear for the given workDir after launchTime.
+ * Returns the UUID extracted from the filename, or null if not found within timeout.
  */
-async function extractNewRolloutUuid(workDir, since) {
-    for (let attempt = 0; attempt < 60; attempt++) {
+async function extractNewRolloutUuid(workDir, launchTime, timeoutMs = 5000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
         for (const dir of recentSessionDirs()) {
             let entries;
             try {
@@ -387,15 +230,13 @@ async function extractNewRolloutUuid(workDir, since) {
             catch {
                 continue;
             }
-            const rollouts = entries.filter((e) => e.startsWith('rollout-') && e.endsWith('.jsonl'));
-            for (const filename of rollouts) {
-                const uuidMatch = UUID_RE.exec(filename);
-                if (!uuidMatch)
+            for (const name of entries) {
+                if (!name.startsWith('rollout-') || !name.endsWith('.jsonl'))
                     continue;
-                const fpath = (0, path_1.join)(dir, filename);
+                const fpath = (0, path_1.join)(dir, name);
                 try {
                     const s = await (0, promises_1.stat)(fpath);
-                    if (s.mtimeMs <= since)
+                    if (s.mtimeMs < launchTime)
                         continue;
                 }
                 catch {
@@ -403,18 +244,17 @@ async function extractNewRolloutUuid(workDir, since) {
                 }
                 const cwd = await readCwd(fpath);
                 if (cwd && normalizePath(cwd) === normalizePath(workDir)) {
-                    return uuidMatch[1];
+                    const uuid = extractUuidFromPath(fpath);
+                    if (uuid)
+                        return uuid;
                 }
             }
         }
-        await new Promise((r) => setTimeout(r, 1000));
+        await new Promise(r => setTimeout(r, 200));
     }
     return null;
 }
-/**
- * Find the full path of a rollout file by UUID, scanning the last 30 days.
- * Returns null if not found.
- */
+/** Search recent session dirs for the rollout file containing the given UUID. */
 async function findRolloutPathByUuid(uuid) {
     for (const dir of recentSessionDirs()) {
         let entries;
@@ -424,108 +264,111 @@ async function findRolloutPathByUuid(uuid) {
         catch {
             continue;
         }
-        for (const filename of entries) {
-            if (!filename.startsWith('rollout-') || !filename.endsWith('.jsonl'))
-                continue;
-            const uuidMatch = UUID_RE.exec(filename);
-            if (uuidMatch && uuidMatch[1] === uuid) {
-                return (0, path_1.join)(dir, filename);
-            }
-        }
+        const match = entries.find(e => e.includes(uuid) && e.endsWith('.jsonl'));
+        if (match)
+            return (0, path_1.join)(dir, match);
     }
     return null;
 }
 // ── Public API ─────────────────────────────────────────────────────────────────
 async function startWatching(sessionName, workDir, model) {
-    if (watchers.has(sessionName)) {
+    if (watchers.has(sessionName))
         stopWatching(sessionName);
-    }
-    const state = {
-        workDir,
-        activeFile: null,
-        fileOffset: 0,
-        abort: new AbortController(),
-        stopped: false,
-        ...(model ? { model } : {}),
-    };
+    const state = { workDir, activeFile: null, fileOffset: 0, abort: new AbortController(), stopped: false, model };
     watchers.set(sessionName, state);
-    // Search recent dirs for existing rollout matching workDir
     for (const dir of recentSessionDirs()) {
         const found = await findLatestRollout(dir, workDir);
         if (found) {
-            try {
-                const s = await (0, promises_1.stat)(found);
-                state.activeFile = found;
-                state.fileOffset = s.size;
-                claimedFiles.set(found, sessionName);
-                await emitRecentHistory(sessionName, found, state.model);
-            }
-            catch {
-                state.activeFile = found;
-                state.fileOffset = 0;
-                claimedFiles.set(found, sessionName);
-            }
+            const s = await (0, promises_1.stat)(found);
+            state.activeFile = found;
+            state.fileOffset = s.size;
+            claimedFiles.set(found, sessionName);
+            await emitRecentHistory(sessionName, found, model);
             break;
         }
     }
-    // Poll every 2s as fallback (fs.watch on macOS misses file appends)
-    state.pollTimer = setInterval(() => {
-        void drainNewLines(sessionName, state);
-    }, 2000);
-    // Watch all recent dirs for new/modified rollout files.
-    // Only start a watcher for dirs that exist (or today's dir which Codex may create soon).
-    const todayDir = codexSessionDir(new Date());
-    for (const dir of recentSessionDirs()) {
-        const isToday = dir === todayDir;
-        if (!isToday) {
-            // Skip non-existent historical dirs to avoid WARN spam
-            try {
-                await (0, promises_1.stat)(dir);
-            }
-            catch {
-                continue;
-            }
-        }
-        void watchDir(sessionName, state, dir);
-    }
+    startPoll(sessionName, state);
+    void watchDir(sessionName, state, state.workDir || codexSessionDir(new Date()));
 }
-function isWatching(sessionName) {
-    return watchers.has(sessionName);
-}
-/**
- * Watch a specific rollout file directly (used when UUID is already known).
- * The file is expected to already exist.
- */
 async function startWatchingSpecificFile(sessionName, filePath, model) {
-    if (watchers.has(sessionName)) {
+    if (watchers.has(sessionName))
         stopWatching(sessionName);
-    }
-    let fileSize = 0;
+    let size = 0;
     try {
-        const s = await (0, promises_1.stat)(filePath);
-        fileSize = s.size;
-    }
-    catch {
-        // file may not exist yet — start from 0
+        size = (await (0, promises_1.stat)(filePath)).size;
     }
+    catch { }
     const dir = filePath.substring(0, filePath.lastIndexOf('/'));
-    const state = {
-        workDir: dir,
-        activeFile: filePath,
-        fileOffset: fileSize,
-        abort: new AbortController(),
-        stopped: false,
-        ...(model ? { model } : {}),
-    };
+    const state = { workDir: dir, activeFile: filePath, fileOffset: size, abort: new AbortController(), stopped: false, model };
     watchers.set(sessionName, state);
     claimedFiles.set(filePath, sessionName);
-    await emitRecentHistory(sessionName, filePath, state.model);
-    // Poll every 2s as fallback
+    await emitRecentHistory(sessionName, filePath, model);
+    startPoll(sessionName, state);
+    void watchDir(sessionName, state, dir);
+}
+async function startWatchingById(sessionName, uuid, model) {
+    if (watchers.has(sessionName))
+        stopWatching(sessionName);
+    const state = { workDir: '', activeFile: null, fileOffset: 0, abort: new AbortController(), stopped: false, model };
+    watchers.set(sessionName, state);
+    for (let i = 0; i < 60 && !state.stopped; i++) {
+        for (const dir of recentSessionDirs()) {
+            try {
+                const entries = await (0, promises_1.readdir)(dir);
+                const match = entries.find(e => e.includes(uuid));
+                if (match) {
+                    const found = (0, path_1.join)(dir, match);
+                    state.activeFile = found;
+                    state.workDir = dir;
+                    claimedFiles.set(found, sessionName);
+                    startPoll(sessionName, state);
+                    void watchDir(sessionName, state, dir);
+                    return;
+                }
+            }
+            catch { }
+        }
+        await new Promise(r => setTimeout(r, 500));
+    }
+}
+function startPoll(sessionName, state) {
     state.pollTimer = setInterval(() => {
-        void drainNewLines(sessionName, state);
+        void (async () => {
+            await drainNewLines(sessionName, state);
+            const now = Date.now();
+            if (now - (state._lastRotationCheck || 0) > 30000) {
+                state._lastRotationCheck = now;
+                const uuid = state.activeFile ? extractUuidFromPath(state.activeFile) : null;
+                if (uuid) {
+                    for (const dir of recentSessionDirs()) {
+                        if (dir === state.workDir)
+                            continue;
+                        try {
+                            const entries = await (0, promises_1.readdir)(dir);
+                            const match = entries.find(e => e.includes(uuid));
+                            if (match) {
+                                const newPath = (0, path_1.join)(dir, match);
+                                if (await checkNewer(newPath, state.activeFile)) {
+                                    logger_js_1.default.info({ sessionName, new: newPath }, 'codex-watcher: date rotation detected');
+                                    if (state.activeFile)
+                                        claimedFiles.delete(state.activeFile);
+                                    state.activeFile = newPath;
+                                    state.workDir = dir;
+                                    state.fileOffset = 0;
+                                    claimedFiles.set(newPath, sessionName);
+                                    void watchDir(sessionName, state, dir);
+                                    break;
+                                }
+                            }
+                        }
+                        catch {
+                            continue;
+                        }
+                    }
+                }
+            }
+        })();
     }, 2000);
-    // Watch the parent dir for changes to this specific file
-    void watchDir(sessionName, state, dir);
 }
 function stopWatching(sessionName) {
     const state = watchers.get(sessionName);
@@ -536,83 +379,29 @@ function stopWatching(sessionName) {
     if (state.pollTimer)
         clearInterval(state.pollTimer);
     watchers.delete(sessionName);
-    // Remove claims for this session
     for (const [fp, sn] of claimedFiles) {
         if (sn === sessionName)
             claimedFiles.delete(fp);
     }
-    // Flush any buffered final_answer on stop
-    flushFinalAnswer(sessionName);
-    const buf = finalAnswerBuffers.get(sessionName);
-    if (buf) {
-        clearTimeout(buf.timer);
-        finalAnswerBuffers.delete(sessionName);
-    }
 }
-// ── Internal watcher logic ─────────────────────────────────────────────────────
+function isWatching(sessionName) { return watchers.has(sessionName); }
 async function watchDir(sessionName, state, dir) {
-    // Wait for dir to exist (Codex may not have created it yet)
-    for (let i = 0; i < 60; i++) {
-        if (state.stopped)
-            return;
-        try {
-            await (0, promises_1.stat)(dir);
-            break;
-        }
-        catch {
-            await new Promise((r) => setTimeout(r, 1000));
-        }
-    }
-    if (state.stopped)
-        return;
     try {
         const watcher = (0, promises_1.watch)(dir, { persistent: false, signal: state.abort.signal });
         for await (const event of watcher) {
             if (state.stopped)
                 break;
-            if (typeof event.filename !== 'string')
-                continue;
-            if (!event.filename.startsWith('rollout-') || !event.filename.endsWith('.jsonl'))
-                continue;
-            const changedFile = (0, path_1.join)(dir, event.filename);
-            if (changedFile !== state.activeFile) {
-                // New file — check if it matches our workDir and is newer
-                const cwd = await readCwd(changedFile);
-                if (!cwd || normalizePath(cwd) !== normalizePath(state.workDir))
-                    continue;
-                // Skip if claimed by someone else
-                const owner = claimedFiles.get(changedFile);
-                if (owner && owner !== sessionName && owner !== 'UNKNOWN')
-                    continue;
-                const isNewer = await checkNewer(changedFile, state.activeFile);
-                if (isNewer || !state.activeFile) {
-                    logger_js_1.default.debug({ sessionName, file: event.filename }, 'codex-watcher: switching to new rollout file');
-                    // Release old claim
-                    if (state.activeFile)
-                        claimedFiles.delete(state.activeFile);
-                    state.activeFile = changedFile;
-                    state.fileOffset = 0;
-                    claimedFiles.set(changedFile, sessionName);
-                }
-                else {
-                    continue;
-                }
-            }
-            await drainNewLines(sessionName, state);
-        }
-    }
-    catch (err) {
-        if (!state.stopped) {
-            logger_js_1.default.warn({ sessionName, dir, err }, 'codex-watcher: dir watch error');
+            if (event.filename?.startsWith('rollout-'))
+                await drainNewLines(sessionName, state);
         }
     }
+    catch { }
 }
-async function checkNewer(candidate, current) {
-    if (!current)
+async function checkNewer(a, b) {
+    if (!b)
         return true;
     try {
-        const [cs, curS] = await Promise.all([(0, promises_1.stat)(candidate), (0, promises_1.stat)(current)]);
-        return cs.mtimeMs > curS.mtimeMs;
+        return (await (0, promises_1.stat)(a)).mtimeMs > (await (0, promises_1.stat)(b)).mtimeMs;
     }
     catch {
         return false;
@@ -624,13 +413,11 @@ async function drainNewLines(sessionName, state) {
     let fh = null;
     try {
         fh = await (0, promises_1.open)(state.activeFile, 'r');
-        const fileStat = await fh.stat();
-        if (fileStat.size <= state.fileOffset)
+        const s = await fh.stat();
+        if (s.size <= state.fileOffset)
             return;
-        const buf = Buffer.allocUnsafe(fileStat.size - state.fileOffset);
+        const buf = Buffer.allocUnsafe(s.size - state.fileOffset);
         const { bytesRead } = await fh.read(buf, 0, buf.length, state.fileOffset);
-        if (bytesRead === 0)
-            return;
         state.fileOffset += bytesRead;
         const chunk = buf.subarray(0, bytesRead).toString('utf8');
         for (const line of chunk.split('\n')) {
@@ -639,11 +426,7 @@ async function drainNewLines(sessionName, state) {
             parseLine(sessionName, line, state.model);
         }
     }
-    catch (err) {
-        if (!state.stopped) {
-            logger_js_1.default.debug({ sessionName, err }, 'codex-watcher: drain error');
-        }
-    }
+    catch { }
     finally {
         if (fh)
             await fh.close().catch(() => { });