@kibitzsh/kibitz 0.0.3

package/dist/core/watcher.js

@@ -0,0 +1,866 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/watcher.ts
+var watcher_exports = {};
+__export(watcher_exports, {
+  SessionWatcher: () => SessionWatcher
+});
+module.exports = __toCommonJS(watcher_exports);
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var os = __toESM(require("os"));
+var import_events = require("events");
+
+// src/core/parsers/claude.ts
+function summarizeToolUse(name, input) {
+  switch (name) {
+    case "Bash":
+      return `Running: ${truncate(String(input.command || ""), 80)}`;
+    case "Read":
+      return `Reading ${shortPath(String(input.file_path || ""))}`;
+    case "Write":
+      return `Writing ${shortPath(String(input.file_path || ""))}`;
+    case "Edit":
+      return `Editing ${shortPath(String(input.file_path || ""))}`;
+    case "Grep":
+      return `Searching for "${truncate(String(input.pattern || ""), 40)}"`;
+    case "Glob":
+      return `Finding files: ${truncate(String(input.pattern || ""), 40)}`;
+    case "Task":
+      return `Spawning agent: ${truncate(String(input.description || ""), 60)}`;
+    case "TodoWrite":
+      return "Updating task list";
+    case "WebSearch":
+      return `Web search: "${truncate(String(input.query || ""), 50)}"`;
+    case "WebFetch":
+      return `Fetching: ${truncate(String(input.url || ""), 60)}`;
+    default:
+      return `Using tool: ${name}`;
+  }
+}
+function shortPath(p) {
+  const parts = String(p || "").split(/[\\/]+/).filter(Boolean);
+  if (parts.length <= 3) return String(p || "");
+  return ".../" + parts.slice(-2).join("/");
+}
+function truncate(s, max) {
+  return s.length > max ? s.slice(0, max) + "..." : s;
+}
+function projectNameFromCwd(cwd) {
+  const parts = String(cwd || "").split(/[\\/]+/).filter(Boolean);
+  return parts[parts.length - 1] || "unknown";
+}
+function parseClaudeLine(line, filePath) {
+  let obj;
+  try {
+    obj = JSON.parse(line);
+  } catch {
+    return [];
+  }
+  const sessionId = obj.sessionId || sessionIdFromFilePath(filePath);
+  const projectName = obj.cwd ? projectNameFromCwd(obj.cwd) : projectFromFilePath(filePath);
+  const timestamp = obj.timestamp ? new Date(obj.timestamp).getTime() : Date.now();
+  if (obj.type === "queue-operation" || obj.type === "file-history-snapshot" || obj.type === "progress") {
+    return [];
+  }
+  const events = [];
+  if (obj.type === "assistant" && obj.message?.content) {
+    for (const block of obj.message.content) {
+      if (block.type === "tool_use" && block.name && block.input) {
+        events.push({
+          sessionId,
+          projectName,
+          agent: "claude",
+          source: "cli",
+          // will be overridden by watcher
+          timestamp,
+          type: "tool_call",
+          summary: summarizeToolUse(block.name, block.input),
+          details: { tool: block.name, input: block.input }
+        });
+      } else if (block.type === "text" && block.text) {
+        const text = block.text.trim();
+        if (text.length > 0) {
+          events.push({
+            sessionId,
+            projectName,
+            agent: "claude",
+            source: "cli",
+            timestamp,
+            type: "message",
+            summary: truncate(text, 120),
+            details: { text }
+          });
+        }
+      }
+    }
+  }
+  if (obj.type === "user" && obj.message?.content) {
+    for (const block of obj.message.content) {
+      if (block.type === "tool_result") {
+        events.push({
+          sessionId,
+          projectName,
+          agent: "claude",
+          source: "cli",
+          timestamp,
+          type: "tool_result",
+          summary: "Tool completed",
+          details: { tool_use_id: block.tool_use_id }
+        });
+      }
+    }
+  }
+  return events;
+}
+function projectFromFilePath(filePath) {
+  const segments = String(filePath || "").split(/[\\/]+/).filter(Boolean);
+  const projectDir = segments.length >= 2 ? segments[segments.length - 2] : "";
+  const projectSegments = projectDir.split("-").filter(Boolean);
+  return projectSegments[projectSegments.length - 1] || "unknown";
+}
+function sessionIdFromFilePath(filePath) {
+  return String(filePath || "").split(/[\\/]+/).filter(Boolean).pop()?.replace(/\.jsonl$/i, "") || "";
+}
+
+// src/core/parsers/codex.ts
+function truncate2(s, max) {
+  return s.length > max ? s.slice(0, max) + "..." : s;
+}
+function projectNameFromCwd2(cwd) {
+  const parts = String(cwd || "").split(/[\\/]+/).filter(Boolean);
+  return parts[parts.length - 1] || "unknown";
+}
+function parseCodexLine(line, filePath) {
+  let obj;
+  try {
+    obj = JSON.parse(line);
+  } catch {
+    return [];
+  }
+  const timestamp = obj.timestamp ? new Date(obj.timestamp).getTime() : Date.now();
+  const sessionId = sessionIdFromFilePath2(filePath);
+  const events = [];
+  if (obj.type === "session_meta" && obj.payload) {
+    const cwd = obj.payload.cwd || "";
+    events.push({
+      sessionId,
+      projectName: projectNameFromCwd2(cwd),
+      agent: "codex",
+      source: "cli",
+      timestamp,
+      type: "meta",
+      summary: `Codex session started (${obj.payload.model_provider || "unknown"}, v${obj.payload.cli_version || "?"})`,
+      details: { cwd, provider: obj.payload.model_provider, version: obj.payload.cli_version }
+    });
+  }
+  if (obj.type === "response_item" && obj.payload) {
+    const p = obj.payload;
+    if (p.type === "function_call" && p.name) {
+      let args = {};
+      try {
+        args = JSON.parse(p.arguments || "{}");
+      } catch {
+      }
+      const summary = summarizeCodexTool(p.name, args);
+      events.push({
+        sessionId,
+        projectName: projectFromFilePath2(filePath),
+        agent: "codex",
+        source: "cli",
+        timestamp,
+        type: "tool_call",
+        summary,
+        details: { tool: p.name, input: args }
+      });
+    }
+    if (p.type === "function_call_output") {
+      events.push({
+        sessionId,
+        projectName: projectFromFilePath2(filePath),
+        agent: "codex",
+        source: "cli",
+        timestamp,
+        type: "tool_result",
+        summary: `Tool completed: ${truncate2(p.output || "", 60)}`,
+        details: { output: p.output, call_id: p.call_id }
+      });
+    }
+    if (p.role === "assistant" && p.content) {
+      for (const block of p.content) {
+        const text = block.text || block.input_text || "";
+        if (text.trim()) {
+          events.push({
+            sessionId,
+            projectName: projectFromFilePath2(filePath),
+            agent: "codex",
+            source: "cli",
+            timestamp,
+            type: "message",
+            summary: truncate2(text.trim(), 120),
+            details: { text }
+          });
+        }
+      }
+    }
+  }
+  if (obj.type === "event_msg" && obj.payload) {
+    if (obj.payload.type === "task_started") {
+      events.push({
+        sessionId,
+        projectName: projectFromFilePath2(filePath),
+        agent: "codex",
+        source: "cli",
+        timestamp,
+        type: "meta",
+        summary: "Codex task started",
+        details: { turn_id: obj.payload.turn_id }
+      });
+    }
+  }
+  return events;
+}
+function summarizeCodexTool(name, args) {
+  if (name === "shell" || name === "run_command") {
+    return `Running: ${truncate2(String(args.command || args.cmd || ""), 80)}`;
+  }
+  if (name === "read_file" || name === "file_read") {
+    return `Reading ${truncate2(String(args.path || args.file_path || ""), 60)}`;
+  }
+  if (name === "write_file" || name === "file_write") {
+    return `Writing ${truncate2(String(args.path || args.file_path || ""), 60)}`;
+  }
+  if (name === "edit_file" || name === "apply_diff") {
+    return `Editing ${truncate2(String(args.path || args.file_path || ""), 60)}`;
+  }
+  return `Using tool: ${name}`;
+}
+function sessionIdFromFilePath2(filePath) {
+  const basename2 = String(filePath || "").split(/[\\/]+/).filter(Boolean).pop()?.replace(/\.jsonl$/i, "") || "";
+  const match = basename2.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/);
+  return match ? match[1] : basename2;
+}
+function projectFromFilePath2(filePath) {
+  return "codex";
+}
+
+// src/core/watcher.ts
+var SessionWatcher = class _SessionWatcher extends import_events.EventEmitter {
+  watched = /* @__PURE__ */ new Map();
+  scanInterval = null;
+  claudeIdeLocks = /* @__PURE__ */ new Map();
+  sessionProjectNames = /* @__PURE__ */ new Map();
+  // sessionId → projectName from meta
+  static ACTIVE_SESSION_WINDOW_MS = 5 * 60 * 1e3;
+  constructor() {
+    super();
+  }
+  start() {
+    this.scan();
+    this.scanInterval = setInterval(() => this.scan(), 15e3);
+  }
+  stop() {
+    if (this.scanInterval) {
+      clearInterval(this.scanInterval);
+      this.scanInterval = null;
+    }
+    for (const w of this.watched.values()) {
+      w.watcher?.close();
+    }
+    this.watched.clear();
+  }
+  getActiveSessions() {
+    const now = Date.now();
+    const sessionsByKey = /* @__PURE__ */ new Map();
+    for (const w of this.watched.values()) {
+      if (w.ignore) continue;
+      this.reconcileCodexSessionTitle(w);
+      try {
+        const stat = fs.statSync(w.filePath);
+        if (now - stat.mtimeMs > _SessionWatcher.ACTIVE_SESSION_WINDOW_MS) continue;
+        const session = {
+          id: w.sessionId,
+          projectName: w.projectName,
+          sessionTitle: w.sessionTitle,
+          agent: w.agent,
+          source: this.detectSource(w),
+          filePath: w.filePath,
+          lastActivity: stat.mtimeMs
+        };
+        const key = `${session.agent}:${session.id.toLowerCase()}`;
+        const existing = sessionsByKey.get(key);
+        if (!existing || existing.lastActivity < session.lastActivity) {
+          sessionsByKey.set(key, session);
+        }
+      } catch {
+      }
+    }
+    return Array.from(sessionsByKey.values()).sort((a, b) => b.lastActivity - a.lastActivity);
+  }
+  scan() {
+    this.loadIdeLocks();
+    this.scanClaude();
+    this.scanCodex();
+    this.pruneStale();
+  }
+  scanClaude() {
+    const claudeDir = path.join(os.homedir(), ".claude", "projects");
+    if (!fs.existsSync(claudeDir)) return;
+    let projectDirs;
+    try {
+      projectDirs = fs.readdirSync(claudeDir).filter((d) => {
+        const full = path.join(claudeDir, d);
+        try {
+          return fs.statSync(full).isDirectory();
+        } catch {
+          return false;
+        }
+      });
+    } catch {
+      return;
+    }
+    const now = Date.now();
+    for (const dir of projectDirs) {
+      const dirPath = path.join(claudeDir, dir);
+      let files;
+      try {
+        files = fs.readdirSync(dirPath).filter((f) => f.endsWith(".jsonl"));
+      } catch {
+        continue;
+      }
+      for (const file of files) {
+        const filePath = path.join(dirPath, file);
+        try {
+          const stat = fs.statSync(filePath);
+          if (now - stat.mtimeMs > _SessionWatcher.ACTIVE_SESSION_WINDOW_MS) continue;
+        } catch {
+          continue;
+        }
+        if (!this.watched.has(filePath)) {
+          const projectName = extractProjectName(dir);
+          this.watchFile(filePath, "claude", projectName);
+        }
+      }
+    }
+  }
+  scanCodex() {
+    const currentTime = Date.now();
+    for (const sessionsDir of codexSessionDirs(2)) {
+      if (!fs.existsSync(sessionsDir)) continue;
+      let files;
+      try {
+        files = fs.readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl"));
+      } catch {
+        continue;
+      }
+      for (const file of files) {
+        const filePath = path.join(sessionsDir, file);
+        try {
+          const stat = fs.statSync(filePath);
+          if (currentTime - stat.mtimeMs > _SessionWatcher.ACTIVE_SESSION_WINDOW_MS) continue;
+        } catch {
+          continue;
+        }
+        if (!this.watched.has(filePath)) {
+          this.watchFile(filePath, "codex", "codex");
+        }
+      }
+    }
+  }
+  watchFile(filePath, agent, projectName) {
+    let offset;
+    try {
+      const stat = fs.statSync(filePath);
+      offset = stat.size;
+    } catch {
+      return;
+    }
+    let resolvedProjectName = projectName;
+    if (agent === "codex") {
+      const codexProject = extractCodexProjectName(filePath);
+      if (codexProject) resolvedProjectName = codexProject;
+    }
+    const sessionId = extractSessionIdFromLog(
+      filePath,
+      agent,
+      deriveSessionId(filePath, agent)
+    );
+    const ignore = agent === "codex" && isKibitzInternalCodexSession(filePath);
+    const sessionTitle = extractSessionTitle(filePath, agent, sessionId);
+    const entry = {
+      filePath,
+      sessionId,
+      offset,
+      agent,
+      ignore,
+      watcher: null,
+      projectName: resolvedProjectName,
+      sessionTitle
+    };
+    try {
+      entry.watcher = fs.watch(filePath, () => {
+        this.readNewLines(entry);
+      });
+    } catch {
+    }
+    this.watched.set(filePath, entry);
+  }
+  readNewLines(entry) {
+    if (entry.ignore) {
+      try {
+        const stat2 = fs.statSync(entry.filePath);
+        entry.offset = stat2.size;
+      } catch {
+      }
+      return;
+    }
+    let stat;
+    try {
+      stat = fs.statSync(entry.filePath);
+    } catch {
+      return;
+    }
+    this.reconcileCodexSessionTitle(entry);
+    if (stat.size <= entry.offset) return;
+    const fd = fs.openSync(entry.filePath, "r");
+    const buf = Buffer.alloc(stat.size - entry.offset);
+    fs.readSync(fd, buf, 0, buf.length, entry.offset);
+    fs.closeSync(fd);
+    entry.offset = stat.size;
+    const chunk = buf.toString("utf8");
+    const lines = chunk.split("\n").filter((l) => l.trim());
+    for (const line of lines) {
+      if (entry.agent === "codex" && isKibitzInternalCodexLine(line)) {
+        entry.ignore = true;
+        break;
+      }
+      if (!entry.sessionTitle) {
+        if (entry.agent === "codex") {
+          const title = extractCodexSessionTitle(entry.filePath, entry.sessionId);
+          if (title) entry.sessionTitle = title;
+        }
+      }
+      if (!entry.sessionTitle) {
+        const title = extractSessionTitleFromLine(line, entry.agent);
+        if (title) entry.sessionTitle = title;
+      }
+      let events;
+      if (entry.agent === "claude") {
+        events = parseClaudeLine(line, entry.filePath);
+      } else {
+        events = parseCodexLine(line, entry.filePath);
+      }
+      for (const event of events) {
+        const normalizedEventSessionId = normalizeSessionId(event.sessionId, entry.agent);
+        if (normalizedEventSessionId && normalizedEventSessionId !== entry.sessionId) {
+          entry.sessionId = normalizedEventSessionId;
+        }
+        event.sessionId = entry.sessionId;
+        event.source = this.detectSource(entry);
+        event.sessionTitle = entry.sessionTitle || fallbackSessionTitle(entry.projectName, entry.agent);
+        if (event.type === "meta" && event.details.cwd) {
+          const cwd = String(event.details.cwd);
+          const name = cwd.split("/").pop() || cwd.split("\\").pop() || "unknown";
+          this.sessionProjectNames.set(event.sessionId, name);
+          entry.projectName = name;
+          event.projectName = name;
+        } else if (this.sessionProjectNames.has(event.sessionId)) {
+          event.projectName = this.sessionProjectNames.get(event.sessionId);
+          entry.projectName = event.projectName;
+        }
+        this.emit("event", event);
+      }
+    }
+  }
+  reconcileCodexSessionTitle(entry) {
+    if (entry.agent !== "codex") return;
+    const threadTitle = getCodexThreadTitle(entry.sessionId);
+    if (threadTitle) {
+      if (threadTitle !== entry.sessionTitle) entry.sessionTitle = threadTitle;
+      return;
+    }
+    if (entry.sessionTitle && isNoiseSessionTitle(entry.sessionTitle)) {
+      entry.sessionTitle = void 0;
+    }
+  }
+  loadIdeLocks() {
+    const ideDir = path.join(os.homedir(), ".claude", "ide");
+    if (!fs.existsSync(ideDir)) return;
+    this.claudeIdeLocks.clear();
+    try {
+      const files = fs.readdirSync(ideDir).filter((f) => f.endsWith(".lock"));
+      for (const file of files) {
+        try {
+          const content = fs.readFileSync(path.join(ideDir, file), "utf8");
+          const lock = JSON.parse(content);
+          this.claudeIdeLocks.set(file, {
+            pid: lock.pid,
+            workspaceFolders: lock.workspaceFolders || []
+          });
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  detectSource(entry) {
+    if (entry.agent === "codex") return "cli";
+    return this.claudeIdeLocks.size > 0 ? "vscode" : "cli";
+  }
+  pruneStale() {
+    const now = Date.now();
+    for (const [filePath, entry] of this.watched) {
+      try {
+        const stat = fs.statSync(filePath);
+        if (now - stat.mtimeMs > _SessionWatcher.ACTIVE_SESSION_WINDOW_MS) {
+          entry.watcher?.close();
+          this.watched.delete(filePath);
+        }
+      } catch {
+        entry.watcher?.close();
+        this.watched.delete(filePath);
+      }
+    }
+  }
+};
+function extractSessionTitle(filePath, agent, sessionId) {
+  return agent === "claude" ? extractClaudeSessionTitle(filePath) : extractCodexSessionTitle(filePath, sessionId);
+}
+function extractSessionTitleFromLine(line, agent) {
+  try {
+    const obj = JSON.parse(line);
+    if (agent === "claude") {
+      if (obj.type !== "user") return void 0;
+      const content = obj.message?.content;
+      if (typeof content === "string") return pickSessionTitle(content);
+      if (Array.isArray(content)) {
+        for (const block of content) {
+          if (typeof block?.text === "string") {
+            const title = pickSessionTitle(block.text);
+            if (title) return title;
+          }
+        }
+      }
+      return void 0;
+    }
+    if (obj.type === "session_meta") {
+      const explicitTitle = pickSessionTitle(String(
+        obj.payload?.title || obj.payload?.session_title || obj.payload?.name || obj.payload?.summary || ""
+      ));
+      if (explicitTitle) return explicitTitle;
+    }
+    if (obj.type === "event_msg" && obj.payload?.type === "user_message") {
+      return pickSessionTitle(String(obj.payload.message || ""));
+    }
+    if (obj.type === "response_item" && obj.payload?.type === "message" && obj.payload?.role === "user") {
+      const contentBlocks = obj.payload.content;
+      if (Array.isArray(contentBlocks)) {
+        for (const block of contentBlocks) {
+          const text = typeof block?.text === "string" ? block.text : typeof block?.input_text === "string" ? block.input_text : "";
+          const title = pickSessionTitle(text);
+          if (title) return title;
+        }
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+function extractClaudeSessionTitle(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf8");
+    for (const line of content.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const obj = JSON.parse(line);
+        if (obj.type === "user") {
+          const msg = obj.message;
+          if (!msg) continue;
+          const content2 = msg.content;
+          if (typeof content2 === "string" && content2.trim()) {
+            const title = pickSessionTitle(content2);
+            if (title) return title;
+          }
+          if (Array.isArray(content2)) {
+            for (const block of content2) {
+              if (block.type === "text" && typeof block.text === "string" && block.text.trim()) {
+                const title = pickSessionTitle(block.text);
+                if (title) return title;
+              }
+            }
+          }
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+function extractCodexSessionTitle(filePath, sessionId) {
+  const codexSessionId = sessionId || deriveSessionId(filePath, "codex");
+  const explicitThreadTitle = getCodexThreadTitle(codexSessionId);
+  if (explicitThreadTitle) return explicitThreadTitle;
+  const logDerivedTitle = extractCodexSessionTitleFromLog(filePath);
+  return logDerivedTitle || void 0;
+}
+function getCodexThreadTitle(sessionId) {
+  const normalizedSessionId = String(sessionId || "").trim().toLowerCase();
+  if (!normalizedSessionId) return void 0;
+  return readCodexThreadTitles().titles.get(normalizedSessionId);
+}
+function extractCodexSessionTitleFromLog(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf8");
+    for (const line of content.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const obj = JSON.parse(line);
+        if (obj.type !== "session_meta") continue;
+        const explicitTitle = pickSessionTitle(String(
+          obj.payload?.title || obj.payload?.session_title || obj.payload?.name || obj.payload?.summary || ""
+        ));
+        if (explicitTitle) return explicitTitle;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+function extractCodexProjectName(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf8");
+    for (const line of content.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const obj = JSON.parse(line);
+        if (obj.type !== "session_meta") continue;
+        const cwd = typeof obj.payload?.cwd === "string" ? obj.payload.cwd : "";
+        if (!cwd) continue;
+        const name = cwd.split("/").pop() || cwd.split("\\").pop();
+        if (name && name.trim()) return name.trim();
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+function isKibitzInternalCodexSession(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf8");
+    const lines = content.split("\n");
+    const maxProbeLines = 50;
+    for (let i = 0; i < lines.length && i < maxProbeLines; i++) {
+      const line = lines[i];
+      if (!line.trim()) continue;
+      try {
+        const obj = JSON.parse(line);
+        if (obj.type === "event_msg" && obj.payload?.type === "user_message") {
+          const msg = String(obj.payload?.message || "").toLowerCase();
+          if (looksLikeKibitzGeneratedPrompt(msg)) return true;
+        }
+        if (obj.type === "response_item" && obj.payload?.type === "message" && obj.payload?.role === "user" && Array.isArray(obj.payload?.content)) {
+          for (const block of obj.payload.content) {
+            const text = typeof block?.text === "string" ? block.text : typeof block?.input_text === "string" ? block.input_text : "";
+            if (looksLikeKibitzGeneratedPrompt(String(text).toLowerCase())) return true;
+          }
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return false;
+}
+function isKibitzInternalCodexLine(line) {
+  try {
+    const obj = JSON.parse(line);
+    if (obj.type === "event_msg" && obj.payload?.type === "user_message") {
+      const msg = String(obj.payload?.message || "").toLowerCase();
+      return looksLikeKibitzGeneratedPrompt(msg);
+    }
+    if (obj.type === "response_item" && obj.payload?.type === "message" && obj.payload?.role === "user" && Array.isArray(obj.payload?.content)) {
+      for (const block of obj.payload.content) {
+        const text = typeof block?.text === "string" ? block.text : typeof block?.input_text === "string" ? block.input_text : "";
+        if (looksLikeKibitzGeneratedPrompt(String(text).toLowerCase())) return true;
+      }
+    }
+  } catch {
+  }
+  return false;
+}
+function looksLikeKibitzGeneratedPrompt(text) {
+  if (!text) return false;
+  return text.includes("you oversee ai coding agents. summarize what they did") && text.includes("format for this message:") && text.includes("tone preset:");
+}
+var codexThreadTitlesCache = {
+  mtimeMs: -1,
+  titles: /* @__PURE__ */ new Map(),
+  order: []
+};
+function readCodexThreadTitles() {
+  const statePath = path.join(os.homedir(), ".codex", ".codex-global-state.json");
+  try {
+    const stat = fs.statSync(statePath);
+    if (stat.mtimeMs === codexThreadTitlesCache.mtimeMs) return codexThreadTitlesCache;
+    const raw = JSON.parse(fs.readFileSync(statePath, "utf8"));
+    const rawTitles = raw?.["thread-titles"]?.titles;
+    const rawOrder = raw?.["thread-titles"]?.order;
+    const titles = /* @__PURE__ */ new Map();
+    if (rawTitles && typeof rawTitles === "object" && !Array.isArray(rawTitles)) {
+      for (const [key, value] of Object.entries(rawTitles)) {
+        const sessionId = String(key || "").trim().toLowerCase();
+        if (!sessionId) continue;
+        const title = pickSessionTitle(String(value || ""));
+        if (title) titles.set(sessionId, title);
+      }
+    }
+    const order = Array.isArray(rawOrder) ? rawOrder.map((item) => String(item || "").trim().toLowerCase()).filter(Boolean) : [];
+    codexThreadTitlesCache.mtimeMs = stat.mtimeMs;
+    codexThreadTitlesCache.titles = titles;
+    codexThreadTitlesCache.order = order;
+  } catch {
+  }
+  return codexThreadTitlesCache;
+}
+function deriveSessionId(filePath, agent) {
+  const basename2 = path.basename(filePath, ".jsonl");
+  if (agent !== "codex") return basename2;
+  const match = basename2.match(/([0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12})/i);
+  return match ? match[1].toLowerCase() : basename2.toLowerCase();
+}
+function normalizeSessionId(rawSessionId, agent) {
+  const value = String(rawSessionId || "").trim();
+  if (!value) return "";
+  if (agent === "codex") return value.toLowerCase();
+  return value;
+}
+function extractSessionIdFromLog(filePath, agent, fallback) {
+  const normalizedFallback = normalizeSessionId(fallback, agent);
+  if (agent !== "claude") return normalizedFallback;
+  try {
+    const stat = fs.statSync(filePath);
+    const length = Math.min(stat.size, 512 * 1024);
+    if (length <= 0) return normalizedFallback;
+    const fd = fs.openSync(filePath, "r");
+    try {
+      const buf = Buffer.alloc(length);
+      const offset = Math.max(0, stat.size - length);
+      fs.readSync(fd, buf, 0, length, offset);
+      const lines = buf.toString("utf8").split("\n").filter((line) => line.trim());
+      for (let i = lines.length - 1; i >= 0; i -= 1) {
+        try {
+          const obj = JSON.parse(lines[i]);
+          const fromLine = normalizeSessionId(obj?.sessionId, agent);
+          if (fromLine) return fromLine;
+        } catch {
+        }
+      }
+    } finally {
+      fs.closeSync(fd);
+    }
+  } catch {
+  }
+  return normalizedFallback;
+}
+function pickSessionTitle(raw) {
+  if (!raw.trim()) return void 0;
+  if (looksLikeKibitzGeneratedPrompt(raw.toLowerCase())) return void 0;
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const cleaned = trimmed.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+    if (!cleaned || isNoiseSessionTitle(cleaned)) continue;
+    return cleaned;
+  }
+  return void 0;
+}
+function isNoiseSessionTitle(text) {
+  const lower = text.toLowerCase();
+  const normalized = lower.replace(/^[#>*\-\s]+/, "").trim();
+  if (normalized.length < 8) return true;
+  if (looksLikeSessionIdentifier(normalized)) return true;
+  if (/^[a-z0-9+/_=-]{64,}$/.test(normalized)) return true;
+  if (normalized.startsWith("the user opened the file ") || normalized.includes("may or may not be related to the current task")) return true;
+  if (/^[\w][\w.\-]*\.[a-z]{2,6}:\s/i.test(normalized)) return true;
+  if (/^\d+\)\s+after deciding to use a skill\b/.test(normalized) || /^\d+\)\s+when `?skill\.md`? references\b/.test(normalized) || /^\d+\)\s+if `?skill\.md`? points\b/.test(normalized) || /^\d+\)\s+if `?scripts\/`? exist\b/.test(normalized) || /^\d+\)\s+if `?assets\/`? or templates exist\b/.test(normalized) || /^perform( a)? repository commit\b/.test(normalized)) return true;
+  if (normalized.startsWith("agents.md instructions for") || normalized.startsWith("a skill is a set of local instructions") || normalized.startsWith("researched how the feature works") || normalized.startsWith("context from my ide setup:") || normalized.startsWith("open tabs:") || normalized.startsWith("my request for codex:") || normalized.startsWith("available skills") || normalized.startsWith("how to use skills") || normalized.startsWith("never mention session ids") || normalized.startsWith("never write in first person") || normalized.startsWith("you oversee ai coding agents") || normalized.startsWith("plain language.") || normalized.startsWith("bold only key nouns") || normalized.startsWith("upper case for emotional") || normalized.startsWith("emoji are allowed") || normalized.startsWith("no filler.") || normalized.startsWith("don't repeat what previous commentary") || normalized.startsWith("rules:") || normalized.startsWith("format for this message:") || normalized.startsWith("tone preset:") || normalized.startsWith("additional user instruction:") || normalized.startsWith("skill-creator:") || normalized.startsWith("skill-installer:") || normalized.startsWith("- skill-") || normalized.startsWith("discovery:") || normalized.startsWith("trigger rules:") || normalized.startsWith("missing/blocked:") || normalized.startsWith("how to use a skill") || normalized.startsWith("context hygiene:") || normalized.startsWith("safety and fallback:") || normalized.startsWith("environment_context") || normalized.startsWith("/environment_context") || normalized.startsWith("permissions instructions") || normalized.startsWith("filesystem sandboxing defines") || normalized.startsWith("collaboration mode:") || normalized.startsWith("system instructions:") || normalized.startsWith("user request:") || normalized.startsWith("active goals") || normalized.startsWith("room memory") || normalized.startsWith("recent activity") || normalized.startsWith("room workers") || normalized.startsWith("room tasks") || normalized.startsWith("recent decisions") || normalized.startsWith("pending questions to keeper") || normalized.startsWith("execution settings") || normalized.startsWith("instructions") || normalized.startsWith("based on the current state") || normalized.startsWith("important: you must call at least one tool") || normalized.startsWith("respond only with a tool call") || normalized.startsWith("use bullet points.") || normalized.startsWith("write a single sentence.") || normalized.startsWith("start with a short upper case reaction") || normalized.startsWith("use numbered steps showing what the agent did in order") || normalized.startsWith("summarize in one sentence, then ask a pointed rhetorical question") || normalized.startsWith("use a compact markdown table with columns") || normalized.startsWith("use bullet points with emoji tags") || normalized.startsWith("use a scoreboard format with these labels") || normalized.startsWith("example:") || normalized.startsWith("session: ") || normalized.startsWith("actions (") || normalized.startsWith("previous commentary") || normalized.startsWith("summarize only this session") || normalized.startsWith("never mention ids/logs/prompts/traces") || normalized.startsWith(`never say "i", "i'll", "we"`)) return true;
+  if (normalized.includes("only key nouns") || normalized.includes("fixed the login page") || normalized.includes("edited auth middleware") || normalized.includes("max 2 per commentary") || normalized.includes("don't repeat what previous commentary already said")) return true;
+  if (normalized.startsWith("cwd:") || normalized.startsWith("shell:")) return true;
+  if (normalized.startsWith("your identity") || normalized.startsWith("room id:") || normalized.startsWith("worker id:")) return true;
+  if (normalized.startsWith("you are codex, a coding agent")) return true;
+  return false;
+}
+function looksLikeSessionIdentifier(text) {
+  if (/^[0-9a-f]{8}$/.test(text)) return true;
+  if (/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/.test(text)) return true;
+  if (/^session[\s:_-]*[0-9a-f]{8,}$/.test(text)) return true;
+  if (/^turn[\s:_-]*[0-9a-f]{8,}$/.test(text)) return true;
+  if (/^rollout-\d{4}-\d{2}-\d{2}t\d{2}[-:]\d{2}[-:]\d{2}[-a-z0-9]+(?:\.jsonl)?$/.test(text)) return true;
+  return false;
+}
+function extractProjectName(dirName) {
+  const parts = dirName.split("-").filter(Boolean);
+  return parts[parts.length - 1] || "unknown";
+}
+function codexSessionDirs(daysBack) {
+  const home = os.homedir();
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  const now = /* @__PURE__ */ new Date();
+  const totalDays = Math.max(1, daysBack);
+  for (let offset = 0; offset < totalDays; offset++) {
+    const d = new Date(now);
+    d.setDate(now.getDate() - offset);
+    const dir = path.join(
+      home,
+      ".codex",
+      "sessions",
+      String(d.getFullYear()),
+      String(d.getMonth() + 1).padStart(2, "0"),
+      String(d.getDate()).padStart(2, "0")
+    );
+    if (seen.has(dir)) continue;
+    seen.add(dir);
+    results.push(dir);
+  }
+  return results;
+}
+function fallbackSessionTitle(projectName, agent) {
+  const project = (projectName || "").trim();
+  if (project) return project;
+  return `${agent} session`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SessionWatcher
+});