@phenx-inc/ctlsurf 0.7.0 → 0.9.0

package/out/renderer/assets/{tsMode-C7m6Kr5E.js → tsMode-8FLRnobw.js}

@@ -1,4 +1,4 @@
-import { c as createWebWorker, e as editor, U as Uri, a as MarkerTag, M as MarkerSeverity, l as languages, t as typescriptDefaults, R as Range } from "./index-dRvutfbl.js";
+import { c as createWebWorker, e as editor, U as Uri, a as MarkerTag, M as MarkerSeverity, l as languages, t as typescriptDefaults, R as Range } from "./index-Cj7K9-Ba.js";
 class WorkerManager {
   constructor(_modeId, _defaults) {
     this._modeId = _modeId;

package/out/renderer/assets/{typescript-DhPw4VVg.js → typescript-rdwAjCi4.js}

@@ -1,4 +1,4 @@
-import { l as languages } from "./index-dRvutfbl.js";
+import { l as languages } from "./index-Cj7K9-Ba.js";
 const conf = {
   wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
   comments: {

package/out/renderer/assets/{xml-B0WLFJ2U.js → xml-HOzT59Qg.js}

@@ -1,4 +1,4 @@
-import { l as languages } from "./index-dRvutfbl.js";
+import { l as languages } from "./index-Cj7K9-Ba.js";
 const conf = {
   comments: {
     blockComment: ["<!--", "-->"]

package/out/renderer/assets/{yaml-BWyn9Wd7.js → yaml-B81JfLsW.js}

@@ -1,4 +1,4 @@
-import { l as languages } from "./index-dRvutfbl.js";
+import { l as languages } from "./index-Cj7K9-Ba.js";
 const conf = {
   comments: {
     lineComment: "#"

package/out/renderer/index.html

@@ -4,10 +4,72 @@
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>ctlsurf-worker</title>
-  <script type="module" crossorigin src="./assets/index-dRvutfbl.js"></script>
-  <link rel="stylesheet" crossorigin href="./assets/index-Cf-RsxoC.css">
+  <!-- Boot splash styles are inlined here so they paint on the first frame,
+       before the JS bundle and styles.css have loaded. Without this the window
+       shows an empty dark pane while React mounts and the startup IPC runs. -->
+  <style>
+    #boot-splash {
+      position: fixed;
+      inset: 0;
+      z-index: 9999;
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      gap: 16px;
+      background: #1a1b26;
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      transition: opacity 0.3s ease;
+      -webkit-app-region: drag; /* keep the frameless window draggable during load */
+    }
+    #boot-splash.boot-splash-hidden {
+      opacity: 0;
+      pointer-events: none;
+    }
+    .boot-spinner {
+      width: 34px;
+      height: 34px;
+      border-radius: 50%;
+      border: 3px solid rgba(122, 162, 247, 0.22);
+      border-top-color: #7aa2f7;
+      animation: boot-spin 0.8s linear infinite;
+    }
+    @keyframes boot-spin {
+      to { transform: rotate(360deg); }
+    }
+    .boot-splash-title {
+      font-size: 15px;
+      font-weight: 600;
+      letter-spacing: 0.02em;
+      color: #c0caf5;
+    }
+    .boot-splash-label {
+      font-size: 12px;
+      letter-spacing: 0.04em;
+      color: #565f89;
+    }
+  </style>
+  <script type="module" crossorigin src="./assets/index-Cj7K9-Ba.js"></script>
+  <link rel="stylesheet" crossorigin href="./assets/index-nvsNYP5c.css">
 </head>
 <body>
+  <div id="boot-splash">
+    <div class="boot-spinner"></div>
+    <div class="boot-splash-title">ctlsurf</div>
+    <div class="boot-splash-label">Starting up…</div>
+  </div>
   <div id="root"></div>
+  <script>
+    // Fades out and removes the boot splash. Called by the React app once its
+    // startup IPC has settled (see App.tsx). The timeout is a safety net so a
+    // hung startup never leaves the user stuck behind the splash forever.
+    window.__dismissSplash = function () {
+      var el = document.getElementById('boot-splash')
+      if (!el) return
+      el.classList.add('boot-splash-hidden')
+      setTimeout(function () { el.remove() }, 350)
+    }
+    setTimeout(function () { window.__dismissSplash() }, 10000)
+  </script>
 </body>
 </html>

package/out/repro-toggle.mjs

@@ -0,0 +1,305 @@
+// repro-toggle.ts
+import fs2 from "fs";
+import os2 from "os";
+import path2 from "path";
+
+// src/main/transcripts.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+var POLL_INTERVAL_MS = 1e3;
+var DISCOVERY_SLACK_MS = 1e4;
+var READ_CHUNK_BYTES = 64 * 1024;
+var MAX_ENTRY_CHARS = 2e4;
+var TranscriptTailer = class {
+  agentId;
+  cwd;
+  sink;
+  claudeProjectsDir;
+  codexSessionsDir;
+  files = /* @__PURE__ */ new Map();
+  pollTimer = null;
+  sinceMs = 0;
+  constructor(options) {
+    this.agentId = options.agentId;
+    this.cwd = stripTrailingSep(options.cwd);
+    this.sink = options.sink;
+    this.claudeProjectsDir = options.claudeProjectsDir || path.join(os.homedir(), ".claude", "projects");
+    this.codexSessionsDir = options.codexSessionsDir || path.join(os.homedir(), ".codex", "sessions");
+  }
+  start() {
+    if (this.pollTimer) return;
+    this.sinceMs = Date.now();
+    this.files.clear();
+    this.pollTimer = setInterval(() => this.poll(), POLL_INTERVAL_MS);
+    console.log(`[transcripts] Tailing ${this.agentId} transcripts for ${this.cwd}`);
+  }
+  stop() {
+    if (!this.pollTimer) return;
+    clearInterval(this.pollTimer);
+    this.pollTimer = null;
+    this.poll();
+    this.files.clear();
+    console.log("[transcripts] Stopped");
+  }
+  poll() {
+    try {
+      this.discover();
+      for (const [filePath, tail] of this.files) {
+        if (!tail.excluded) this.drainFile(filePath, tail);
+      }
+    } catch (err) {
+      console.error("[transcripts] Poll error:", err);
+    }
+  }
+  // ─── Discovery ──────────────────────────────────
+  /**
+   * Track every transcript file with recent activity, not just the first
+   * match: /clear (Claude) or /new (Codex) starts a new session file in the
+   * middle of one PTY run, and tailing all active candidates handles the
+   * switch without special cases. Old idle files never match (stale mtime).
+   */
+  discover() {
+    const dirs = this.agentId === "claude" ? [this.claudeProjectsDirForCwd()] : this.codexDateDirs();
+    for (const dir of dirs) {
+      let names;
+      try {
+        names = fs.readdirSync(dir);
+      } catch {
+        continue;
+      }
+      for (const name of names) {
+        if (!name.endsWith(".jsonl")) continue;
+        if (this.agentId === "codex" && !name.startsWith("rollout-")) continue;
+        const filePath = path.join(dir, name);
+        if (this.files.has(filePath)) continue;
+        try {
+          const stat = fs.statSync(filePath);
+          if (stat.mtimeMs >= this.sinceMs - DISCOVERY_SLACK_MS) {
+            this.files.set(filePath, { offset: 0, remainder: "", excluded: false });
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  claudeProjectsDirForCwd() {
+    const slug = this.cwd.replace(/[^a-zA-Z0-9]/g, "-");
+    return path.join(this.claudeProjectsDir, slug);
+  }
+  codexDateDirs() {
+    const dirs = /* @__PURE__ */ new Set();
+    for (const ms of [this.sinceMs, Date.now()]) {
+      const d = new Date(ms);
+      const yyyy = String(d.getFullYear());
+      const mm = String(d.getMonth() + 1).padStart(2, "0");
+      const dd = String(d.getDate()).padStart(2, "0");
+      dirs.add(path.join(this.codexSessionsDir, yyyy, mm, dd));
+    }
+    return [...dirs];
+  }
+  // ─── Tailing ────────────────────────────────────
+  drainFile(filePath, tail) {
+    let size;
+    try {
+      size = fs.statSync(filePath).size;
+    } catch {
+      return;
+    }
+    if (size <= tail.offset) return;
+    let fd;
+    try {
+      fd = fs.openSync(filePath, "r");
+    } catch {
+      return;
+    }
+    try {
+      const buf = Buffer.alloc(READ_CHUNK_BYTES);
+      while (tail.offset < size && !tail.excluded) {
+        const bytesRead = fs.readSync(fd, buf, 0, READ_CHUNK_BYTES, tail.offset);
+        if (bytesRead <= 0) break;
+        tail.offset += bytesRead;
+        tail.remainder += buf.toString("utf-8", 0, bytesRead);
+        const lines = tail.remainder.split("\n");
+        tail.remainder = lines.pop() || "";
+        for (const line2 of lines) {
+          this.handleLine(line2, tail);
+          if (tail.excluded) break;
+        }
+      }
+    } catch (err) {
+      console.error(`[transcripts] Read error for ${filePath}:`, err);
+    } finally {
+      try {
+        fs.closeSync(fd);
+      } catch {
+      }
+    }
+  }
+  handleLine(line2, tail) {
+    const trimmed = line2.trim();
+    if (!trimmed) return;
+    let obj;
+    try {
+      obj = JSON.parse(trimmed);
+    } catch {
+      return;
+    }
+    const entry = this.agentId === "claude" ? this.parseClaudeLine(obj) : this.parseCodexLine(obj, tail);
+    if (!entry) return;
+    const ms = Date.parse(entry.ts);
+    if (Number.isFinite(ms) && ms < this.sinceMs - DISCOVERY_SLACK_MS) return;
+    this.sink({ ...entry, content: capLength(entry.content) });
+  }
+  // ─── Claude Code format ─────────────────────────
+  parseClaudeLine(obj) {
+    if (!obj || typeof obj !== "object") return null;
+    if (obj.isMeta) return null;
+    if (obj.type !== "user" && obj.type !== "assistant") return null;
+    if (typeof obj.cwd === "string" && stripTrailingSep(obj.cwd) !== this.cwd) return null;
+    if (obj.isSidechain) return null;
+    const message = obj.message;
+    if (!message) return null;
+    const text = extractClaudeText(message.content, obj.type === "user");
+    if (!text) return null;
+    return {
+      ts: typeof obj.timestamp === "string" ? obj.timestamp : (/* @__PURE__ */ new Date()).toISOString(),
+      type: obj.type === "user" ? "user_input" : "terminal_output",
+      content: text
+    };
+  }
+  // ─── Codex CLI format ───────────────────────────
+  parseCodexLine(obj, tail) {
+    if (!obj || typeof obj !== "object") return null;
+    const payload = obj.payload;
+    if (obj.type === "session_meta") {
+      const metaCwd = payload?.cwd;
+      if (typeof metaCwd === "string" && stripTrailingSep(metaCwd) !== this.cwd) {
+        tail.excluded = true;
+      }
+      return null;
+    }
+    if (obj.type !== "event_msg" || !payload || typeof payload !== "object") return null;
+    let type;
+    if (payload.type === "user_message") {
+      type = "user_input";
+    } else if (payload.type === "agent_message") {
+      type = "terminal_output";
+    } else {
+      return null;
+    }
+    const text = typeof payload.message === "string" ? payload.message.trim() : "";
+    if (!text || isCodexNoise(text)) return null;
+    return {
+      ts: typeof obj.timestamp === "string" ? obj.timestamp : (/* @__PURE__ */ new Date()).toISOString(),
+      type,
+      content: text
+    };
+  }
+};
+var CLAUDE_NOISE_PREFIXES = [
+  "<local-command-caveat>",
+  "<command-name>",
+  "<command-message>",
+  "<local-command-stdout>",
+  "<bash-input>",
+  "<bash-stdout>",
+  "<bash-stderr>",
+  "<system-reminder>",
+  "<task-notification>",
+  "caveat: the messages below",
+  "[request interrupted"
+];
+var CODEX_NOISE_PREFIXES = [
+  "<environment_context>",
+  "<user_instructions>",
+  "<permissions instructions>",
+  "<turn_aborted>"
+];
+function isClaudeNoise(text) {
+  const lower = text.trimStart().toLowerCase();
+  return CLAUDE_NOISE_PREFIXES.some((p) => lower.startsWith(p));
+}
+function isCodexNoise(text) {
+  const lower = text.trimStart().toLowerCase();
+  return CODEX_NOISE_PREFIXES.some((p) => lower.startsWith(p));
+}
+function extractClaudeText(content, isUser) {
+  if (typeof content === "string") {
+    const text = content.trim();
+    return text && !isClaudeNoise(text) ? text : "";
+  }
+  if (!Array.isArray(content)) return "";
+  if (isUser && content.some((b) => b?.type === "tool_result")) return "";
+  const parts = [];
+  for (const block of content) {
+    if (block?.type !== "text" || typeof block.text !== "string") continue;
+    const text = block.text.trim();
+    if (text && !isClaudeNoise(text)) parts.push(text);
+  }
+  return parts.join("\n\n");
+}
+function stripTrailingSep(p) {
+  return p.length > 1 ? p.replace(/[/\\]+$/, "") : p;
+}
+function capLength(str) {
+  if (str.length <= MAX_ENTRY_CHARS) return str;
+  return str.slice(0, MAX_ENTRY_CHARS) + `\u2026 [truncated, ${str.length} total chars]`;
+}
+
+// repro-toggle.ts
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var now = () => (/* @__PURE__ */ new Date()).toISOString();
+var line = (o) => JSON.stringify(o) + "\n";
+var tmp = fs2.mkdtempSync(path2.join(os2.tmpdir(), "toggle-test-"));
+var claudeDir = path2.join(tmp, "claude-projects");
+var cwd = "/Users/test/projects/my_app";
+var projDir = path2.join(claudeDir, "-Users-test-projects-my-app");
+fs2.mkdirSync(projDir, { recursive: true });
+var sessionFile = path2.join(projDir, "session-1.jsonl");
+var era = "enable#1";
+var emitted = [];
+var sink = (e) => emitted.push({ era, type: e.type, content: e.content });
+function makeTailer() {
+  return new TranscriptTailer({ agentId: "claude", cwd, sink, claudeProjectsDir: claudeDir });
+}
+async function main() {
+  let tailer = makeTailer();
+  tailer.start();
+  await sleep(200);
+  fs2.appendFileSync(sessionFile, line({
+    type: "assistant",
+    cwd,
+    timestamp: now(),
+    message: { role: "assistant", content: [{ type: "text", text: "Reply ONE \u2014 while first enabled." }] }
+  }));
+  await sleep(1500);
+  tailer.stop();
+  era = "between";
+  await sleep(800);
+  era = "enable#2";
+  tailer = makeTailer();
+  tailer.start();
+  await sleep(200);
+  fs2.appendFileSync(sessionFile, line({
+    type: "assistant",
+    cwd,
+    timestamp: now(),
+    message: { role: "assistant", content: [{ type: "text", text: "Reply TWO \u2014 after off then on." }] }
+  }));
+  await sleep(1500);
+  tailer.stop();
+  console.log("\nEmitted entries:");
+  for (const e of emitted) console.log(`  [${e.era}] ${e.type}: ${JSON.stringify(e.content)}`);
+  const two = emitted.filter((e) => e.content.includes("Reply TWO"));
+  console.log("\n--- VERDICT ---");
+  console.log(`Reply ONE emitted while enabled#1: ${emitted.some((e) => e.era === "enable#1" && e.content.includes("Reply ONE"))}`);
+  console.log(`Reply TWO emitted after off\u2192on:    ${two.length > 0}  (count=${two.length}, eras=${JSON.stringify(two.map((e) => e.era))})`);
+  if (two.length === 0) {
+    console.log(">> BUG REPRODUCED: new reply after toggle is NEVER forwarded by the tailer.");
+  } else {
+    console.log(">> Tailer re-emits fine \u2014 bug is NOT in the main-process layer.");
+  }
+  fs2.rmSync(tmp, { recursive: true, force: true });
+}
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phenx-inc/ctlsurf",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "Agent-agnostic terminal and desktop app for ctlsurf — run Claude Code, Codex, or any coding agent with live session logging and remote control",
   "main": "out/main/index.js",
   "bin": {

package/src/main/index.ts

@@ -106,6 +106,7 @@ const orchestrator = new Orchestrator(
     onWorkerMessage: (message) => mainWindow?.webContents.send('worker:message', message),
     onWorkerRegistered: (data) => mainWindow?.webContents.send('worker:registered', data),
     onProjectChanged: (name) => mainWindow?.webContents.send('app:projectChanged', name),
+    onAgentMessage: (text) => mainWindow?.webContents.send('agent:message', text),
     onCwdChanged: () => {
       mainWindow?.webContents.send('app:cwdChanged')
       updateProjectBadge(orchestrator.cwd)
@@ -414,6 +415,14 @@ ipcMain.handle('logchat:set', (_event, enabled: boolean) => {
   return { enabled: orchestrator.logChatEnabled }
 })
 
+ipcMain.handle('speak:get', () => ({ enabled: orchestrator.speakRepliesEnabled }))
+ipcMain.handle('speak:set', (_event, enabled: boolean) => {
+  orchestrator.setSpeakReplies(!!enabled)
+  return { enabled: orchestrator.speakRepliesEnabled }
+})
+// Latest assistant reply from the active tab's transcript, for on-demand TTS.
+ipcMain.handle('agent:getLastReply', () => orchestrator.getLastReply())
+
 // ─── Tracking IPC ─────────────────────────────────
 
 ipcMain.handle('tracking:get', () => ({ active: orchestrator.isActiveTabTracking() }))

package/src/main/orchestrator.ts

@@ -6,7 +6,7 @@ import { PtyManager } from './pty'
 import { AgentConfig, isCodingAgent } from './agents'
 import { CtlsurfApi } from './ctlsurfApi'
 import { ConversationBridge } from './bridge'
-import { TranscriptTailer, supportsTranscriptLogging } from './transcripts'
+import { TranscriptTailer, supportsTranscriptLogging, readLatestAssistantReply } from './transcripts'
 import { WorkerWsClient, type WorkerWsStatus, type IncomingMessage } from './workerWs'
 import { TimeTracker } from './timeTracker'
 import { TicketStore, type TicketInput } from './ticketStore'
@@ -32,6 +32,9 @@ export interface SettingsData {
   ctlsurfBaseUrl?: string
   ctlsurfDataspacePageId?: string
   logChat?: boolean
+  // Speak agent replies aloud (Electron desktop only). Drives the transcript
+  // tailer the same way logChat does, independent of chat logging.
+  speakReplies?: boolean
 }
 
 export interface OrchestratorEvents {
@@ -44,6 +47,10 @@ export interface OrchestratorEvents {
   // Human-readable name of the connected ctlsurf project (folder), or null
   // when no project is connected. Optional — only the desktop header uses it.
   onProjectChanged?: (name: string | null) => void
+  // A clean assistant reply from the active agent's transcript, forwarded for
+  // text-to-speech. Optional and wired only by the Electron entry — the
+  // headless build leaves it unset, so replies are never spoken in a terminal.
+  onAgentMessage?: (text: string) => void
 }
 
 interface TabState {
@@ -148,16 +155,42 @@ export class Orchestrator {
     return !!this.settings.logChat
   }
 
+  get speakRepliesEnabled(): boolean {
+    return !!this.settings.speakReplies
+  }
+
+  // Latest assistant reply from a tab's transcript, for on-demand "read aloud".
+  // Defaults to the active tab. Returns null when the tab's agent has no native
+  // transcript (only Claude Code / Codex do) or nothing has been said yet. Reads
+  // the transcript directly, so it works regardless of the speakReplies setting.
+  getLastReply(tabId?: string): string | null {
+    const id = tabId || this.activeTabId
+    if (!id) return null
+    const tab = this.tabs.get(id)
+    if (!tab || !supportsTranscriptLogging(tab.agent.id)) return null
+    return readLatestAssistantReply({ agentId: tab.agent.id, cwd: tab.cwd })
+  }
+
   setLogChat(enabled: boolean): void {
     this.settings.logChat = enabled
     this.saveSettings()
     this.bridge.setLoggingEnabled(enabled)
-    if (!enabled) {
-      this.stopChatLogging()
-    } else if (this.activeTabId) {
-      const tab = this.tabs.get(this.activeTabId)
-      if (tab) this.startChatLogging(tab.agent, tab.cwd)
-    }
+    this.restartActiveChatLogging()
+  }
+
+  setSpeakReplies(enabled: boolean): void {
+    this.settings.speakReplies = enabled
+    this.saveSettings()
+    this.restartActiveChatLogging()
+  }
+
+  // Re-evaluate the transcript tailer for the active tab against the current
+  // logChat / speakReplies flags. Both setters funnel through here.
+  private restartActiveChatLogging(): void {
+    this.stopChatLogging()
+    if (!this.activeTabId) return
+    const tab = this.tabs.get(this.activeTabId)
+    if (tab) this.startChatLogging(tab.agent, tab.cwd)
   }
 
   // Agents with native session transcripts (Claude Code, Codex) get exact
@@ -165,16 +198,24 @@ export class Orchestrator {
   // the terminal screen-scraper bridge.
   private startChatLogging(agent: AgentConfig, cwd: string): void {
     this.stopChatLogging()
-    if (!this.settings.logChat) return
+    if (!this.settings.logChat && !this.settings.speakReplies) return
 
     if (supportsTranscriptLogging(agent.id)) {
       this.transcriptTailer = new TranscriptTailer({
         agentId: agent.id,
         cwd,
-        sink: (entry) => this.workerWs.sendChatLog(entry),
+        sink: (entry) => {
+          if (this.settings.logChat) this.workerWs.sendChatLog(entry)
+          // Only assistant replies are spoken; user_input entries are skipped.
+          if (this.settings.speakReplies && entry.type === 'terminal_output') {
+            this.events.onAgentMessage?.(entry.content)
+          }
+        },
       })
       this.transcriptTailer.start()
-    } else {
+    } else if (this.settings.logChat) {
+      // The screen-scraper feeds ctlsurf chat logging only; TTS needs the clean
+      // transcript path, so non-transcript agents aren't spoken aloud.
       this.bridge.startSession()
     }
   }

package/src/main/transcripts.ts

@@ -339,3 +339,137 @@ function capLength(str: string): string {
   if (str.length <= MAX_ENTRY_CHARS) return str
   return str.slice(0, MAX_ENTRY_CHARS) + `… [truncated, ${str.length} total chars]`
 }
+
+// ─── One-shot latest-reply read (on-demand "read aloud") ──────────
+//
+// Unlike the tailer, this does a single synchronous scan to return the most
+// recent assistant reply for an agent + cwd, independent of whether the tailer
+// is running. Used by the "read last response aloud" button so it works even
+// when the speak-replies setting is off. Returns null when there's no
+// transcript or no assistant message yet.
+export function readLatestAssistantReply(opts: {
+  agentId: TranscriptAgentId
+  cwd: string
+  claudeProjectsDir?: string
+  codexSessionsDir?: string
+}): string | null {
+  try {
+    const cwd = stripTrailingSep(opts.cwd)
+    if (opts.agentId === 'claude') {
+      const file = mostRecentClaudeFile(cwd, opts.claudeProjectsDir)
+      if (!file) return null
+      const text = lastClaudeAssistant(file, cwd)
+      return text ? capLength(text) : null
+    }
+    // Codex: the active session is the most recently written rollout for this cwd.
+    const codexRoot = opts.codexSessionsDir || path.join(os.homedir(), '.codex', 'sessions')
+    for (const file of recentCodexRollouts(codexRoot)) {
+      const text = lastCodexAgentMessage(file, cwd)
+      if (text) return capLength(text)
+    }
+    return null
+  } catch {
+    return null
+  }
+}
+
+// Whole-file read is fine here: transcripts are at most a few MB and we only do
+// this on an explicit button click, not on a poll.
+function readLines(file: string): string[] {
+  try {
+    return fs.readFileSync(file, 'utf-8').split('\n')
+  } catch {
+    return []
+  }
+}
+
+function mostRecentClaudeFile(cwd: string, root?: string): string | null {
+  const projectsRoot = root || path.join(os.homedir(), '.claude', 'projects')
+  const slug = cwd.replace(/[^a-zA-Z0-9]/g, '-')
+  const dir = path.join(projectsRoot, slug)
+  let names: string[]
+  try {
+    names = fs.readdirSync(dir)
+  } catch {
+    return null
+  }
+  let best: string | null = null
+  let bestMs = -Infinity
+  for (const name of names) {
+    if (!name.endsWith('.jsonl')) continue
+    const fp = path.join(dir, name)
+    try {
+      const ms = fs.statSync(fp).mtimeMs
+      if (ms > bestMs) { bestMs = ms; best = fp }
+    } catch { /* ignore */ }
+  }
+  return best
+}
+
+function recentCodexRollouts(root: string): string[] {
+  // Today and yesterday's session dirs (covers sessions spanning midnight),
+  // newest file first.
+  const dirs = new Set<string>()
+  const now = Date.now()
+  for (const ms of [now, now - 24 * 60 * 60 * 1000]) {
+    const d = new Date(ms)
+    const yyyy = String(d.getFullYear())
+    const mm = String(d.getMonth() + 1).padStart(2, '0')
+    const dd = String(d.getDate()).padStart(2, '0')
+    dirs.add(path.join(root, yyyy, mm, dd))
+  }
+  const files: Array<{ fp: string; ms: number }> = []
+  for (const dir of dirs) {
+    let names: string[]
+    try { names = fs.readdirSync(dir) } catch { continue }
+    for (const name of names) {
+      if (!name.startsWith('rollout-') || !name.endsWith('.jsonl')) continue
+      const fp = path.join(dir, name)
+      try { files.push({ fp, ms: fs.statSync(fp).mtimeMs }) } catch { /* ignore */ }
+    }
+  }
+  return files.sort((a, b) => b.ms - a.ms).map((f) => f.fp)
+}
+
+function lastClaudeAssistant(file: string, cwd: string): string | null {
+  const lines = readLines(file)
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const trimmed = lines[i].trim()
+    if (!trimmed) continue
+    let obj: any
+    try { obj = JSON.parse(trimmed) } catch { continue }
+    if (!obj || typeof obj !== 'object') continue
+    if (obj.isMeta || obj.isSidechain || obj.type !== 'assistant') continue
+    if (typeof obj.cwd === 'string' && stripTrailingSep(obj.cwd) !== cwd) continue
+    const text = extractClaudeText(obj.message?.content, false)
+    if (text) return text
+  }
+  return null
+}
+
+function lastCodexAgentMessage(file: string, cwd: string): string | null {
+  const lines = readLines(file)
+  // The date dir is shared across projects, so confirm this rollout belongs to
+  // our cwd via its session_meta before trusting any of its messages.
+  for (const line of lines) {
+    const trimmed = line.trim()
+    if (!trimmed) continue
+    let obj: any
+    try { obj = JSON.parse(trimmed) } catch { continue }
+    if (obj?.type === 'session_meta') {
+      const metaCwd = obj.payload?.cwd
+      if (typeof metaCwd === 'string' && stripTrailingSep(metaCwd) !== cwd) return null
+      break
+    }
+  }
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const trimmed = lines[i].trim()
+    if (!trimmed) continue
+    let obj: any
+    try { obj = JSON.parse(trimmed) } catch { continue }
+    if (obj?.type !== 'event_msg' || obj.payload?.type !== 'agent_message') continue
+    const text = typeof obj.payload.message === 'string' ? obj.payload.message.trim() : ''
+    if (text && !isCodexNoise(text)) return text
+  }
+  return null
+}