@kibitzsh/kibitz 0.0.3

package/dist/cli/index.js

@@ -0,0 +1,2662 @@
+#!/usr/bin/env node
+"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 __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
+));
+
+// src/cli/index.ts
+var readline = __toESM(require("readline"));
+
+// src/core/watcher.ts
+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 basename3 = String(filePath || "").split(/[\\/]+/).filter(Boolean).pop()?.replace(/\.jsonl$/i, "") || "";
+  const match = basename3.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] : basename3;
+}
+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 basename3 = path.basename(filePath, ".jsonl");
+  if (agent !== "codex") return basename3;
+  const match = basename3.match(/([0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12})/i);
+  return match ? match[1].toLowerCase() : basename3.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`;
+}
+
+// src/core/commentary.ts
+var import_events2 = require("events");
+
+// src/core/types.ts
+var COMMENTARY_STYLE_OPTIONS = [
+  { id: "bullets", label: "Bullet list" },
+  { id: "one-liner", label: "One-liner" },
+  { id: "headline-context", label: "Headline + context" },
+  { id: "numbered-progress", label: "Numbered progress" },
+  { id: "short-question", label: "Short + question" },
+  { id: "table", label: "Table" },
+  { id: "emoji-bullets", label: "Emoji bullets" },
+  { id: "scoreboard", label: "Scoreboard" }
+];
+var MODELS = [
+  { id: "claude-opus-4-6", label: "Claude Opus", provider: "anthropic" },
+  { id: "claude-sonnet-4-6", label: "Claude Sonnet", provider: "anthropic" },
+  { id: "claude-haiku-4-5-20251001", label: "Claude Haiku", provider: "anthropic" },
+  { id: "gpt-4o", label: "GPT-4o", provider: "openai" },
+  { id: "gpt-4o-mini", label: "GPT-4o mini", provider: "openai" }
+];
+var DEFAULT_MODEL = "claude-opus-4-6";
+
+// src/core/providers/anthropic.ts
+var import_child_process = require("child_process");
+var import_fs = require("fs");
+var import_path = require("path");
+var import_os = require("os");
+var cachedClaudePath = null;
+var PROVIDER_TIMEOUT_MS = 9e4;
+function resolveNodeScript(cmdPath) {
+  if (process.platform !== "win32" || !cmdPath.endsWith(".cmd")) return null;
+  try {
+    const content = (0, import_fs.readFileSync)(cmdPath, "utf-8");
+    const match = content.match(/%dp0%\\(.+?\.js)/);
+    if (match) {
+      const script = (0, import_path.join)((0, import_path.dirname)(cmdPath), match[1]);
+      if ((0, import_fs.existsSync)(script)) return script;
+    }
+  } catch {
+  }
+  return null;
+}
+function resolveClaudePath() {
+  if (cachedClaudePath) return cachedClaudePath;
+  const home = (0, import_os.homedir)();
+  const isWindows = process.platform === "win32";
+  const candidates = isWindows ? [
+    (0, import_path.join)(home, ".claude", "bin", "claude.exe"),
+    (0, import_path.join)(home, "AppData", "Local", "Programs", "claude-code", "claude.exe"),
+    (0, import_path.join)(home, "AppData", "Local", "Claude", "claude.exe"),
+    (0, import_path.join)(home, "AppData", "Local", "Microsoft", "WinGet", "Links", "claude.exe"),
+    "C:\\Program Files\\Claude\\claude.exe",
+    (0, import_path.join)(home, "AppData", "Roaming", "npm", "claude.cmd")
+  ] : [
+    (0, import_path.join)(home, ".local", "bin", "claude"),
+    (0, import_path.join)(home, ".claude", "bin", "claude"),
+    "/usr/local/bin/claude",
+    "/usr/bin/claude",
+    "/snap/bin/claude",
+    "/opt/homebrew/bin/claude"
+  ];
+  for (const p of candidates) {
+    if ((0, import_fs.existsSync)(p)) {
+      cachedClaudePath = p;
+      return p;
+    }
+  }
+  const env = { ...process.env };
+  delete env.ELECTRON_RUN_AS_NODE;
+  delete env.CLAUDECODE;
+  if (isWindows) {
+    try {
+      const resolved = (0, import_child_process.execSync)("where claude", {
+        encoding: "utf-8",
+        env,
+        timeout: 5e3
+      }).trim().split("\n")[0].trim();
+      if (resolved && (0, import_fs.existsSync)(resolved)) {
+        cachedClaudePath = resolved;
+        return resolved;
+      }
+    } catch {
+    }
+  } else {
+    const shells = ["/bin/zsh", "/bin/bash"];
+    for (const sh of shells) {
+      if (!(0, import_fs.existsSync)(sh)) continue;
+      try {
+        const resolved = (0, import_child_process.execSync)(`${sh} -lic 'which claude'`, {
+          encoding: "utf-8",
+          env,
+          timeout: 5e3
+        }).trim();
+        if (resolved && (0, import_fs.existsSync)(resolved)) {
+          cachedClaudePath = resolved;
+          return resolved;
+        }
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+var AnthropicProvider = class {
+  async generate(systemPrompt, userPrompt, _apiKey, model, onChunk) {
+    return new Promise((resolve, reject) => {
+      const claudePath = resolveClaudePath();
+      if (!claudePath) {
+        reject(new Error("Claude CLI not found. Install from https://docs.anthropic.com/en/docs/claude-code"));
+        return;
+      }
+      const fullPrompt = `${systemPrompt}
+
+${userPrompt}`;
+      const args = [
+        "-p",
+        fullPrompt,
+        "--output-format",
+        "stream-json",
+        "--verbose",
+        "--max-turns",
+        "1",
+        "--model",
+        model
+      ];
+      const env = { ...process.env };
+      delete env.ELECTRON_RUN_AS_NODE;
+      delete env.CLAUDECODE;
+      let proc;
+      try {
+        const nodeScript = resolveNodeScript(claudePath);
+        if (nodeScript) {
+          proc = (0, import_child_process.spawn)(process.execPath, [nodeScript, ...args], {
+            cwd: (0, import_os.homedir)(),
+            env,
+            stdio: ["ignore", "pipe", "pipe"],
+            windowsHide: true
+          });
+        } else {
+          proc = (0, import_child_process.spawn)(claudePath, args, {
+            cwd: (0, import_os.homedir)(),
+            env,
+            stdio: ["ignore", "pipe", "pipe"],
+            windowsHide: true,
+            shell: process.platform === "win32"
+          });
+        }
+      } catch (err) {
+        reject(new Error(`Failed to spawn claude CLI: ${err instanceof Error ? err.message : String(err)}`));
+        return;
+      }
+      if (!proc.stdout || !proc.stderr) {
+        reject(new Error("Failed to create stdio pipes for Claude CLI"));
+        try {
+          proc.kill();
+        } catch {
+        }
+        return;
+      }
+      let full = "";
+      let buffer = "";
+      let stderr = "";
+      let timedOut = false;
+      proc.stdout.on("data", (data) => {
+        buffer += data.toString();
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const event = JSON.parse(line);
+            if (event.type === "assistant") {
+              const content = event.message?.content;
+              if (Array.isArray(content)) {
+                for (const block of content) {
+                  if (block.type === "text" && typeof block.text === "string") {
+                    full += block.text;
+                    onChunk(block.text);
+                  }
+                }
+              }
+            }
+            if (event.type === "result" && event.result) {
+              if (!full) {
+                full = String(event.result);
+                onChunk(full);
+              }
+            }
+          } catch {
+          }
+        }
+      });
+      proc.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+      const timeout = setTimeout(() => {
+        timedOut = true;
+        try {
+          proc.kill();
+        } catch {
+        }
+      }, PROVIDER_TIMEOUT_MS);
+      proc.on("close", (code) => {
+        clearTimeout(timeout);
+        if (timedOut && !full) {
+          reject(new Error(`Claude CLI timed out after ${PROVIDER_TIMEOUT_MS}ms`));
+          return;
+        }
+        if (code !== 0 && !full) {
+          reject(new Error(`Claude CLI exited with code ${code}: ${stderr.slice(0, 500)}`));
+        } else {
+          resolve(full);
+        }
+      });
+      proc.on("error", (err) => {
+        clearTimeout(timeout);
+        reject(new Error(`Claude CLI error: ${err.message}`));
+      });
+    });
+  }
+};
+
+// src/core/providers/openai.ts
+var import_child_process2 = require("child_process");
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+var import_os2 = require("os");
+var cachedCodexScript = null;
+var codexScriptResolved = false;
+var PROVIDER_TIMEOUT_MS2 = 9e4;
+function resolveCodexNodeScript() {
+  if (codexScriptResolved) return cachedCodexScript;
+  codexScriptResolved = true;
+  if (process.platform !== "win32") return null;
+  try {
+    const cmdPath = (0, import_child_process2.execSync)("where codex.cmd", {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim().split("\n")[0].trim();
+    const content = (0, import_fs2.readFileSync)(cmdPath, "utf-8");
+    const match = content.match(/%dp0%\\(.+?\.js)/);
+    if (!match) return null;
+    const script = (0, import_path2.join)((0, import_path2.dirname)(cmdPath), match[1]);
+    if ((0, import_fs2.existsSync)(script)) {
+      cachedCodexScript = script;
+      return script;
+    }
+  } catch {
+  }
+  return null;
+}
+var OpenAIProvider = class {
+  async generate(systemPrompt, userPrompt, _apiKey, _model, onChunk) {
+    return new Promise((resolve, reject) => {
+      const fullPrompt = `${systemPrompt}
+
+${userPrompt}`;
+      const args = ["exec", "--json", "--skip-git-repo-check", fullPrompt];
+      let proc;
+      try {
+        const nodeScript = resolveCodexNodeScript();
+        if (nodeScript) {
+          proc = (0, import_child_process2.spawn)(process.execPath, [nodeScript, ...args], {
+            cwd: (0, import_os2.homedir)(),
+            env: process.env,
+            stdio: ["ignore", "pipe", "pipe"],
+            windowsHide: true
+          });
+        } else {
+          const codexCmd = process.platform === "win32" ? "codex.cmd" : "codex";
+          proc = (0, import_child_process2.spawn)(codexCmd, args, {
+            cwd: (0, import_os2.homedir)(),
+            env: process.env,
+            stdio: ["ignore", "pipe", "pipe"],
+            windowsHide: true,
+            shell: process.platform === "win32"
+          });
+        }
+      } catch (err) {
+        reject(new Error(`Failed to spawn codex CLI: ${err instanceof Error ? err.message : String(err)}`));
+        return;
+      }
+      if (!proc.stdout || !proc.stderr) {
+        reject(new Error("Failed to create stdio pipes for codex CLI"));
+        try {
+          proc.kill();
+        } catch {
+        }
+        return;
+      }
+      let full = "";
+      let buffer = "";
+      let stderr = "";
+      let timedOut = false;
+      proc.stdout.on("data", (data) => {
+        buffer += data.toString();
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const event = JSON.parse(line);
+            if (event.type === "item.completed" && event.item) {
+              if (event.item.type === "agent_message" && typeof event.item.text === "string") {
+                full += event.item.text;
+                onChunk(event.item.text);
+              }
+            }
+          } catch {
+          }
+        }
+      });
+      proc.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+      const timeout = setTimeout(() => {
+        timedOut = true;
+        try {
+          proc.kill();
+        } catch {
+        }
+      }, PROVIDER_TIMEOUT_MS2);
+      proc.on("close", (code) => {
+        clearTimeout(timeout);
+        if (timedOut && !full) {
+          reject(new Error(`Codex CLI timed out after ${PROVIDER_TIMEOUT_MS2}ms`));
+          return;
+        }
+        if (code !== 0 && !full) {
+          reject(new Error(`Codex CLI exited with code ${code}: ${stderr.slice(0, 500)}`));
+        } else {
+          resolve(full);
+        }
+      });
+      proc.on("error", (err) => {
+        clearTimeout(timeout);
+        reject(new Error(`Codex CLI error: ${err.message}`));
+      });
+    });
+  }
+};
+
+// src/core/commentary.ts
+var SYSTEM_PROMPT = `You oversee AI coding agents. Summarize what they did in plain language anyone can understand.
+
+Rules:
+- Plain language. "Fixed the login page" not "Edited auth middleware".
+- **Bold** only key nouns, 1-2 words: **tests**, **deploy**, **production**. NEVER bold sentences.
+- UPPER CASE short reactions when it helps: GREAT FIND, NICE MOVE, RISK ALERT, SOLID CHECK, WATCH OUT.
+- Vary judgment wording across messages; avoid repeating one catchphrase.
+- Always judge execution direction using the session goal + concrete actions in this batch.
+- Close with a sentence that captures the current direction and momentum of the work.
+- Emoji are allowed when they add meaning (max 2 per commentary).
+- No filler. No "methodical", "surgical", "disciplined", "clean work". Facts and reactions only.
+- Don't repeat what previous commentary already said.
+- Never mention session IDs, logs, traces, prompts, JSONL files, or internal tooling.
+- Never write in first person ("I", "I'll", "we") or future tense plans.
+- Never use the word "verdict". Write narrative, not a ruling.`;
+var FORMAT_TEMPLATES = {
+  bullets: `Use bullet points. Each bullet = one thing done or one observation.
+Close with a sentence on direction and momentum.
+Example:
+- Researched how the feature works
+- Rewrote the page with new layout
+- Shipped without **tests** \u2014 RISKY
+- Checked for errors before pushing`,
+  "one-liner": `Write a single sentence. Punchy, complete, under 20 words.
+One closing sentence on where this is headed.
+Example: Agent investigated the bug, found the root cause, and fixed it \u2014 NICE WORK.
+Example: Still reading code after 30 actions \u2014 hasn't changed anything yet.`,
+  "headline-context": `Start with a short UPPER CASE reaction (2-4 words), then one sentence of context.
+Close with a read on momentum.
+Example:
+SOLID APPROACH. Agent read the dependencies first, then made targeted changes across three files.
+Example:
+NOT GREAT. Pushed to **production** without running any tests \u2014 hope nothing breaks.`,
+  "numbered-progress": `Use numbered steps showing what the agent did in order. Finish with a momentum line.
+Example:
+1. Read the existing code
+2. Made changes to the login flow
+3. Tested locally
+4. Pushed to **production**
+Proper process, nothing to flag.`,
+  "short-question": `Summarize in one sentence, then ask a pointed rhetorical question.
+End with a one-sentence read on direction.
+Example:
+Agent rewrote the entire settings page and shipped it immediately. Did they test this at all?
+Example:
+Third time reading the same code. Lost, or just being thorough?`,
+  table: `Use a compact markdown table with columns: Action | Why it mattered.
+Include 3-5 rows max, then one sentence on momentum.
+Example:
+| Action | Why it mattered |
+| --- | --- |
+| Ran tests | Verified changes before shipping |
+| Skipped lint | Could hide style regressions |
+Mostly careful, one loose end.`,
+  "emoji-bullets": `Use bullet points with emoji tags to signal risk/quality.
+Use only these tags: \u2705, \u26A0\uFE0F, \u{1F525}, \u2744\uFE0F.
+Close with a direction sentence.
+Example:
+- \u2705 Fixed the failing migration script
+- \u26A0\uFE0F Pushed without rerunning integration tests
+- \u{1F525} Found the root cause in auth token parsing`,
+  scoreboard: `Use a scoreboard format with these labels:
+Wins:
+Risks:
+Next:
+Each label should have 1-3 short bullets, then one line on where things stand.`
+};
+var DEFAULT_FORMAT_STYLE_IDS = COMMENTARY_STYLE_OPTIONS.map((option) => option.id);
+var PRESET_INSTRUCTIONS = {
+  auto: "",
+  "critical-coder": "Be a VERY CRITICAL coder using code terminology. Call out architectural or process flaws directly and sharply.",
+  "precise-short": "Be precise and short. Keep the output compact and information-dense with minimal words.",
+  emotional: "Be emotional and expressive. React strongly to good or risky behavior while staying factual.",
+  newbie: "Explain for non-developers. Avoid jargon or explain it in plain words with simple cause/effect."
+};
+function normalizeFormatStyles(styleIds) {
+  const requested = new Set(styleIds.map((styleId) => String(styleId || "").trim()));
+  const normalized = COMMENTARY_STYLE_OPTIONS.map((option) => option.id).filter((styleId) => requested.has(styleId));
+  return normalized.length > 0 ? normalized : DEFAULT_FORMAT_STYLE_IDS.slice();
+}
+function sameFormatStyles(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i += 1) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+var SESSION_ID_PATTERNS = [
+  /\b[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}\b/gi,
+  /\brollout-\d{4}-\d{2}-\d{2}t\d{2}[-:]\d{2}[-:]\d{2}[-a-z0-9]+(?:\.jsonl)?\b/gi,
+  /\bsession[\s:_-]*[0-9a-f]{8,}\b/gi,
+  /\bturn[\s:_-]*[0-9a-f]{8,}\b/gi
+];
+var MIN_BATCH_SIZE = 1;
+var MAX_BATCH_SIZE = 40;
+var IDLE_TIMEOUT_MS = 5e3;
+var MAX_WAIT_MS = 15e3;
+var TEST_COMMAND_PATTERNS = [
+  /\b(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:test|test:[\w:-]+)\b/i,
+  /\b(?:jest|vitest|mocha|ava|pytest|go\s+test|cargo\s+test|dotnet\s+test|mvn\s+test|gradle(?:w)?\s+test|rspec|phpunit)\b/i
+];
+var DEPLOY_COMMAND_PATTERNS = [
+  /\b(?:deploy|release|publish)\b/i,
+  /\b(?:kubectl\s+apply|helm\s+upgrade|terraform\s+apply|serverless\s+deploy|vercel\s+--prod|netlify\s+deploy|fly\s+deploy)\b/i
+];
+var ERROR_SIGNAL_PATTERN = /\b(?:error|failed|failure|exception|traceback|panic|denied|timeout|cannot|can't|unable)\b/i;
+var SECURITY_COMMAND_RULES = [
+  {
+    severity: "high",
+    signal: "Remote script piped directly into a shell",
+    pattern: /\b(?:curl|wget)\b[^\n|]{0,300}\|\s*(?:bash|sh|zsh|pwsh|powershell)\b/i
+  },
+  {
+    severity: "high",
+    signal: "TLS verification explicitly disabled",
+    pattern: /\bNODE_TLS_REJECT_UNAUTHORIZED\s*=\s*0\b/i
+  },
+  {
+    severity: "high",
+    signal: "Destructive root-level delete command",
+    pattern: /\brm\s+-rf\s+\/(?:\s|$)/i
+  },
+  {
+    severity: "medium",
+    signal: "Insecure transport flag used in command",
+    pattern: /\bcurl\b[^\n]*\s(?:--insecure|-k)\b/i
+  },
+  {
+    severity: "medium",
+    signal: "Git hooks bypassed with --no-verify",
+    pattern: /\bgit\b[^\n]*\s--no-verify\b/i
+  },
+  {
+    severity: "medium",
+    signal: "SSH host key verification disabled",
+    pattern: /\bStrictHostKeyChecking\s*=\s*no\b/i
+  },
+  {
+    severity: "medium",
+    signal: "Overly broad file permissions (chmod 777)",
+    pattern: /\bchmod\s+777\b/i
+  },
+  {
+    severity: "medium",
+    signal: "Potential secret exposed in command arguments",
+    pattern: /\b(?:api[_-]?key|token|password)\s*=\s*\S+/i
+  }
+];
+var SECURITY_PATH_RULES = [
+  {
+    severity: "medium",
+    signal: "Secret-related file touched",
+    pattern: /(?:^|[\\/])(?:\.env(?:\.[^\\/]+)?|id_rsa|id_dsa|authorized_keys|known_hosts|credentials?|secrets?)(?:$|[\\/])/i
+  },
+  {
+    severity: "medium",
+    signal: "Sensitive key/cert file touched",
+    pattern: /\.(?:pem|key|p12|pfx)$/i
+  }
+];
+var JUDGMENT_PHRASES = [
+  "NOT IDEAL",
+  "NOT GREAT",
+  "WATCH OUT",
+  "RISK ALERT",
+  "GREAT FIND",
+  "NICE MOVE",
+  "SOLID CHECK"
+];
+function getDetailValue(details, ...keys) {
+  for (const key of keys) {
+    const value = details[key];
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return "";
+}
+function extractCommand(event) {
+  if (event.type !== "tool_call") return "";
+  const details = event.details || {};
+  const input = typeof details.input === "object" && details.input ? details.input : {};
+  const direct = getDetailValue(details, "command", "cmd");
+  if (direct) return direct;
+  return getDetailValue(input, "command", "cmd");
+}
+function extractTouchedPath(event) {
+  if (event.type !== "tool_call") return "";
+  const details = event.details || {};
+  const input = typeof details.input === "object" && details.input ? details.input : {};
+  const direct = getDetailValue(details, "path", "file_path");
+  if (direct) return direct;
+  return getDetailValue(input, "path", "file_path");
+}
+function extractToolName(event) {
+  const details = event.details || {};
+  const value = details.tool;
+  return typeof value === "string" ? value.toLowerCase() : "";
+}
+function pushUnique(list, value, maxItems = 4) {
+  const normalized = sanitizePromptText(value);
+  if (!normalized) return;
+  if (list.includes(normalized)) return;
+  if (list.length < maxItems) list.push(normalized);
+}
+function pushSecurityFinding(findings, finding) {
+  const key = `${finding.severity}:${finding.signal}:${finding.evidence}`;
+  const exists = findings.some((item) => `${item.severity}:${item.signal}:${item.evidence}` === key);
+  if (!exists) findings.push(finding);
+}
+function detectSecurityFindings(findings, sourceText, rules) {
+  const evidence = sanitizePromptText(sourceText).slice(0, 140);
+  if (!evidence) return;
+  for (const rule of rules) {
+    if (!rule.pattern.test(sourceText)) continue;
+    pushSecurityFinding(findings, {
+      severity: rule.severity,
+      signal: rule.signal,
+      evidence
+    });
+  }
+}
+function hasPattern(text, patterns) {
+  return patterns.some((pattern) => pattern.test(text));
+}
+function summarizeActivity(reads, writes, searches, commands, tests, errors) {
+  return `reads=${reads}, writes=${writes}, searches=${searches}, commands=${commands}, tests=${tests}, errors=${errors}`;
+}
+function summarizeClosingEvidence(assessment) {
+  if (assessment.progressSignals.length > 0) return assessment.progressSignals[0];
+  if (assessment.driftSignals.length > 0) return assessment.driftSignals[0];
+  return assessment.activitySummary;
+}
+function createClosingLine(assessment) {
+  const evidence = summarizeClosingEvidence(assessment);
+  const dir = assessment.direction === "on-track" ? "on track" : assessment.direction;
+  const sec = assessment.security !== "clean" ? ` Security is ${assessment.security}.` : "";
+  return `${evidence} \u2014 looks ${dir} with ${assessment.confidence} confidence.${sec}`;
+}
+function extractRecentlyUsedJudgments(recentCommentary) {
+  const found = /* @__PURE__ */ new Set();
+  for (const text of recentCommentary.slice(-5)) {
+    const upper = String(text || "").toUpperCase();
+    for (const phrase of JUDGMENT_PHRASES) {
+      if (upper.includes(phrase)) found.add(phrase);
+    }
+  }
+  return Array.from(found).slice(0, 4);
+}
+function buildCommentaryAssessment(events, sessionTitle) {
+  let reads = 0;
+  let writes = 0;
+  let searches = 0;
+  let commands = 0;
+  let tests = 0;
+  let deploys = 0;
+  let errors = 0;
+  const touchedFiles = [];
+  const progressSignals = [];
+  const driftSignals = [];
+  const securityFindings = [];
+  for (const event of events) {
+    const summary = sanitizePromptText(event.summary);
+    const summaryLower = summary.toLowerCase();
+    const toolName = extractToolName(event);
+    const command = extractCommand(event);
+    const touchedPath = extractTouchedPath(event);
+    if (event.type === "tool_call") {
+      if (summaryLower.startsWith("reading ") || toolName.includes("read")) reads += 1;
+      if (summaryLower.startsWith("writing ") || summaryLower.startsWith("editing ") || toolName.includes("write") || toolName.includes("edit") || toolName.includes("apply_diff")) {
+        writes += 1;
+      }
+      if (summaryLower.startsWith("searching ") || summaryLower.startsWith("finding files") || toolName.includes("grep") || toolName.includes("glob")) {
+        searches += 1;
+      }
+      if (command) {
+        commands += 1;
+        if (hasPattern(command, TEST_COMMAND_PATTERNS)) tests += 1;
+        if (hasPattern(command, DEPLOY_COMMAND_PATTERNS)) deploys += 1;
+        detectSecurityFindings(securityFindings, command, SECURITY_COMMAND_RULES);
+      }
+      if (touchedPath) {
+        pushUnique(touchedFiles, touchedPath, 3);
+        detectSecurityFindings(securityFindings, touchedPath, SECURITY_PATH_RULES);
+      }
+    }
+    const output = typeof event.details?.output === "string" ? event.details.output : "";
+    const combinedText = `${summary}
+${output}`;
+    if ((event.type === "message" || event.type === "tool_result") && ERROR_SIGNAL_PATTERN.test(combinedText)) {
+      errors += 1;
+    }
+  }
+  if (writes > 0) pushUnique(progressSignals, `${writes} write/edit actions executed`);
+  if (tests > 0) pushUnique(progressSignals, `${tests} test commands detected`);
+  if (deploys > 0) pushUnique(progressSignals, `${deploys} deploy/release commands detected`);
+  if (touchedFiles.length > 0) pushUnique(progressSignals, `touched files: ${touchedFiles.join(", ")}`);
+  if (reads >= 4 && writes === 0) pushUnique(driftSignals, `${reads} reads with no code edits`);
+  if (commands >= 6 && writes === 0 && tests === 0) {
+    pushUnique(driftSignals, `${commands} commands executed without visible code/test progress`);
+  }
+  if (errors >= 2) pushUnique(driftSignals, `${errors} error/failure signals seen in outputs`);
+  if (deploys > 0 && tests === 0) pushUnique(driftSignals, "deploy/release command seen without test evidence");
+  if (progressSignals.length === 0 && events.length >= 3) {
+    pushUnique(driftSignals, "no concrete progress signal captured in this batch");
+  }
+  let direction = "on-track";
+  if (errors >= 3 && writes === 0 && tests === 0) {
+    direction = "blocked";
+  } else if (driftSignals.length > 0 && writes === 0 && tests === 0) {
+    direction = "drifting";
+  } else if (progressSignals.length === 0) {
+    direction = "drifting";
+  }
+  const evidenceScore = writes + tests + deploys + (errors > 0 ? 1 : 0);
+  const confidence = events.length >= 8 || evidenceScore >= 3 ? "high" : events.length >= 4 || evidenceScore >= 1 ? "medium" : "low";
+  const security = securityFindings.some((finding) => finding.severity === "high") ? "alert" : securityFindings.length > 0 ? "watch" : "clean";
+  if (sessionTitle) {
+    pushUnique(progressSignals, `session goal/title: ${sessionTitle}`, 5);
+  }
+  return {
+    direction,
+    confidence,
+    security,
+    activitySummary: summarizeActivity(reads, writes, searches, commands, tests, errors),
+    progressSignals,
+    driftSignals,
+    securityFindings: securityFindings.slice(0, 3)
+  };
+}
+function applyAssessmentSignals(commentary, assessment) {
+  let out = String(commentary || "").trim();
+  if (!out) {
+    out = "Agent completed actions in this session.";
+  }
+  const hasSecuritySignal = /\bsecurity\b|\bsecurity alert\b|\bsecurity watch\b/i.test(out);
+  if (!hasSecuritySignal && assessment.security !== "clean") {
+    const top = assessment.securityFindings[0];
+    const label = assessment.security === "alert" ? "SECURITY ALERT" : "SECURITY WATCH";
+    const reason = top ? `${top.signal} (${top.evidence})` : "Risky behavior detected in this batch.";
+    out = `${label}: ${reason}
+${out}`;
+  }
+  const hasClosingLine = /\bverdict\b|\bon.?track\b|\bdrifting\b|\bblocked\b|\bmomentum\b/i.test(out);
+  if (!hasClosingLine) {
+    out = `${out}
+${createClosingLine(assessment)}`;
+  }
+  return out;
+}
+var CommentaryEngine = class extends import_events2.EventEmitter {
+  sessions = /* @__PURE__ */ new Map();
+  flushQueue = [];
+  queuedSessions = /* @__PURE__ */ new Set();
+  generating = false;
+  model = DEFAULT_MODEL;
+  userFocus = "";
+  preset = "auto";
+  providers = {
+    anthropic: new AnthropicProvider(),
+    openai: new OpenAIProvider()
+  };
+  keyResolver;
+  paused = false;
+  enabledFormatStyleIds = DEFAULT_FORMAT_STYLE_IDS.slice();
+  lastFormatStyleId = null;
+  constructor(keyResolver) {
+    super();
+    this.keyResolver = keyResolver;
+  }
+  setModel(model) {
+    this.model = model;
+    this.emit("model-changed", model);
+  }
+  getModel() {
+    return this.model;
+  }
+  setFocus(focus) {
+    this.userFocus = focus;
+  }
+  getFocus() {
+    return this.userFocus;
+  }
+  setPreset(preset) {
+    const next = Object.prototype.hasOwnProperty.call(PRESET_INSTRUCTIONS, preset) ? preset : "auto";
+    this.preset = next;
+    this.emit("preset-changed", this.preset);
+  }
+  getPreset() {
+    return this.preset;
+  }
+  setFormatStyles(styleIds) {
+    const next = normalizeFormatStyles(Array.isArray(styleIds) ? styleIds : []);
+    if (sameFormatStyles(next, this.enabledFormatStyleIds)) return;
+    this.enabledFormatStyleIds = next;
+    if (this.lastFormatStyleId && !this.enabledFormatStyleIds.includes(this.lastFormatStyleId)) {
+      this.lastFormatStyleId = null;
+    }
+    this.emit("format-styles-changed", this.enabledFormatStyleIds.slice());
+  }
+  getFormatStyles() {
+    return this.enabledFormatStyleIds.slice();
+  }
+  pause() {
+    this.paused = true;
+  }
+  resume() {
+    this.paused = false;
+  }
+  isPaused() {
+    return this.paused;
+  }
+  addEvent(event) {
+    if (this.paused) return;
+    if (event.type === "tool_result" || event.type === "meta") return;
+    const key = this.sessionKey(event);
+    const state = this.ensureSessionState(key);
+    state.events.push(event);
+    if (state.events.length >= MAX_BATCH_SIZE) {
+      this.requestFlush(key, true);
+      return;
+    }
+    if (state.idleTimer) clearTimeout(state.idleTimer);
+    state.idleTimer = setTimeout(() => this.requestFlush(key, false), IDLE_TIMEOUT_MS);
+    if (!state.maxTimer) {
+      state.maxTimer = setTimeout(() => this.requestFlush(key, true), MAX_WAIT_MS);
+    }
+  }
+  sessionKey(event) {
+    return `${event.agent}:${event.sessionId}`;
+  }
+  ensureSessionState(key) {
+    if (!this.sessions.has(key)) {
+      this.sessions.set(key, {
+        events: [],
+        idleTimer: null,
+        maxTimer: null,
+        recentCommentary: []
+      });
+    }
+    return this.sessions.get(key);
+  }
+  clearSessionTimers(state) {
+    if (state.idleTimer) {
+      clearTimeout(state.idleTimer);
+      state.idleTimer = null;
+    }
+    if (state.maxTimer) {
+      clearTimeout(state.maxTimer);
+      state.maxTimer = null;
+    }
+  }
+  requestFlush(key, force) {
+    const state = this.sessions.get(key);
+    if (!state) return;
+    this.clearSessionTimers(state);
+    if (state.events.length === 0) return;
+    if (!force && state.events.length < MIN_BATCH_SIZE) {
+      state.idleTimer = setTimeout(() => this.requestFlush(key, true), IDLE_TIMEOUT_MS);
+      return;
+    }
+    this.enqueueFlush(key);
+  }
+  enqueueFlush(key) {
+    if (this.queuedSessions.has(key)) return;
+    this.queuedSessions.add(key);
+    this.flushQueue.push(key);
+    this.processFlushQueue();
+  }
+  async processFlushQueue() {
+    if (this.generating) return;
+    while (this.flushQueue.length > 0) {
+      const key = this.flushQueue.shift();
+      this.queuedSessions.delete(key);
+      const state = this.sessions.get(key);
+      if (!state || state.events.length === 0) continue;
+      const batch = state.events.splice(0);
+      this.generating = true;
+      try {
+        await this.generateCommentary(batch, state);
+      } catch (err) {
+        this.emit("error", err);
+      } finally {
+        this.generating = false;
+      }
+      if (state.events.length > 0) {
+        if (state.events.length >= MIN_BATCH_SIZE) {
+          this.enqueueFlush(key);
+        } else if (!state.idleTimer) {
+          state.idleTimer = setTimeout(() => this.requestFlush(key, true), IDLE_TIMEOUT_MS);
+        }
+      }
+    }
+  }
+  pickFormat() {
+    const enabled = this.enabledFormatStyleIds.length > 0 ? this.enabledFormatStyleIds : DEFAULT_FORMAT_STYLE_IDS;
+    const pool = this.lastFormatStyleId && enabled.length > 1 ? enabled.filter((styleId) => styleId !== this.lastFormatStyleId) : enabled;
+    const pickedStyleId = pool[Math.floor(Math.random() * pool.length)];
+    this.lastFormatStyleId = pickedStyleId;
+    return FORMAT_TEMPLATES[pickedStyleId];
+  }
+  async generateCommentary(events, state) {
+    if (events.length === 0) return;
+    const modelConfig = MODELS.find((m) => m.id === this.model);
+    if (!modelConfig) {
+      this.emit("error", new Error(`Unknown model: ${this.model}`));
+      return;
+    }
+    const apiKey = "";
+    const systemPrompt = this.buildSystemPrompt();
+    const latest = events[events.length - 1];
+    const assessment = buildCommentaryAssessment(events, latest.sessionTitle);
+    const userPrompt = this.buildUserPrompt(events, state.recentCommentary, assessment);
+    const provider = this.providers[modelConfig.provider];
+    const entry = {
+      timestamp: Date.now(),
+      sessionId: latest.sessionId,
+      projectName: latest.projectName,
+      sessionTitle: latest.sessionTitle,
+      agent: latest.agent,
+      source: latest.source,
+      eventSummary: events.map((e) => sanitizePromptText(e.summary)).join(" \u2192 "),
+      commentary: ""
+    };
+    this.emit("commentary-start", entry);
+    try {
+      let streamedRaw = "";
+      const full = await provider.generate(
+        systemPrompt,
+        userPrompt,
+        apiKey || "",
+        this.model,
+        (chunk) => {
+          streamedRaw += chunk;
+        }
+      );
+      const rawOutput = full || streamedRaw;
+      entry.commentary = applyAssessmentSignals(
+        sanitizeGeneratedCommentary(rawOutput),
+        assessment
+      );
+      if (entry.commentary) {
+        this.emit("commentary-chunk", { entry, chunk: entry.commentary });
+      }
+      this.emit("commentary-done", entry);
+      state.recentCommentary.push(entry.commentary);
+      if (state.recentCommentary.length > 5) {
+        state.recentCommentary.shift();
+      }
+    } catch (err) {
+      entry.commentary = "Commentary unavailable right now.";
+      this.emit("commentary-chunk", { entry, chunk: entry.commentary });
+      this.emit("commentary-done", entry);
+      this.emit("error", err);
+    }
+  }
+  buildSystemPrompt() {
+    let prompt = SYSTEM_PROMPT;
+    prompt += `
+
+Format for this message:
+${this.pickFormat()}`;
+    if (this.preset !== "auto") {
+      prompt += `
+
+Tone preset:
+${PRESET_INSTRUCTIONS[this.preset]}`;
+    }
+    if (this.userFocus.trim()) {
+      prompt += `
+
+Additional user instruction: ${this.userFocus}`;
+    }
+    return prompt;
+  }
+  buildUserPrompt(events, recentCommentary, assessment) {
+    const latest = events[events.length - 1];
+    const lines = events.map((e) => `  ${e.type}: ${sanitizePromptText(e.summary)}`);
+    let prompt = `Session: ${latest.agent}/${latest.projectName}
+`;
+    if (latest.sessionTitle) {
+      prompt += `Session title: ${sanitizePromptText(latest.sessionTitle)}
+`;
+    }
+    prompt += `Actions (${events.length}):
+${lines.join("\n")}`;
+    prompt += `
+
+Direction context:
+`;
+    prompt += `- Activity snapshot: ${assessment.activitySummary}
+`;
+    if (assessment.progressSignals.length > 0) {
+      prompt += `- Progress signals: ${assessment.progressSignals.join(" | ")}
+`;
+    }
+    if (assessment.driftSignals.length > 0) {
+      prompt += `- Drift/block signals: ${assessment.driftSignals.join(" | ")}
+`;
+    }
+    prompt += `- Initial direction estimate from raw signals: ${assessment.direction} (${assessment.confidence} confidence)
+`;
+    prompt += `
+Security auto-check:
+`;
+    prompt += `- Security state: ${assessment.security}
+`;
+    if (assessment.securityFindings.length > 0) {
+      prompt += assessment.securityFindings.map((finding) => `- ${finding.severity.toUpperCase()}: ${finding.signal} (${finding.evidence})`).join("\n");
+      prompt += "\n";
+    } else {
+      prompt += `- No explicit security flags in this batch.
+`;
+    }
+    if (recentCommentary.length > 0) {
+      prompt += `
+
+Previous commentary (don't repeat):
+`;
+      prompt += recentCommentary.slice(-3).map((c2) => `- ${sanitizePromptText(c2).slice(0, 80)}...`).join("\n");
+      prompt += `
+Use different judgment wording than these previous lines.`;
+    }
+    const recentlyUsed = extractRecentlyUsedJudgments(recentCommentary);
+    if (recentlyUsed.length > 0) {
+      prompt += `
+Avoid reusing these reaction phrases: ${recentlyUsed.join(", ")}.`;
+    }
+    prompt += `
+
+Summarize only this session's actions. Plain language, with your reaction.`;
+    prompt += `
+Close with one sentence about direction and momentum \u2014 weave in confidence and security naturally.`;
+    prompt += `
+Never mention IDs/logs/prompts/traces or internal data-collection steps.`;
+    prompt += `
+Never say "I", "I'll", "we", or any future plan.`;
+    return prompt;
+  }
+};
+function redactSessionIdentifiers(text) {
+  let out = text;
+  for (const pattern of SESSION_ID_PATTERNS) {
+    out = out.replace(pattern, "[session]");
+  }
+  return out;
+}
+function sanitizePromptText(text) {
+  return redactSessionIdentifiers(String(text || "")).replace(/\s+/g, " ").trim();
+}
+function sanitizeGeneratedCommentary(text) {
+  let out = redactSessionIdentifiers(String(text || ""));
+  out = out.replace(/\blocal session logs?\b/gi, "recent actions");
+  out = out.replace(/\bsession logs?\b/gi, "actions");
+  out = out.replace(/\bsession id\b/gi, "session");
+  out = out.replace(/\bverdict\s*:\s*/gi, "");
+  const blockedLine = /\b(i['’]?ll|i will|we(?:'ll| will)?)\b.*\b(pull|fetch|read|inspect|scan|parse|load|check)\b.*\b(session|log|trace|jsonl|prompt|history)\b/i;
+  const keptLines = out.split("\n").filter((line) => !blockedLine.test(line.trim()));
+  out = keptLines.join("\n").trim();
+  if (!out) {
+    return "Agent completed actions in this session.";
+  }
+  return out;
+}
+
+// src/core/platform-support.ts
+var import_child_process3 = require("child_process");
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+function getProviderCliCommand(provider, platform = process.platform) {
+  return platform === "win32" ? `${provider}.cmd` : provider;
+}
+function resolveCmdNodeScript(cmdPath) {
+  if (!String(cmdPath || "").toLowerCase().endsWith(".cmd")) return null;
+  try {
+    const content = fs2.readFileSync(cmdPath, "utf8");
+    const match = content.match(/%dp0%\\(.+?\.js)/i);
+    if (!match) return null;
+    const scriptPath = path2.join(path2.dirname(cmdPath), match[1]);
+    return fs2.existsSync(scriptPath) ? scriptPath : null;
+  } catch {
+    return null;
+  }
+}
+function inheritShellPath(platform = process.platform) {
+  if (platform === "darwin") {
+    inheritDarwinPath();
+    return;
+  }
+  if (platform === "win32") {
+    inheritNpmPrefixPath("win32");
+    return;
+  }
+  inheritNpmPrefixPath("linux");
+}
+function findCommandPath(command, platform = process.platform) {
+  try {
+    if (platform === "win32") {
+      const out2 = (0, import_child_process3.execSync)(`where ${command}`, {
+        encoding: "utf8",
+        timeout: 5e3,
+        stdio: ["ignore", "pipe", "ignore"]
+      }).trim();
+      const first = out2.split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+      return first || void 0;
+    }
+    const out = (0, import_child_process3.execFileSync)("which", [command], {
+      encoding: "utf8",
+      timeout: 5e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return out || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function inheritDarwinPath() {
+  const currentPath = process.env.PATH || "";
+  const parts = new Set(currentPath.split(path2.delimiter).filter(Boolean));
+  const candidateShells = [process.env.SHELL, "/bin/zsh", "/bin/bash"].map((value) => String(value || "").trim()).filter(Boolean).filter((value, index, arr) => arr.indexOf(value) === index);
+  for (const shell of candidateShells) {
+    if (!fs2.existsSync(shell)) continue;
+    try {
+      const shellPath = (0, import_child_process3.execFileSync)(shell, ["-lic", "echo $PATH"], {
+        encoding: "utf8",
+        timeout: 5e3,
+        stdio: ["ignore", "pipe", "ignore"]
+      }).trim();
+      if (!shellPath) continue;
+      process.env.PATH = mergePath(currentPath, shellPath, parts);
+      return;
+    } catch {
+    }
+  }
+}
+function inheritNpmPrefixPath(platform) {
+  const npmCommand = platform === "win32" ? "npm.cmd" : "npm";
+  try {
+    const npmPrefix = (0, import_child_process3.execFileSync)(npmCommand, ["prefix", "-g"], {
+      encoding: "utf8",
+      timeout: 5e3,
+      stdio: ["ignore", "pipe", "ignore"],
+      shell: platform === "win32"
+    }).trim();
+    if (!npmPrefix) return;
+    const candidates = platform === "win32" ? [npmPrefix, path2.join(npmPrefix, "node_modules", ".bin")] : [path2.join(npmPrefix, "bin")];
+    let nextPath = process.env.PATH || "";
+    const parts = new Set(nextPath.split(path2.delimiter).filter(Boolean));
+    for (const candidate of candidates) {
+      if (!candidate || parts.has(candidate)) continue;
+      nextPath = nextPath ? `${candidate}${path2.delimiter}${nextPath}` : candidate;
+      parts.add(candidate);
+    }
+    process.env.PATH = nextPath;
+  } catch {
+  }
+}
+function mergePath(currentPath, shellPath, knownParts) {
+  const additions = [];
+  for (const candidate of shellPath.split(path2.delimiter).filter(Boolean)) {
+    if (knownParts.has(candidate)) continue;
+    knownParts.add(candidate);
+    additions.push(candidate);
+  }
+  if (additions.length === 0) return currentPath;
+  return currentPath ? `${currentPath}${path2.delimiter}${additions.join(path2.delimiter)}` : additions.join(path2.delimiter);
+}
+
+// src/core/session-dispatch.ts
+var import_events3 = require("events");
+var import_child_process4 = require("child_process");
+var fs3 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
+var SessionDispatchService = class extends import_events3.EventEmitter {
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  async dispatch(request) {
+    const prompt = String(request.prompt || "").trim();
+    if (!prompt) {
+      this.emitStatus("failed", request.target, "Prompt cannot be empty");
+      return;
+    }
+    this.emitStatus("queued", request.target, `Queued for ${describeTarget(request.target)}`);
+    if (request.target.kind === "existing") {
+      await this.dispatchExistingSession(request.target, prompt);
+      return;
+    }
+    const provider = request.target.kind === "new-codex" ? "codex" : "claude";
+    this.emitStatus("started", request.target, `Starting new ${provider} session`);
+    try {
+      if (request.origin === "vscode") {
+        if (!this.options.launchInteractiveSession) {
+          throw new Error("Interactive launcher is not available in VS Code mode");
+        }
+        await this.options.launchInteractiveSession(provider, prompt);
+      } else {
+        await runInteractiveInTerminal(provider, prompt);
+      }
+      this.emitStatus("sent", request.target, `Started new ${provider} session`);
+    } catch (error) {
+      this.emitStatus("failed", request.target, normalizeError(error));
+    }
+  }
+  async dispatchExistingSession(target, prompt) {
+    const targetSessionId = String(target.sessionId || "").trim().toLowerCase();
+    const targetAgent = target.agent;
+    if (!targetSessionId || targetAgent !== "claude" && targetAgent !== "codex") {
+      this.emitStatus("failed", target, "Missing target session or provider");
+      return;
+    }
+    const active = this.options.getActiveSessions();
+    const activeMatch = active.find((session) => {
+      return session.agent === targetAgent && session.id.toLowerCase() === targetSessionId;
+    });
+    if (!activeMatch) {
+      this.emitStatus("failed", target, `Selected ${describeProvider(targetAgent)} session is not active`);
+      return;
+    }
+    const targetLabel = describeTarget(target);
+    this.emitStatus("started", target, `Dispatching to ${targetLabel}`);
+    try {
+      const command = buildExistingDispatchCommand(target, prompt);
+      const dispatchCwd = deriveDispatchCwdForSession(activeMatch);
+      const beforeDispatch = captureSessionFileSnapshot(activeMatch.filePath);
+      const handle = await startBackgroundCommand(command, { cwd: dispatchCwd });
+      const dispatchOutcome = await runWithTimeout(
+        waitForDispatchAcknowledgement(
+          activeMatch.filePath,
+          prompt,
+          beforeDispatch,
+          handle.completion
+        ),
+        2e4,
+        "Dispatch timed out waiting for target session update"
+      );
+      if (dispatchOutcome === "process-complete") {
+        verifyExistingDispatchDelivery(activeMatch.filePath, prompt, beforeDispatch);
+      }
+      void handle.completion.catch(() => void 0);
+      this.emitStatus("sent", target, `Prompt sent to ${targetLabel}`);
+    } catch (error) {
+      this.emitStatus("failed", target, normalizeError(error));
+    }
+  }
+  emitStatus(state, target, message) {
+    const status = {
+      state,
+      message,
+      target,
+      timestamp: Date.now()
+    };
+    this.emit("status", status);
+  }
+};
+function buildExistingDispatchCommand(target, prompt, platform = process.platform) {
+  if (target.kind !== "existing") {
+    throw new Error(`Expected existing target, got "${target.kind}"`);
+  }
+  const sessionId = String(target.sessionId || "").trim();
+  const agent = target.agent;
+  if (!sessionId || agent !== "claude" && agent !== "codex") {
+    throw new Error("Missing existing-session target details");
+  }
+  if (agent === "codex") {
+    return {
+      provider: "codex",
+      command: getProviderCliCommand("codex", platform),
+      args: ["exec", "resume", "--json", "--skip-git-repo-check", sessionId, prompt]
+    };
+  }
+  return {
+    provider: "claude",
+    command: getProviderCliCommand("claude", platform),
+    args: ["-p", prompt, "--verbose", "--output-format", "stream-json", "--resume", sessionId]
+  };
+}
+function buildInteractiveDispatchCommand(provider, prompt, platform = process.platform) {
+  return {
+    provider,
+    command: getProviderCliCommand(provider, platform),
+    args: [prompt]
+  };
+}
+function resolveDispatchCommand(command, platform = process.platform) {
+  const pathHint = findCommandPath(command.command, platform);
+  if (!pathHint) {
+    throw new Error(`CLI not found: ${command.command}`);
+  }
+  if (platform === "win32") {
+    const nodeScript = resolveCmdNodeScript(pathHint);
+    if (nodeScript) {
+      return {
+        command: process.execPath,
+        args: [nodeScript, ...command.args],
+        shell: false
+      };
+    }
+    if (pathHint.toLowerCase().endsWith(".cmd")) {
+      return {
+        command: pathHint,
+        args: command.args,
+        shell: true
+      };
+    }
+  }
+  return {
+    command: pathHint,
+    args: command.args,
+    shell: false
+  };
+}
+async function waitForDispatchAcknowledgement(filePath, prompt, before, completion) {
+  let completionState = 0;
+  let completionError = null;
+  completion.then(() => {
+    completionState = 1;
+  }).catch((error) => {
+    completionState = 2;
+    completionError = error instanceof Error ? error : new Error(String(error || "Dispatch failed"));
+  });
+  while (true) {
+    if (completionState === 2) {
+      throw completionError || new Error("Dispatch failed");
+    }
+    if (hasSessionUpdateWithPrompt(filePath, prompt, before)) {
+      return "prompt-observed";
+    }
+    if (completionState === 1) {
+      return "process-complete";
+    }
+    await sleepMs(120);
+  }
+}
+async function startBackgroundCommand(command, options = {}) {
+  const resolved = resolveDispatchCommand(command);
+  return await new Promise((resolve, reject) => {
+    const child = (0, import_child_process4.spawn)(resolved.command, resolved.args, {
+      stdio: ["ignore", "ignore", "pipe"],
+      shell: resolved.shell,
+      windowsHide: true,
+      ...options.cwd ? { cwd: options.cwd } : {}
+    });
+    let stderr = "";
+    let spawned = false;
+    let launchSettled = false;
+    const failLaunch = (error) => {
+      if (launchSettled) return;
+      launchSettled = true;
+      reject(error);
+    };
+    const completion = new Promise((resolveCompletion, rejectCompletion) => {
+      child.on("error", (error) => {
+        if (!spawned) {
+          failLaunch(error);
+          return;
+        }
+        rejectCompletion(error);
+      });
+      child.on("close", (code) => {
+        if (code === 0) {
+          resolveCompletion();
+          return;
+        }
+        const normalized = String(stderr || "").trim();
+        if (looksLikeUnsupportedFlags(normalized)) {
+          rejectCompletion(new Error("Provider CLI does not support required resume flags. Update the CLI version."));
+          return;
+        }
+        rejectCompletion(new Error(normalized || `Dispatch exited with code ${code}`));
+      });
+    });
+    child.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("spawn", () => {
+      spawned = true;
+      if (launchSettled) return;
+      launchSettled = true;
+      resolve({ completion });
+    });
+  });
+}
+async function runInteractiveInTerminal(provider, prompt) {
+  const command = buildInteractiveDispatchCommand(provider, prompt);
+  const resolved = resolveDispatchCommand(command);
+  await new Promise((resolve, reject) => {
+    const child = (0, import_child_process4.spawn)(resolved.command, resolved.args, {
+      stdio: "inherit",
+      shell: resolved.shell,
+      windowsHide: false
+    });
+    child.on("error", (error) => reject(error));
+    child.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`Interactive session exited with code ${code}`));
+    });
+  });
+}
+function describeTarget(target) {
+  if (target.kind === "new-codex") return "new codex session";
+  if (target.kind === "new-claude") return "new claude session";
+  const provider = describeProvider(target.agent);
+  const project = cleanTargetLabel(target.projectName, 24);
+  const sessionTitle = cleanTargetLabel(target.sessionTitle, 44);
+  if (project && sessionTitle) return `${provider} session (${project} \u203A ${sessionTitle})`;
+  if (sessionTitle) return `${provider} session (${sessionTitle})`;
+  if (project) return `${provider} session (${project})`;
+  return `${provider} session`;
+}
+function describeProvider(agent) {
+  return String(agent || "").toLowerCase() === "claude" ? "Claude" : "Codex";
+}
+function cleanTargetLabel(value, max) {
+  const text = String(value || "").replace(/\s+/g, " ").trim();
+  if (!text) return "";
+  if (/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i.test(text)) return "";
+  if (text.length <= max) return text;
+  if (max <= 3) return text.slice(0, max);
+  return `${text.slice(0, max - 3).trimEnd()}...`;
+}
+function looksLikeUnsupportedFlags(stderr) {
+  const normalized = String(stderr || "").toLowerCase();
+  if (!normalized) return false;
+  return normalized.includes("unknown option") || normalized.includes("unknown flag") || normalized.includes("unrecognized option") || normalized.includes("did you mean");
+}
+function normalizeError(error) {
+  if (error instanceof Error && error.message) return error.message;
+  return String(error || "Dispatch failed");
+}
+function captureSessionFileSnapshot(filePath) {
+  try {
+    const stat = fs3.statSync(filePath);
+    return {
+      exists: true,
+      size: stat.size,
+      mtimeMs: stat.mtimeMs
+    };
+  } catch {
+    return {
+      exists: false,
+      size: 0,
+      mtimeMs: 0
+    };
+  }
+}
+function verifyExistingDispatchDelivery(filePath, prompt, before) {
+  if (!hasSessionFileChanged(filePath, before)) {
+    throw new Error("Target session did not update after dispatch");
+  }
+  const promptSignature = firstPromptSignature(prompt);
+  if (promptSignature.length < 4) return;
+  const tail = readSessionTailSinceOffset(filePath, before.size);
+  if (!tail) {
+    throw new Error("Target session updated but prompt text was not found");
+  }
+  if (!tail.toLowerCase().includes(promptSignature.toLowerCase())) {
+    throw new Error("Prompt text was not found in target session update");
+  }
+}
+function hasSessionUpdateWithPrompt(filePath, prompt, before) {
+  if (!hasSessionFileChanged(filePath, before)) return false;
+  const promptSignature = firstPromptSignature(prompt);
+  if (promptSignature.length < 4) return true;
+  const tail = readSessionTailSinceOffset(filePath, before.size);
+  if (!tail) return false;
+  return tail.toLowerCase().includes(promptSignature.toLowerCase());
+}
+function hasSessionFileChanged(filePath, before) {
+  const after = captureSessionFileSnapshot(filePath);
+  if (!after.exists) {
+    throw new Error("Target session file is not accessible after dispatch");
+  }
+  return after.size > before.size || after.mtimeMs > before.mtimeMs;
+}
+function firstPromptSignature(prompt) {
+  const lines = String(prompt || "").split(/\r?\n/g).map((line) => line.trim()).filter(Boolean);
+  const first = lines[0] || String(prompt || "").trim();
+  return first.slice(0, 160);
+}
+function readSessionTailSinceOffset(filePath, previousSize) {
+  try {
+    const stat = fs3.statSync(filePath);
+    const maxBytes = 1024 * 512;
+    const start = Math.max(0, previousSize - 2048);
+    const desiredStart = stat.size - start > maxBytes ? Math.max(0, stat.size - maxBytes) : start;
+    const length = Math.max(0, stat.size - desiredStart);
+    if (length === 0) return "";
+    const fd = fs3.openSync(filePath, "r");
+    try {
+      const buf = Buffer.alloc(length);
+      fs3.readSync(fd, buf, 0, length, desiredStart);
+      return buf.toString("utf8");
+    } finally {
+      fs3.closeSync(fd);
+    }
+  } catch {
+    return "";
+  }
+}
+async function runWithTimeout(promise, timeoutMs, message) {
+  return await new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+    promise.then((value) => {
+      clearTimeout(timer);
+      resolve(value);
+    }).catch((error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+  });
+}
+async function sleepMs(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+function deriveDispatchCwdForSession(session) {
+  if (session.agent !== "claude") return void 0;
+  return decodeClaudeProjectPathFromSessionFile(session.filePath);
+}
+function decodeClaudeProjectPathFromSessionFile(filePath) {
+  if (!filePath) return void 0;
+  const projectDir = path3.basename(path3.dirname(filePath));
+  if (!projectDir) return void 0;
+  const parts = projectDir.split("-").filter(Boolean);
+  if (parts.length === 0) return void 0;
+  if (parts.length >= 2 && /^[A-Za-z]$/.test(parts[0])) {
+    const windowsPath = `${parts[0]}:\\${parts.slice(1).join("\\")}`;
+    if (fs3.existsSync(windowsPath)) return windowsPath;
+  }
+  const unixPath = `/${parts.join("/")}`;
+  if (fs3.existsSync(unixPath)) return unixPath;
+  return void 0;
+}
+
+// src/cli/index.ts
+var c = {
+  bold: (s) => `\x1B[1m${s}\x1B[0m`,
+  dim: (s) => `\x1B[2m${s}\x1B[0m`,
+  red: (s) => `\x1B[31m${s}\x1B[0m`,
+  green: (s) => `\x1B[32m${s}\x1B[0m`,
+  yellow: (s) => `\x1B[33m${s}\x1B[0m`,
+  cyan: (s) => `\x1B[36m${s}\x1B[0m`
+};
+var noopKeyResolver = {
+  async getKey(_provider) {
+    return "subscription";
+  }
+};
+function parseArgs(args) {
+  let model = DEFAULT_MODEL;
+  let focus = "";
+  let agent = null;
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (arg === "--model" && args[index + 1]) {
+      const value = args[++index];
+      const found = MODELS.find((entry) => {
+        return entry.id === value || entry.label.toLowerCase().includes(value.toLowerCase());
+      });
+      if (found) model = found.id;
+      continue;
+    }
+    if (arg === "--focus" && args[index + 1]) {
+      focus = args[++index];
+      continue;
+    }
+    if (arg === "--agent" && args[index + 1]) {
+      agent = args[++index];
+      continue;
+    }
+    if (arg === "--help" || arg === "-h") {
+      printHelp();
+      process.exit(0);
+    }
+  }
+  return { model, focus, agent };
+}
+function printHelp() {
+  console.log(`
+${c.bold("KIBITZ")} \u2014 Live commentary + cross-session dispatch
+
+${c.bold("Usage:")}
+  kibitz [options]
+
+${c.bold("Options:")}
+  --model <name>   Commentary model (opus, sonnet, haiku, gpt-4o, gpt-4o-mini)
+  --focus <text>   Focus instructions for commentary
+  --agent <name>   Filter events by agent (claude, codex)
+  --help, -h       Show this help
+
+${c.bold("Slash commands:")}
+  /help
+  /pause
+  /resume
+  /focus <text>
+  /model <id-or-label>
+  /preset <id>
+  /sessions
+  /target <index|agent:sessionId|new-codex|new-claude>
+
+${c.bold("Composer behavior:")}
+  Plain text sends prompt to selected target.
+`);
+}
+function timeStr() {
+  return (/* @__PURE__ */ new Date()).toLocaleTimeString([], {
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  });
+}
+function formatCommentary(text) {
+  return String(text || "").replace(/\*\*(.+?)\*\*/g, (_, inner) => c.bold(inner)).replace(/`([^`]+)`/g, (_, code) => c.cyan(code)).replace(/^[-*] /gm, "  \u2022 ");
+}
+function agentColor(agent) {
+  return agent === "claude" ? c.yellow : c.green;
+}
+function visibleSessionName(session) {
+  const title = String(session.sessionTitle || "").trim();
+  if (title) return title;
+  const project = String(session.projectName || "").trim();
+  if (project) return project;
+  return `${session.agent} session`;
+}
+function normalizeTarget(target) {
+  if (target.kind === "new-claude") return { kind: "new-claude" };
+  if (target.kind === "new-codex") return { kind: "new-codex" };
+  return {
+    kind: "existing",
+    agent: target.agent,
+    sessionId: String(target.sessionId || "").trim().toLowerCase(),
+    projectName: target.projectName,
+    sessionTitle: target.sessionTitle
+  };
+}
+function parseTargetArg(rawArg, sessions) {
+  const raw = String(rawArg || "").trim();
+  if (!raw) return null;
+  if (raw === "new-codex") return { kind: "new-codex" };
+  if (raw === "new-claude") return { kind: "new-claude" };
+  if (/^\d+$/.test(raw)) {
+    const index = Number(raw);
+    if (index < 1 || index > sessions.length) return null;
+    const session = sessions[index - 1];
+    return {
+      kind: "existing",
+      agent: session.agent,
+      sessionId: String(session.id || "").trim().toLowerCase(),
+      projectName: session.projectName,
+      sessionTitle: session.sessionTitle
+    };
+  }
+  const match = raw.match(/^(claude|codex):(.+)$/i);
+  if (!match) return null;
+  const agent = match[1].toLowerCase();
+  const sessionId = String(match[2] || "").trim().toLowerCase();
+  if (!sessionId) return null;
+  const found = sessions.find((session) => {
+    return session.agent === agent && String(session.id || "").trim().toLowerCase() === sessionId;
+  });
+  return {
+    kind: "existing",
+    agent,
+    sessionId,
+    projectName: found?.projectName,
+    sessionTitle: found?.sessionTitle
+  };
+}
+function describeTarget2(target) {
+  if (target.kind === "new-codex") return "new-codex";
+  if (target.kind === "new-claude") return "new-claude";
+  return `${target.agent || "unknown"}:${target.sessionId || "unknown"}`;
+}
+async function main() {
+  inheritShellPath();
+  const options = parseArgs(process.argv.slice(2));
+  console.log(c.bold("\n  KIBITZ") + c.dim(" \u2014 Live AI commentary + session dispatch\n"));
+  console.log(c.dim(`  Model: ${options.model}`));
+  if (options.focus) console.log(c.dim(`  Focus: ${options.focus}`));
+  if (options.agent) console.log(c.dim(`  Agent filter: ${options.agent}`));
+  console.log(c.dim("  Watching for sessions... type /help for commands.\n"));
+  const watcher = new SessionWatcher();
+  const engine = new CommentaryEngine(noopKeyResolver);
+  const dispatch = new SessionDispatchService({
+    getActiveSessions: () => watcher.getActiveSessions()
+  });
+  engine.setModel(options.model);
+  if (options.focus) engine.setFocus(options.focus);
+  let selectedTarget = { kind: "new-codex" };
+  function activeSessions() {
+    return watcher.getActiveSessions().filter((session) => {
+      return !options.agent || session.agent === options.agent;
+    });
+  }
+  function printSessions() {
+    const sessions = activeSessions();
+    if (sessions.length === 0) {
+      console.log(`  ${c.dim("No active sessions in watcher window.")}`);
+      return;
+    }
+    console.log(`  ${c.bold("Active sessions:")}`);
+    sessions.forEach((session, index) => {
+      const marker = selectedTarget.kind === "existing" && selectedTarget.agent === session.agent && String(selectedTarget.sessionId || "").toLowerCase() === String(session.id || "").toLowerCase() ? c.green("*") : " ";
+      const project = session.projectName ? ` project=${session.projectName}` : "";
+      const title = visibleSessionName(session);
+      console.log(`  ${marker} [${index + 1}] ${session.agent}:${session.id} ${title}${project}`);
+    });
+  }
+  function printPromptLine() {
+    const target = describeTarget2(selectedTarget);
+    rl.setPrompt(c.dim(`kibitz[${target}]> `));
+    rl.prompt();
+  }
+  watcher.on("event", (event) => {
+    if (options.agent && event.agent !== options.agent) return;
+    engine.addEvent(event);
+  });
+  engine.on("commentary-start", (entry) => {
+    const color = agentColor(entry.agent);
+    const badge = color(`${entry.agent}/${entry.projectName}`);
+    const source = c.dim(`(${entry.source})`);
+    console.log(`
+  ${c.dim(timeStr())} ${badge} ${source}`);
+    console.log(`  ${c.dim(entry.eventSummary)}`);
+    process.stdout.write("  ");
+  });
+  engine.on("commentary-chunk", ({ chunk }) => {
+    process.stdout.write(formatCommentary(chunk));
+  });
+  engine.on("commentary-done", () => {
+    console.log("\n");
+    printPromptLine();
+  });
+  engine.on("error", (error) => {
+    console.log(`
+  ${c.red("Error:")} ${error.message}`);
+    printPromptLine();
+  });
+  dispatch.on("status", (status) => {
+    const label = status.state.toUpperCase();
+    const color = status.state === "failed" ? c.red : status.state === "sent" ? c.green : c.cyan;
+    console.log(`
+  ${color(label)} ${status.message}`);
+    printPromptLine();
+  });
+  watcher.start();
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true,
+    historySize: 1e3
+  });
+  async function handleSlash(raw) {
+    const body = raw.slice(1).trim();
+    const firstSpace = body.indexOf(" ");
+    const command = (firstSpace === -1 ? body : body.slice(0, firstSpace)).toLowerCase();
+    const args = firstSpace === -1 ? "" : body.slice(firstSpace + 1).trim();
+    if (command === "help") {
+      printHelp();
+      return;
+    }
+    if (command === "pause") {
+      engine.pause();
+      console.log(`  ${c.dim("Commentary paused")}`);
+      return;
+    }
+    if (command === "resume") {
+      engine.resume();
+      console.log(`  ${c.dim("Commentary resumed")}`);
+      return;
+    }
+    if (command === "focus") {
+      if (!args) {
+        console.log(`  ${c.red("Usage: /focus <text>")}`);
+        return;
+      }
+      engine.setFocus(args);
+      console.log(`  ${c.dim("Focus updated")}`);
+      return;
+    }
+    if (command === "model") {
+      if (!args) {
+        console.log(`  ${c.red("Usage: /model <id-or-label>")}`);
+        return;
+      }
+      const found = MODELS.find((model) => {
+        const needle = args.toLowerCase();
+        return model.id.toLowerCase() === needle || model.label.toLowerCase().includes(needle);
+      });
+      if (!found) {
+        console.log(`  ${c.red("Unknown model: " + args)}`);
+        return;
+      }
+      engine.setModel(found.id);
+      console.log(`  ${c.dim("Model set to " + found.label)}`);
+      return;
+    }
+    if (command === "preset") {
+      if (!args) {
+        console.log(`  ${c.red("Usage: /preset <auto|critical-coder|precise-short|emotional|newbie>")}`);
+        return;
+      }
+      engine.setPreset(args);
+      console.log(`  ${c.dim("Preset set to " + engine.getPreset())}`);
+      return;
+    }
+    if (command === "sessions") {
+      printSessions();
+      return;
+    }
+    if (command === "target") {
+      if (!args) {
+        console.log(`  ${c.red("Usage: /target <index|agent:sessionId|new-codex|new-claude>")}`);
+        return;
+      }
+      const next = parseTargetArg(args, activeSessions());
+      if (!next) {
+        console.log(`  ${c.red("Invalid target: " + args)}`);
+        return;
+      }
+      selectedTarget = normalizeTarget(next);
+      console.log(`  ${c.dim("Target set to " + describeTarget2(selectedTarget))}`);
+      return;
+    }
+    console.log(`  ${c.red("Unknown command: /" + command)}`);
+  }
+  rl.on("line", async (line) => {
+    const trimmed = String(line || "").trim();
+    if (!trimmed) {
+      printPromptLine();
+      return;
+    }
+    if (trimmed.startsWith("/")) {
+      await handleSlash(trimmed);
+      printPromptLine();
+      return;
+    }
+    const request = {
+      target: selectedTarget,
+      prompt: trimmed,
+      origin: "cli"
+    };
+    await dispatch.dispatch(request);
+    printPromptLine();
+  });
+  rl.on("close", () => {
+    watcher.stop();
+    console.log(c.dim("\n  Kibitz out."));
+    process.exit(0);
+  });
+  process.on("SIGINT", () => {
+    watcher.stop();
+    rl.close();
+  });
+  printPromptLine();
+}
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(c.red(`Fatal: ${message}`));
+  process.exit(1);
+});