agenter-app 0.0.0-stage → 1.0.0

package/server.js

@@ -0,0 +1,1434 @@
+#!/usr/bin/env node
+// Agenter server: receives Claude Code hook events from hook.js, keeps track of every
+// session, and lets the dashboard answer permission prompts, questions and replies.
+'use strict';
+const http = require('node:http');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const crypto = require('node:crypto');
+const { spawn, execFile } = require('node:child_process');
+const openDashboard = require('./lib/open-dashboard');
+
+const PORT = Number(process.env.AGENTER_PORT) || 4317;
+const HOST = '127.0.0.1';
+const PUBLIC_DIR = path.join(__dirname, 'public');
+// Kept in the home folder, not next to the code, so updating a global npm install doesn't wipe them.
+const SETTINGS_DIR = path.join(os.homedir(), '.agenter');
+const SETTINGS_FILE = path.join(SETTINGS_DIR, 'settings.json');
+const OLD_SETTINGS_FILE = path.join(__dirname, 'agenter-settings.json');
+const PROJECTS_DIR = path.join(os.homedir(), '.claude', 'projects');
+const MAX_ACTIVITY = 200;
+// If the dashboard is closed this long, anything waiting goes back to VS Code.
+const DISCONNECT_GRACE_MS = 15000;
+// If you switch away from the dashboard (to VS Code, say) this long, same thing.
+const BLUR_GRACE_MS = 5000;
+const DISCOVER_INTERVAL_MS = 30000;
+const DISCOVER_FULL_SCAN_MS = 5 * 60 * 1000; // when a file watcher catches changes in between
+// Plan usage (5-hour session / weekly limits) comes from the same endpoint Claude
+// Code's /usage uses. It's undocumented, so treat it as best effort. AGENTER_USAGE=0 disables it.
+const CREDENTIALS_FILE = path.join(os.homedir(), '.claude', '.credentials.json');
+const USAGE_URL = 'https://api.anthropic.com/api/oauth/usage';
+const USAGE_INTERVAL_MS = 2 * 60 * 1000;
+
+const sessions = new Map(); // session_id -> session
+const pending = new Map(); // pending id -> { item, res, payload }
+const clients = new Map(); // SSE response -> { id, focused }
+const dismissed = new Set(); // session ids the user cleared; discovery won't bring them back
+
+// holdMinutes: anything waiting on the dashboard goes back to VS Code after this
+// long (0 = wait until answered), so a session never spins forever unnoticed.
+let settings = { holdOnStop: true, holdMinutes: 3 };
+try {
+  // Older versions kept settings next to server.js; carry them over the first time.
+  const file = fs.existsSync(SETTINGS_FILE) ? SETTINGS_FILE : OLD_SETTINGS_FILE;
+  settings = { ...settings, ...JSON.parse(fs.readFileSync(file, 'utf8')) };
+} catch {}
+const saveSettings = () => {
+  fs.mkdirSync(SETTINGS_DIR, { recursive: true });
+  fs.writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2));
+};
+
+// ---------- helpers ----------
+
+const truncate = (s, n) => {
+  s = String(s ?? '');
+  return s.length > n ? s.slice(0, n) + `\n… (${s.length - n} more chars)` : s;
+};
+
+function describeTool(name, input = {}) {
+  if (!input || typeof input !== 'object') return '';
+  if (input.command) return input.command;
+  if (name === 'AskUserQuestion' && Array.isArray(input.questions)) return input.questions.map((q) => q.question).join(' / ');
+  if (input.file_path) return input.file_path;
+  if (input.notebook_path) return input.notebook_path;
+  if (input.pattern) return input.pattern + (input.path ? `  in ${input.path}` : '');
+  if (input.url) return input.url;
+  if (input.query) return input.query;
+  if (input.description) return input.description;
+  if (input.prompt) return input.prompt;
+  return JSON.stringify(input);
+}
+
+function readTail(file, maxBytes) {
+  const fd = fs.openSync(file, 'r');
+  try {
+    const size = fs.fstatSync(fd).size;
+    const start = Math.max(0, size - maxBytes);
+    const buf = Buffer.alloc(size - start);
+    fs.readSync(fd, buf, 0, buf.length, start);
+    let text = buf.toString('utf8');
+    if (start > 0) text = text.slice(text.indexOf('\n') + 1); // drop the partial first line
+    return text;
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+const resultText = (content) =>
+  typeof content === 'string'
+    ? content
+    : Array.isArray(content)
+      ? content.map((c) => (c.type === 'text' ? c.text : `[${c.type}]`)).join('\n')
+      : '';
+
+const isNoise = (text) => /^\s*<(system-reminder|ide_|command-|local-command)/.test(text);
+
+// Appends the messages in these transcript lines to out (metadata and noise skipped).
+// Reads both Claude Code transcripts and Codex rollouts.
+function parseLines(text, out) {
+  for (const line of text.split('\n')) {
+    if (!line.trim()) continue;
+    let e;
+    try {
+      e = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (e.type === 'response_item') {
+      parseCodexItem(e, out);
+      continue;
+    }
+    if ((e.type !== 'user' && e.type !== 'assistant') || e.isMeta || !e.message) continue;
+    const ts = e.timestamp;
+    const content = e.message.content;
+    if (typeof content === 'string') {
+      if (!isNoise(content)) out.push({ role: e.type, kind: 'text', text: content, ts });
+      continue;
+    }
+    if (!Array.isArray(content)) continue;
+    for (const b of content) {
+      if (b.type === 'text' && b.text?.trim() && !isNoise(b.text)) out.push({ role: e.type, kind: 'text', text: b.text, ts });
+      else if (b.type === 'tool_use') out.push({ role: 'assistant', kind: 'tool', id: b.id, name: b.name, text: describeTool(b.name, b.input), ts });
+      else if (b.type === 'tool_result') out.push({ role: 'tool', kind: 'result', toolUseId: b.tool_use_id, text: resultText(b.content), isError: !!b.is_error, ts });
+    }
+  }
+  return out;
+}
+
+// Codex's exec tool takes a small script; the shell command inside it is what's worth showing.
+function describeCodexCall(name, input) {
+  const raw = String(input ?? '');
+  if (name === 'wait') return 'Waiting for the running command';
+  const m = raw.match(/\bcmd\s*:\s*(["'`])((?:\\.|(?!\1)[^\\])*)\1/);
+  if (m) return m[2].replace(/\\(.)/g, (_, c) => ({ n: '\n', t: '\t' })[c] ?? c);
+  // Other built-in tools called from the script: name them, plus the search query if any.
+  const call = raw.match(/\btools\.(\w+)\(/)?.[1];
+  if (call === 'write_stdin') return 'Sending input to the running command';
+  if (call) {
+    const q = raw.match(/\bq\s*:\s*(["'`])((?:\\.|(?!\1)[^\\])*)\1/)?.[2];
+    return call.replace(/__/g, ' ') + (q ? `: ${q}` : '');
+  }
+  try {
+    const args = JSON.parse(raw);
+    if (args && typeof args === 'object') return describeTool(name, args);
+  } catch {}
+  return raw.split('\n')[0];
+}
+
+const codexOutput = (o) => (typeof o === 'string' ? o : Array.isArray(o) ? o.map((c) => c.text ?? `[${c.type}]`).join('\n') : '');
+
+function parseCodexItem(e, out) {
+  const p = e.payload || {};
+  const ts = e.timestamp;
+  if (p.type === 'message' && (p.role === 'user' || p.role === 'assistant')) {
+    // Only what you typed: Codex also sends context (environment, open pages) as user messages.
+    const kinds = p.internal_chat_message_metadata_passthrough?.content_item_kinds;
+    (p.content || []).forEach((c, i) => {
+      const text = c.text?.trim();
+      if (!text) return;
+      if (p.role === 'user' && (kinds ? kinds[i] !== 'user.text' : text.startsWith('<'))) return;
+      // The VS Code extension wraps what you typed in IDE context (open tabs etc.).
+      const typed = p.role === 'user' ? c.text.match(/^#+ My request:\s*\n([\s\S]*)$/m)?.[1] : null;
+      out.push({ role: p.role, kind: 'text', text: typed?.trim() || c.text, ts });
+    });
+  } else if (p.type === 'function_call' || p.type === 'custom_tool_call') {
+    out.push({ role: 'assistant', kind: 'tool', id: p.call_id, name: p.name, text: describeCodexCall(p.name, p.arguments ?? p.input), ts });
+  } else if (p.type === 'function_call_output' || p.type === 'custom_tool_call_output') {
+    out.push({ role: 'tool', kind: 'result', toolUseId: p.call_id, text: codexOutput(p.output), isError: false, ts });
+  }
+}
+
+const clipMessage = (m) => ({ ...m, text: truncate(m.text, m.kind === 'result' ? 4000 : 20000) });
+
+function parseTranscript(file, limit = 120) {
+  if (!file || !fs.existsSync(file)) return [];
+  return parseLines(readTail(file, TRANSCRIPT_TAIL), []).slice(-limit).map(clipMessage);
+}
+
+// The conversation open on the dashboard is read incrementally: each request parses
+// only the bytes appended since the last one. Messages get increasing seq numbers so
+// the dashboard can ask for just the new ones; epoch changes if the file is replaced.
+const TRANSCRIPT_TAIL = 2 * 1024 * 1024;
+const TRANSCRIPT_KEEP = 400;
+const TRANSCRIPT_FILES = 8;
+const transcriptCache = new Map(); // file -> { epoch, offset, rest, dropFirstLine, seq, messages }
+
+function readTranscript(file) {
+  let size;
+  try {
+    size = fs.statSync(file).size;
+  } catch {
+    return null;
+  }
+  let c = transcriptCache.get(file);
+  if (!c || size < c.offset) {
+    const offset = Math.max(0, size - TRANSCRIPT_TAIL);
+    c = { epoch: crypto.randomUUID(), offset, rest: Buffer.alloc(0), dropFirstLine: offset > 0, seq: 0, messages: [] };
+  }
+  transcriptCache.delete(file); // most recently used goes last
+  transcriptCache.set(file, c);
+  if (transcriptCache.size > TRANSCRIPT_FILES) transcriptCache.delete(transcriptCache.keys().next().value);
+  if (size === c.offset) return c;
+
+  const fd = fs.openSync(file, 'r');
+  let buf;
+  try {
+    buf = Buffer.alloc(size - c.offset);
+    fs.readSync(fd, buf, 0, buf.length, c.offset);
+  } finally {
+    fs.closeSync(fd);
+  }
+  c.offset = size;
+  buf = Buffer.concat([c.rest, buf]);
+  let start = 0;
+  if (c.dropFirstLine) {
+    start = buf.indexOf(10) + 1; // we started mid-file: skip the partial first line
+    if (start) c.dropFirstLine = false;
+  }
+  // Only complete lines. Splitting on the newline byte never cuts a UTF-8 character.
+  const end = Math.max(start, buf.lastIndexOf(10) + 1);
+  c.rest = Buffer.from(buf.subarray(end));
+  for (const m of parseLines(buf.toString('utf8', start, end), [])) c.messages.push({ ...clipMessage(m), seq: ++c.seq });
+  if (c.messages.length > TRANSCRIPT_KEEP) c.messages.splice(0, c.messages.length - TRANSCRIPT_KEEP);
+  return c;
+}
+
+function lastAssistantText(file) {
+  const msgs = parseTranscript(file, 400);
+  for (let i = msgs.length - 1; i >= 0; i--) if (msgs[i].role === 'assistant' && msgs[i].kind === 'text') return msgs[i].text;
+  return '';
+}
+
+function readHead(file, maxBytes) {
+  const fd = fs.openSync(file, 'r');
+  try {
+    const buf = Buffer.alloc(Math.min(maxBytes, fs.fstatSync(fd).size));
+    fs.readSync(fd, buf, 0, buf.length, 0);
+    return buf.toString('utf8');
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+const firstText = (content) =>
+  typeof content === 'string' ? content : Array.isArray(content) ? content.find((b) => b.type === 'text' && !isNoise(b.text || ''))?.text || '' : '';
+
+// cwd and a title (Claude's summary, else the first prompt) from the start of a transcript.
+function transcriptInfo(file) {
+  let cwd = '';
+  let prompt = '';
+  let summary = '';
+  for (const line of readHead(file, 256 * 1024).split('\n')) {
+    let e;
+    try {
+      e = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!cwd && e.cwd) cwd = e.cwd;
+    if (e.type === 'summary' && e.summary && !summary) summary = e.summary;
+    if (!prompt && e.type === 'user' && !e.isMeta) {
+      const t = firstText(e.message?.content);
+      if (t && !isNoise(t)) prompt = t;
+    }
+    if (cwd && prompt) break;
+  }
+  return { cwd, title: (summary || prompt).split('\n')[0].slice(0, 140) };
+}
+
+// ---------- sessions ----------
+
+const newSession = (id) => ({ id, agent: 'claude', cwd: '', project: '', title: '', transcriptPath: '', status: 'idle', hold: null, startedAt: Date.now(), lastEventAt: 0, lastAction: '', permissionMode: '', activity: [], queue: [] });
+
+function getOrCreateSession(id) {
+  let s = sessions.get(id);
+  if (!s) {
+    s = newSession(id);
+    sessions.set(id, s);
+  }
+  return s;
+}
+
+function setCwd(s, cwd) {
+  if (!cwd || s.cwd) return;
+  s.cwd = cwd;
+  s.project = path.basename(cwd);
+}
+
+function touchSession(p) {
+  const id = p.session_id || 'unknown';
+  dismissed.delete(id);
+  const s = getOrCreateSession(id);
+  setCwd(s, p.cwd);
+  if (p.transcript_path) s.transcriptPath = p.transcript_path;
+  if (p.permission_mode) s.permissionMode = p.permission_mode;
+  if (s.status === 'dormant' || s.status === 'ended') s.status = 'idle';
+  s.lastEventAt = Date.now();
+  return s;
+}
+
+// Sessions you ran today that aren't talking to us (closed, or started before the
+// server/hooks were up) are found from their transcripts in ~/.claude/projects.
+// A watcher on ~/.claude/projects tells us which transcripts changed, so normally only
+// those are looked at. A full scan (async, so hooks are never kept waiting) runs at
+// startup and now and then as a safety net, or every 30s if watching isn't possible.
+const scanned = new Map(); // transcript file -> mtime when last read
+const isSessionTranscript = (f) => f.endsWith('.jsonl') && !path.basename(f).startsWith('agent-');
+
+// Returns true if it added or updated a session.
+async function checkTranscript(file) {
+  const id = path.basename(file, '.jsonl');
+  let mtime;
+  try {
+    mtime = (await fs.promises.stat(file)).mtimeMs;
+  } catch {
+    return false;
+  }
+  const since = new Date().setHours(0, 0, 0, 0);
+  if (mtime < since || dismissed.has(id) || scanned.get(file) === mtime) return false;
+  scanned.set(file, mtime);
+  try {
+    let s = sessions.get(id);
+    if (!s || !s.title || !s.cwd) {
+      const info = transcriptInfo(file);
+      if (!s && !info.title) return false; // opened but never used
+      // Agenter can continue a session it drives at any time, so it isn't "not connected".
+      s = s || Object.assign(getOrCreateSession(id), { status: driveOf({ id }) === 'agenter' ? 'idle' : 'dormant', startedAt: mtime });
+      setCwd(s, info.cwd);
+      if (!s.title) s.title = info.title;
+    }
+    if (!s.transcriptPath) s.transcriptPath = file;
+    if (s.status === 'dormant' || (driveOf(s) === 'agenter' && s.status === 'idle' && !runners.has(s.id))) {
+      s.lastEventAt = mtime;
+      s.lastAction = lastAssistantText(file).split('\n')[0].slice(0, 160);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+let scanning = false;
+async function discoverSessions() {
+  if (scanning) return;
+  scanning = true;
+  let changed = false;
+  try {
+    const dirs = (await fs.promises.readdir(PROJECTS_DIR, { withFileTypes: true })).filter((d) => d.isDirectory());
+    for (const d of dirs) {
+      const dir = path.join(PROJECTS_DIR, d.name);
+      let files = [];
+      try {
+        files = (await fs.promises.readdir(dir)).filter(isSessionTranscript);
+      } catch {
+        continue;
+      }
+      const results = await Promise.all(files.map((f) => checkTranscript(path.join(dir, f))));
+      changed = results.some(Boolean) || changed;
+    }
+  } catch {
+  } finally {
+    scanning = false;
+  }
+  if (changed) broadcast();
+}
+
+const changedFiles = new Set();
+let changedTimer = null;
+function onProjectsChange(_, name) {
+  // Only <project>/<session>.jsonl; subagent transcripts live deeper.
+  if (!name || name.split(/[\\/]/).length !== 2 || !isSessionTranscript(name)) return;
+  changedFiles.add(path.join(PROJECTS_DIR, name));
+  if (changedTimer) return;
+  changedTimer = setTimeout(async () => {
+    changedTimer = null;
+    const files = [...changedFiles];
+    changedFiles.clear();
+    if ((await Promise.all(files.map(checkTranscript))).some(Boolean)) broadcast();
+  }, 1000);
+}
+
+function startDiscovery() {
+  let watching = false;
+  try {
+    fs.watch(PROJECTS_DIR, { recursive: true }, onProjectsChange).on('error', () => {});
+    watching = true;
+  } catch {} // no projects folder yet, or recursive watching isn't supported here
+  discoverSessions();
+  setInterval(discoverSessions, watching ? DISCOVER_FULL_SCAN_MS : DISCOVER_INTERVAL_MS);
+}
+
+// ---------- plan usage ----------
+
+let usage = null; // { fetchedAt, plan, limits: [...], error }
+const LIMIT_LABELS = { session: '5-hour session', weekly_all: 'Weekly · all models', weekly_opus: 'Weekly · Opus', weekly_sonnet: 'Weekly · Sonnet' };
+
+function normalizeLimits(j) {
+  if (Array.isArray(j.limits) && j.limits.length) {
+    return j.limits
+      .filter((l) => typeof l.percent === 'number')
+      .map((l) => ({ kind: l.kind, label: LIMIT_LABELS[l.kind] || String(l.kind).replace(/_/g, ' '), percent: l.percent, severity: l.severity || null, resetsAt: l.resets_at || null }));
+  }
+  // Older response shape.
+  const pick = (key, kind) => j[key] && typeof j[key].utilization === 'number' && { kind, label: LIMIT_LABELS[kind], percent: j[key].utilization, severity: null, resetsAt: j[key].resets_at || null };
+  return [pick('five_hour', 'session'), pick('seven_day', 'weekly_all'), pick('seven_day_opus', 'weekly_opus'), pick('seven_day_sonnet', 'weekly_sonnet')].filter(Boolean);
+}
+
+// The usage endpoint is rate-limited per account (Claude Code's /usage calls it too).
+// After a 429 we wait before asking again, longer each time, instead of keeping the
+// limit tripped by retrying every couple of minutes.
+let usageBackoffUntil = 0;
+let usageBackoffMs = 0;
+
+let usageInFlight = false;
+async function fetchUsage({ force = false } = {}) {
+  if (process.env.AGENTER_USAGE === '0' || usageInFlight) return;
+  if (!force && Date.now() < usageBackoffUntil) return;
+  usageInFlight = true;
+  const keep = usage?.limits || [];
+  const fail = (error) => (usage = { ...usage, limits: keep, fetchedAt: Date.now(), error });
+  try {
+    let oauth;
+    try {
+      oauth = JSON.parse(fs.readFileSync(CREDENTIALS_FILE, 'utf8')).claudeAiOauth;
+    } catch {}
+    if (!oauth?.accessToken) return fail('Not signed in to Claude Code with a Claude subscription.');
+    // Never refresh the token ourselves (that would rotate it under Claude Code).
+    if (oauth.expiresAt && oauth.expiresAt < Date.now()) return fail('Login token expired. It renews the next time Claude runs.');
+    const r = await fetch(USAGE_URL, {
+      headers: { authorization: `Bearer ${oauth.accessToken}`, 'anthropic-beta': 'oauth-2025-04-20', 'content-type': 'application/json' },
+      signal: AbortSignal.timeout(10000),
+    });
+    if (r.status === 401 || r.status === 403) return fail('Login token was rejected. It renews the next time Claude runs.');
+    if (r.status === 429) {
+      const retryAfter = Number(r.headers.get('retry-after')) * 1000;
+      usageBackoffMs = Math.min(Math.max(usageBackoffMs * 2, 5 * 60000), 30 * 60000);
+      usageBackoffUntil = Date.now() + Math.max(retryAfter || 0, usageBackoffMs);
+      const at = new Date(usageBackoffUntil).toLocaleTimeString([], { hour: 'numeric', minute: '2-digit' });
+      return fail(`Anthropic is limiting how often usage can be checked. Trying again at ${at}.`);
+    }
+    if (!r.ok) return fail(`Usage service returned ${r.status}.`);
+    usageBackoffMs = 0;
+    usageBackoffUntil = 0;
+    usage = { fetchedAt: Date.now(), plan: oauth.subscriptionType || '', limits: normalizeLimits(await r.json()), error: null };
+  } catch {
+    fail("Couldn't reach Anthropic to check usage.");
+  } finally {
+    usageInFlight = false;
+    broadcast();
+  }
+}
+
+// ---------- Codex ----------
+// Codex sessions and plan usage, read from Codex's own session logs
+// (~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl). Read-only: nothing is sent anywhere,
+// and Codex's settings aren't touched. AGENTER_CODEX=0 turns it off.
+
+const CODEX_HOME = process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
+const CODEX_SESSIONS = path.join(CODEX_HOME, 'sessions');
+const CODEX_ENABLED = process.env.AGENTER_CODEX !== '0';
+// A turn whose log hasn't moved in this long was most likely cut off (Codex closed mid-turn).
+const CODEX_STALE_TURN_MS = 10 * 60 * 1000;
+// A Codex session written to this recently counts as live.
+const CODEX_LIVE_MS = 30 * 60 * 1000;
+
+const isRollout = (f) => /^rollout-.*\.jsonl$/.test(path.basename(f));
+
+let codexIndex = { mtime: 0, names: new Map() };
+function codexThreadName(id) {
+  const file = path.join(CODEX_HOME, 'session_index.jsonl');
+  try {
+    const mtime = fs.statSync(file).mtimeMs;
+    if (mtime !== codexIndex.mtime) {
+      const names = new Map();
+      for (const line of fs.readFileSync(file, 'utf8').split('\n')) {
+        try {
+          const e = JSON.parse(line);
+          if (e.id && e.thread_name) names.set(e.id, e.thread_name);
+        } catch {}
+      }
+      codexIndex = { mtime, names };
+    }
+  } catch {}
+  return codexIndex.names.get(id) || '';
+}
+
+// Session id, folder and first prompt from the start of a rollout. Subagent threads
+// (Codex's own reviewers and helpers) are skipped: they aren't conversations you had.
+function codexInfo(file) {
+  let meta = null;
+  let prompt = '';
+  for (const line of readHead(file, 256 * 1024).split('\n')) {
+    let e;
+    try {
+      e = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (e.type === 'session_meta') meta = e.payload;
+    else if (e.type === 'response_item' && !prompt) {
+      const msgs = [];
+      parseCodexItem(e, msgs);
+      prompt = msgs.find((m) => m.role === 'user')?.text || '';
+    }
+    if (meta && prompt) break;
+  }
+  if (!meta?.id || meta.source?.subagent || (meta.thread_source && meta.thread_source !== 'user')) return null;
+  return { id: meta.id, cwd: meta.cwd || '', title: (codexThreadName(meta.id) || prompt).split('\n')[0].slice(0, 140) };
+}
+
+// From the end of a rollout: whether a turn is in progress, what it's doing, and the
+// latest plan limits Codex recorded.
+function codexTail(file) {
+  let turnOpen = false;
+  let rateLimits = null;
+  let rateAt = 0;
+  const msgs = [];
+  for (const line of readTail(file, 512 * 1024).split('\n')) {
+    let e;
+    try {
+      e = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const t = e.payload?.type;
+    if (e.type === 'event_msg') {
+      if (t === 'task_started') turnOpen = true;
+      else if (t === 'task_complete' || t === 'turn_aborted') turnOpen = false;
+      else if (t === 'token_count' && e.payload.rate_limits) {
+        rateLimits = e.payload.rate_limits;
+        rateAt = Date.parse(e.timestamp) || 0;
+      }
+    } else if (e.type === 'response_item') parseCodexItem(e, msgs);
+  }
+  return { turnOpen, rateLimits, rateAt, last: msgs.at(-1) };
+}
+
+function codexStatus(s, now = Date.now()) {
+  if (runners.has(s.id) || (s.codexTurnOpen && now - s.lastEventAt < CODEX_STALE_TURN_MS)) return 'working';
+  // Agenter can continue a session it drives at any time.
+  if (driveOf(s) === 'agenter') return 'idle';
+  return now - s.lastEventAt < CODEX_LIVE_MS ? 'idle' : 'dormant';
+}
+
+// Returns true if it added or updated a session.
+async function checkRollout(file) {
+  let mtime;
+  try {
+    mtime = (await fs.promises.stat(file)).mtimeMs;
+  } catch {
+    return false;
+  }
+  const since = new Date().setHours(0, 0, 0, 0);
+  if (scanned.get(file) === mtime) return false;
+  scanned.set(file, mtime);
+  try {
+    const tail = codexTail(file);
+    if (tail.rateLimits) noteCodexLimits(tail.rateLimits, tail.rateAt);
+    if (mtime < since) return false;
+    const info = codexInfo(file);
+    if (!info || dismissed.has(info.id) || (!sessions.has(info.id) && !info.title)) return false;
+    const s = sessions.get(info.id) || Object.assign(getOrCreateSession(info.id), { agent: 'codex', startedAt: mtime });
+    setCwd(s, info.cwd);
+    if (info.title) s.title = info.title;
+    s.transcriptPath = file;
+    s.lastEventAt = mtime;
+    s.codexTurnOpen = tail.turnOpen;
+    s.status = codexStatus(s);
+    const last = tail.last;
+    s.lastAction =
+      s.status === 'working' && last?.kind === 'tool'
+        ? `${last.name}: ${last.text.split('\n')[0]}`.slice(0, 160)
+        : (lastAssistantText(file) || '').split('\n')[0].slice(0, 160);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Rollouts live in per-day folders. Yesterday's too: a session started before midnight
+// and still going today keeps writing to yesterday's folder.
+function codexDayDirs() {
+  const day = (d) => path.join(CODEX_SESSIONS, String(d.getFullYear()), String(d.getMonth() + 1).padStart(2, '0'), String(d.getDate()).padStart(2, '0'));
+  const today = new Date();
+  return [day(today), day(new Date(today.getTime() - 86400000))];
+}
+
+let codexScanning = false;
+async function discoverCodex() {
+  if (!CODEX_ENABLED || codexScanning) return;
+  codexScanning = true;
+  let changed = false;
+  try {
+    for (const dir of codexDayDirs()) {
+      let files = [];
+      try {
+        files = (await fs.promises.readdir(dir)).filter(isRollout);
+      } catch {
+        continue;
+      }
+      changed = (await Promise.all(files.map((f) => checkRollout(path.join(dir, f))))).some(Boolean) || changed;
+    }
+    // Plan usage even if you haven't used Codex today: the newest rollout anywhere has it.
+    if (!codexUsage) {
+      const newest = await newestRollout();
+      if (newest && !scanned.has(newest)) changed = (await checkRollout(newest)) || changed;
+    }
+    // Live/working wears off with time even when nothing is written.
+    for (const s of sessions.values()) {
+      if (s.agent !== 'codex') continue;
+      const status = codexStatus(s);
+      if (status !== s.status) {
+        s.status = status;
+        changed = true;
+      }
+    }
+  } finally {
+    codexScanning = false;
+  }
+  if (changed) broadcast();
+}
+
+async function newestRollout() {
+  // Walk year/month/day folders newest first; the first rollout found is the newest.
+  const sortedDirs = async (dir) =>
+    (await fs.promises.readdir(dir, { withFileTypes: true }).catch(() => []))
+      .filter((d) => d.isDirectory())
+      .map((d) => d.name)
+      .sort()
+      .reverse();
+  for (const y of await sortedDirs(CODEX_SESSIONS))
+    for (const m of await sortedDirs(path.join(CODEX_SESSIONS, y)))
+      for (const d of await sortedDirs(path.join(CODEX_SESSIONS, y, m))) {
+        const dir = path.join(CODEX_SESSIONS, y, m, d);
+        const files = (await fs.promises.readdir(dir).catch(() => [])).filter(isRollout);
+        if (!files.length) continue;
+        const stats = await Promise.all(files.map(async (f) => ({ f: path.join(dir, f), m: (await fs.promises.stat(path.join(dir, f))).mtimeMs })));
+        return stats.sort((a, b) => b.m - a.m)[0].f;
+      }
+  return null;
+}
+
+const codexChanged = new Set();
+let codexTimer = null;
+function onCodexChange(_, name) {
+  if (!name || !isRollout(name)) return;
+  codexChanged.add(path.join(CODEX_SESSIONS, name));
+  if (codexTimer) return;
+  codexTimer = setTimeout(async () => {
+    codexTimer = null;
+    const files = [...codexChanged];
+    codexChanged.clear();
+    if ((await Promise.all(files.map(checkRollout))).some(Boolean)) broadcast();
+  }, 1000);
+}
+
+function startCodexDiscovery() {
+  if (!CODEX_ENABLED || !fs.existsSync(CODEX_SESSIONS)) return;
+  try {
+    fs.watch(CODEX_SESSIONS, { recursive: true }, onCodexChange).on('error', () => {});
+  } catch {}
+  discoverCodex();
+  setInterval(discoverCodex, DISCOVER_INTERVAL_MS);
+}
+
+// Codex records your plan limits with every turn (the same numbers its /status shows).
+let codexUsage = null; // { updatedAt, plan, limits, credits }
+
+function codexWindowLabel(minutes) {
+  if (minutes === 300) return '5-hour session';
+  if (minutes === 10080) return 'Weekly';
+  if (minutes % 1440 === 0) return `${minutes / 1440}-day`;
+  if (minutes % 60 === 0) return `${minutes / 60}-hour`;
+  return `${minutes}-minute`;
+}
+
+function noteCodexLimits(rl, at) {
+  if (codexUsage && at <= codexUsage.updatedAt) return;
+  const limits = [];
+  for (const [kind, w] of [['session', rl.primary], ['weekly_all', rl.secondary]]) {
+    if (!w || typeof w.used_percent !== 'number') continue;
+    const resetsAt = w.resets_at ? new Date(w.resets_at * 1000).toISOString() : null;
+    // A window that has reset since Codex last wrote this starts over at 0.
+    const reset = resetsAt && Date.parse(resetsAt) < Date.now();
+    limits.push({
+      kind,
+      label: (rl.limit_name ? `${rl.limit_name} · ` : '') + codexWindowLabel(w.window_minutes),
+      percent: reset ? 0 : w.used_percent,
+      severity: rl.rate_limit_reached_type ? 'critical' : null,
+      resetsAt: reset ? null : resetsAt,
+    });
+  }
+  codexUsage = { updatedAt: at, plan: rl.plan_type || '', limits, credits: rl.credits || null };
+}
+
+function openInVSCode(cwd) {
+  if (!cwd || /["&|<>^%]/.test(cwd) || !fs.existsSync(cwd)) return false;
+  const child =
+    process.platform === 'win32'
+      ? spawn('cmd.exe', ['/c', 'code', cwd], { detached: true, stdio: 'ignore', windowsHide: true })
+      : spawn('code', [cwd], { detached: true, stdio: 'ignore' });
+  child.on('error', () => {});
+  child.unref();
+  return true;
+}
+
+// ---------- app preview ----------
+// Finds web servers started from a session's project folder (npm run dev and the like)
+// so the dashboard can show the app next to the conversation. Windows only for now;
+// elsewhere you type the address yourself.
+
+const PS_LISTENERS =
+  'Get-CimInstance Win32_Process | Select-Object ProcessId,CommandLine | ConvertTo-Json -Compress; "<<split>>"; ' +
+  'Get-NetTCPConnection -State Listen | Select-Object LocalAddress,LocalPort,OwningProcess | ConvertTo-Json -Compress';
+// Editors and Claude itself are often started with the project path; their ports aren't the app.
+const NOT_APPS = new Set(['code.exe', 'code - insiders.exe', 'cursor.exe', 'claude.exe', 'explorer.exe']);
+
+function listListeners() {
+  return new Promise((resolve) => {
+    if (process.platform !== 'win32') return resolve(null);
+    execFile('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', PS_LISTENERS], { windowsHide: true, timeout: 20000, maxBuffer: 64 * 1024 * 1024 }, (err, out) => {
+      if (err) return resolve(null);
+      try {
+        const [procs, listen] = out.split('<<split>>').map((part) => [].concat(JSON.parse(part.trim() || '[]')));
+        resolve({ procs, listen });
+      } catch {
+        resolve(null);
+      }
+    });
+  });
+}
+
+const exeOf = (cmd) => path.basename((cmd.startsWith('"') ? cmd.slice(1).split('"')[0] : cmd.split(' ')[0]) || '').toLowerCase();
+// "…\node_modules\.bin\..\vite\bin\vite.js dev" -> "vite"
+const appLabel = (cmd) => cmd.match(/node_modules[\\/](?:\.bin[\\/]\.\.[\\/])?((?:@[^\\/]+[\\/])?[^\\/"\s]+)/i)?.[1].replace('\\', '/') || exeOf(cmd).replace(/\.exe$/, '');
+
+function probe(host, port) {
+  return new Promise((resolve) => {
+    const req = http.get({ host, port, path: '/', timeout: 1500 }, (res) => {
+      res.resume();
+      const xfo = String(res.headers['x-frame-options'] || '');
+      const csp = String(res.headers['content-security-policy'] || '');
+      resolve({
+        html: /html/i.test(res.headers['content-type'] || ''),
+        embeddable: !xfo && !/frame-ancestors/i.test(csp),
+      });
+    });
+    req.on('timeout', () => req.destroy());
+    req.on('error', () => resolve(null));
+  });
+}
+
+async function findApps(cwd) {
+  const data = cwd && (await listListeners());
+  if (!data) return [];
+  const root = cwd.toLowerCase().replace(/\//g, '\\').replace(/\\+$/, '');
+  const inProject = (cmd) => {
+    const c = cmd.toLowerCase().replace(/\//g, '\\');
+    const i = c.indexOf(root);
+    return i >= 0 && !/[\w.-]/.test(c[i + root.length] || '');
+  };
+  const owners = new Map(); // pid -> command line
+  for (const p of data.procs) {
+    const cmd = String(p.CommandLine || '');
+    if (p.ProcessId !== process.pid && !NOT_APPS.has(exeOf(cmd)) && inProject(cmd)) owners.set(p.ProcessId, cmd);
+  }
+  const seen = new Set();
+  const found = [];
+  for (const l of data.listen) {
+    if (!owners.has(l.OwningProcess) || l.LocalPort === PORT || seen.has(l.LocalPort)) continue;
+    seen.add(l.LocalPort);
+    const host = l.LocalAddress === '::1' ? '::1' : l.LocalAddress === '::' || l.LocalAddress === '0.0.0.0' ? '127.0.0.1' : l.LocalAddress;
+    found.push(probe(host, l.LocalPort).then((r) => r && { url: `http://localhost:${l.LocalPort}`, port: l.LocalPort, label: appLabel(owners.get(l.OwningProcess)), ...r }));
+  }
+  // Pages first (an API server answers too, but isn't much to look at), then by port.
+  return (await Promise.all(found)).filter(Boolean).sort((a, b) => b.html - a.html || a.port - b.port);
+}
+
+function addActivity(s, kind, text, extra = {}) {
+  s.activity.push({ t: Date.now(), kind, text: truncate(text, 4000), ...extra });
+  if (s.activity.length > MAX_ACTIVITY) s.activity.splice(0, s.activity.length - MAX_ACTIVITY);
+  s.lastAction = (extra.tool ? `${extra.tool}: ` : '') + String(text).split('\n')[0].slice(0, 160);
+}
+
+// Who drives a session: 'vscode' (Agenter only answers inside VS Code's turns) or
+// 'agenter' (Agenter runs turns itself, so nothing ever waits on VS Code).
+const driveOf = (s) => (settings.drive?.[s.id] === 'agenter' ? 'agenter' : 'vscode');
+const effectiveHold = (s) => driveOf(s) === 'vscode' && (s.hold === null ? !!settings.holdOnStop : s.hold);
+const hasPending = (s) => [...pending.values()].some((e) => e.item.sessionId === s.id);
+
+function settleStatus(s, status) {
+  s.status = hasPending(s) ? 'waiting' : status;
+}
+
+// ---------- waiting on the dashboard ----------
+
+function hold(s, kind, data, payload, res) {
+  const item = { id: crypto.randomUUID(), sessionId: s.id, kind, createdAt: Date.now(), headless: runners.has(s.id), ...data };
+  const entry = { item, res, payload, timer: null };
+  const minutes = Number(settings.holdMinutes) || 0;
+  if (minutes > 0) {
+    item.releaseAt = item.createdAt + minutes * 60000;
+    entry.timer = setTimeout(() => respond(item.id, 'pass', { auto: true }), minutes * 60000);
+  }
+  pending.set(item.id, entry);
+  s.status = 'waiting';
+  // Claude gave up on the hook (interrupted, timed out, session closed).
+  res.on('close', () => {
+    if (!pending.has(item.id)) return;
+    clearTimeout(entry.timer);
+    pending.delete(item.id);
+    settleStatus(s, kind === 'stop' ? 'idle' : 'working');
+    broadcast();
+  });
+  broadcast();
+}
+
+// action: allow | always | deny | answer | reply | pass
+function respond(id, action, body = {}) {
+  const entry = pending.get(id);
+  if (!entry) return false;
+  const { item, res, payload } = entry;
+  clearTimeout(entry.timer);
+  const s = sessions.get(item.sessionId);
+  let out = {};
+  let status = 'working';
+  if (body.auto) addActivity(s, 'notice', `No answer after ${settings.holdMinutes} min, handed back to VS Code`);
+
+  if (item.kind === 'permission') {
+    if (action === 'allow' || action === 'always') {
+      const decision = { behavior: 'allow' };
+      if (action === 'always' && Array.isArray(payload.permission_suggestions)) decision.updatedPermissions = payload.permission_suggestions;
+      out = { hookSpecificOutput: { hookEventName: 'PermissionRequest', decision } };
+      addActivity(s, 'decision', `${action === 'always' ? 'Always allowed' : 'Allowed'} ${item.tool}`);
+    } else if (action === 'deny') {
+      const message = body.message?.trim() || 'The user denied this from the Agenter dashboard.';
+      out = { hookSpecificOutput: { hookEventName: 'PermissionRequest', decision: { behavior: 'deny', message } } };
+      addActivity(s, 'decision', `Denied ${item.tool}${body.message?.trim() ? `: ${body.message.trim()}` : ''}`);
+    } else {
+      status = 'vscode';
+      addActivity(s, 'decision', `Sent ${item.tool} prompt back to VS Code`);
+    }
+  } else if (item.kind === 'question') {
+    if (action === 'answer' && body.answers && typeof body.answers === 'object') {
+      out = {
+        hookSpecificOutput: {
+          hookEventName: 'PreToolUse',
+          permissionDecision: 'allow',
+          permissionDecisionReason: 'Answered from the Agenter dashboard',
+          updatedInput: { ...payload.tool_input, answers: body.answers },
+        },
+      };
+      addActivity(s, 'decision', `Answered: ${Object.values(body.answers).join(' | ')}`);
+    } else {
+      status = 'vscode';
+      addActivity(s, 'decision', 'Sent question back to VS Code');
+    }
+  } else if (item.kind === 'stop') {
+    const message = body.message?.trim();
+    if (action === 'reply' && message) {
+      out = { decision: 'block', reason: message };
+      addActivity(s, 'prompt', message, { fromDashboard: true });
+    } else {
+      status = 'idle';
+      addActivity(s, 'stop', 'Finished turn');
+    }
+  }
+
+  pending.delete(id);
+  res.writeHead(200, { 'content-type': 'application/json' });
+  res.end(JSON.stringify(out));
+  if (s) settleStatus(s, status);
+  broadcast();
+  return true;
+}
+
+// Sessions are only held while a dashboard window has focus. If you're in VS Code,
+// Claude finishes (or asks) there as usual instead of spinning on the dashboard.
+const inUse = () => [...clients.values()].some((c) => c.focused);
+
+let releaseTimer = null;
+function onAttentionChanged() {
+  clearTimeout(releaseTimer);
+  if (inUse()) return;
+  releaseTimer = setTimeout(() => {
+    // A turn Agenter runs has no VS Code to fall back to, so it keeps waiting while a dashboard is open.
+    for (const [id, e] of [...pending]) if (!clients.size || !e.item.headless) respond(id, 'pass');
+  }, clients.size ? BLUR_GRACE_MS : DISCONNECT_GRACE_MS);
+}
+
+// ---------- steering ----------
+// Messages typed in the dashboard while Claude isn't waiting for a reply. Hooks only run
+// at events, so they wait here and go out with the next one: after the current tool
+// call, when the turn ends (Claude carries on), or with your next prompt if it's idle.
+
+function takeQueue(s, when) {
+  if (!s.queue.length) return '';
+  const texts = s.queue.map((m) => m.text);
+  s.queue = [];
+  for (const t of texts) addActivity(s, 'prompt', t, { fromDashboard: true });
+  const body = texts.join('\n\n');
+  return when === 'stop' ? body : `The user sent this from the Agenter dashboard ${when}. Follow it from here on:\n\n${body}`;
+}
+
+function steer(s, text) {
+  if (s.agent === 'codex') return steerCodex(s, text);
+  const stop = [...pending.values()].find((e) => e.item.sessionId === s.id && e.item.kind === 'stop');
+  if (stop) return respond(stop.item.id, 'reply', { message: text }), 'sent';
+  const busy = runners.has(s.id) || s.status === 'working' || s.status === 'waiting' || s.status === 'vscode';
+  if (driveOf(s) === 'agenter' && !busy) {
+    if (!startRun(s, text)) return 'no-claude';
+    addActivity(s, 'prompt', text, { fromDashboard: true });
+    return 'started';
+  }
+  s.queue.push({ id: crypto.randomUUID(), text, t: Date.now() });
+  broadcast();
+  return 'queued';
+}
+
+// ---------- turns Agenter runs itself ----------
+// "Drive from Agenter" continues the session with the Claude Code CLI that ships with the
+// VS Code extension (`claude -p --resume <id>`). Its hooks report back here like any
+// session, so permission prompts and questions show up on the dashboard.
+
+const runners = new Map(); // session id -> claude process
+
+function findClaude() {
+  if (process.env.AGENTER_CLAUDE) return process.env.AGENTER_CLAUDE;
+  const exe = process.platform === 'win32' ? 'claude.exe' : 'claude';
+  const found = [];
+  for (const editor of ['.vscode', '.vscode-insiders', '.cursor']) {
+    const dir = path.join(os.homedir(), editor, 'extensions');
+    let names = [];
+    try {
+      names = fs.readdirSync(dir).filter((n) => n.startsWith('anthropic.claude-code-'));
+    } catch {}
+    for (const n of names) {
+      const bin = path.join(dir, n, 'resources', 'native-binary', exe);
+      try {
+        found.push({ bin, mtime: fs.statSync(bin).mtimeMs });
+      } catch {}
+    }
+  }
+  if (found.length) return found.sort((a, b) => b.mtime - a.mtime)[0].bin;
+  // Installed on PATH (npm or the native installer)?
+  for (const dir of (process.env.PATH || '').split(path.delimiter)) {
+    for (const name of process.platform === 'win32' ? ['claude.exe', 'claude.cmd'] : ['claude']) {
+      if (dir && fs.existsSync(path.join(dir, name))) return path.join(dir, name);
+    }
+  }
+  return null;
+}
+
+// fresh: the session doesn't exist yet (started from Agenter), so create it under this id.
+function startRun(s, text, { fresh = false } = {}) {
+  const bin = s.cwd && fs.existsSync(s.cwd) && findClaude();
+  if (!bin) return false;
+  const args = ['-p', fresh ? '--session-id' : '--resume', s.id];
+  if (s.permissionMode === 'acceptEdits') args.push('--permission-mode', 'acceptEdits');
+  const child = spawn(bin, args, { cwd: s.cwd, windowsHide: true, stdio: ['pipe', 'ignore', 'pipe'], shell: bin.endsWith('.cmd') });
+  runners.set(s.id, child);
+  s.status = 'working';
+  let err = '';
+  child.stderr.on('data', (d) => (err = (err + d).slice(-2000)));
+  child.on('error', (e) => (err = e.message));
+  child.on('close', (code) => {
+    runners.delete(s.id);
+    if (code && !child.interrupted) addActivity(s, 'notice', `Claude stopped with an error${err.trim() ? `: ${err.trim()}` : ''}`);
+    if (child.interrupted) addActivity(s, 'notice', 'Stopped from Agenter');
+    settleStatus(s, 'idle');
+    // Something sent after the last point Claude could pick it up: run it next.
+    const next = !child.interrupted && takeQueue(s, 'stop');
+    if (next) startRun(s, next);
+    broadcast();
+  });
+  child.stdin.end(text);
+  broadcast();
+  return true;
+}
+
+// ---------- steering Codex ----------
+// Driven from the Codex app (default): `codex queue` hands the message to Codex, which runs
+// it as the next turn of that session in the VS Code extension or the desktop app.
+// Driven from Agenter: `codex exec resume` runs the turn here, sandboxed to the project
+// (workspace-write, no network) since nobody is there to approve anything more.
+
+function findCodex() {
+  if (process.env.AGENTER_CODEX_BIN) return process.env.AGENTER_CODEX_BIN;
+  const exe = process.platform === 'win32' ? 'codex.exe' : 'codex';
+  const found = [];
+  for (const editor of ['.vscode', '.vscode-insiders', '.cursor']) {
+    const dir = path.join(os.homedir(), editor, 'extensions');
+    let names = [];
+    try {
+      names = fs.readdirSync(dir).filter((n) => n.startsWith('openai.chatgpt-'));
+    } catch {}
+    for (const n of names) {
+      let platforms = [];
+      try {
+        platforms = fs.readdirSync(path.join(dir, n, 'bin'));
+      } catch {}
+      for (const p of platforms) {
+        const bin = path.join(dir, n, 'bin', p, exe);
+        try {
+          found.push({ bin, mtime: fs.statSync(bin).mtimeMs });
+        } catch {}
+      }
+    }
+  }
+  if (found.length) return found.sort((a, b) => b.mtime - a.mtime)[0].bin;
+  for (const dir of (process.env.PATH || '').split(path.delimiter)) {
+    for (const name of process.platform === 'win32' ? ['codex.exe', 'codex.cmd'] : ['codex']) {
+      if (dir && fs.existsSync(path.join(dir, name))) return path.join(dir, name);
+    }
+  }
+  return null;
+}
+
+async function steerCodex(s, text) {
+  if (driveOf(s) === 'agenter') {
+    if (runners.has(s.id)) {
+      // `exec` can't take messages mid-turn; this runs as the next turn.
+      s.queue.push({ id: crypto.randomUUID(), text, t: Date.now() });
+      broadcast();
+      return 'queued';
+    }
+    if (!(await startCodexRun(s, text))) return 'no-codex';
+    addActivity(s, 'prompt', text, { fromDashboard: true });
+    return 'started';
+  }
+  const bin = findCodex();
+  if (!bin) return 'no-codex';
+  return new Promise((resolve) => {
+    execFile(bin, ['queue', '--thread', s.id, '--message', text], { windowsHide: true, timeout: 30000, shell: bin.endsWith('.cmd') }, (err) => {
+      if (err) return resolve('error');
+      addActivity(s, 'prompt', text, { fromDashboard: true });
+      resolve('codex-queued');
+    });
+  });
+}
+
+// Runs one Codex turn. fresh: start a new session (no id yet); resolves with the session
+// once Codex has named it. Otherwise resolves true/false for whether it started.
+function startCodexRun(s, text, { fresh = false } = {}) {
+  const bin = s.cwd && fs.existsSync(s.cwd) && findCodex();
+  if (!bin) return Promise.resolve(fresh ? null : false);
+  const common = ['--json', '--skip-git-repo-check'];
+  const args = fresh ? ['exec', ...common, '--sandbox', 'workspace-write', '-'] : ['exec', 'resume', ...common, '-c', 'sandbox_mode=workspace-write', s.id, '-'];
+  const child = spawn(bin, args, { cwd: s.cwd, windowsHide: true, stdio: ['pipe', 'pipe', 'pipe'], shell: bin.endsWith('.cmd') });
+  let err = '';
+  let failure = '';
+  let buf = '';
+  return new Promise((resolve) => {
+    const begin = () => {
+      runners.set(s.id, child);
+      s.status = 'working';
+      s.codexTurnOpen = true;
+      s.lastEventAt = Date.now();
+      broadcast();
+      resolve(fresh ? s : true);
+    };
+    if (!fresh) begin();
+    child.stdout.on('data', (d) => {
+      buf += d;
+      let i;
+      while ((i = buf.indexOf('\n')) >= 0) {
+        const line = buf.slice(0, i);
+        buf = buf.slice(i + 1);
+        let e;
+        try {
+          e = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (e.type === 'thread.started' && fresh && !runners.has(e.thread_id)) {
+          s.id = e.thread_id;
+          sessions.set(s.id, s);
+          begin();
+        } else if (e.type === 'error' || e.type === 'turn.failed') failure = e.message || e.error?.message || failure;
+      }
+    });
+    child.stderr.on('data', (d) => (err = (err + d).slice(-2000)));
+    child.on('error', (e) => (err = e.message));
+    child.on('close', (code) => {
+      // Never got going (Codex missing a login, bad folder…): report why to whoever asked.
+      if (runners.get(s.id) !== child) return resolve(fresh ? { error: failure || err.trim().split('\n').pop() || `Codex exited (${code}).` } : false);
+      runners.delete(s.id);
+      s.codexTurnOpen = false;
+      if ((code || failure) && !child.interrupted) addActivity(s, 'notice', `Codex stopped with an error${failure || err.trim() ? `: ${failure || err.trim().split('\n').pop()}` : ''}`);
+      if (child.interrupted) addActivity(s, 'notice', 'Stopped from Agenter');
+      s.status = 'idle';
+      s.lastAction = (s.transcriptPath && lastAssistantText(s.transcriptPath).split('\n')[0].slice(0, 160)) || s.lastAction;
+      const next = !child.interrupted && takeQueue(s, 'stop');
+      if (next) startCodexRun(s, next);
+      broadcast();
+    });
+    child.stdin.end(text);
+  });
+}
+
+// ---------- hook events ----------
+
+function handleHook(p, res) {
+  const ev = p.hook_event_name;
+  const s = touchSession(p);
+  // A turn Agenter started has nowhere else to ask, so it always asks here.
+  const watching = inUse() || runners.has(s.id);
+  let out = {};
+  let steering;
+
+  switch (ev) {
+    case 'SessionStart':
+      s.status = 'idle';
+      addActivity(s, 'session', `Session ${p.source || 'started'}`);
+      break;
+    case 'SessionEnd':
+      for (const [id, e] of pending) if (e.item.sessionId === s.id) respond(id, 'pass');
+      // Each turn Agenter runs ends its process; the session itself carries on.
+      if (driveOf(s) === 'agenter') {
+        s.status = 'idle';
+        s.lastAction = lastAssistantText(s.transcriptPath).split('\n')[0].slice(0, 160) || s.lastAction;
+      } else {
+        s.status = 'ended';
+        s.queue = [];
+        addActivity(s, 'session', `Session ended${p.reason ? ` (${p.reason})` : ''}`);
+      }
+      break;
+    case 'UserPromptSubmit':
+      s.status = 'working';
+      if (!s.title && p.prompt) s.title = p.prompt.split('\n')[0].slice(0, 140);
+      addActivity(s, 'prompt', p.prompt || '');
+      if ((steering = takeQueue(s, 'while you were idle'))) out = { hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: steering } };
+      break;
+    case 'PreToolUse':
+      if (p.tool_name === 'AskUserQuestion' && watching && Array.isArray(p.tool_input?.questions)) {
+        addActivity(s, 'tool', describeTool(p.tool_name, p.tool_input), { tool: p.tool_name });
+        return hold(s, 'question', { tool: p.tool_name, questions: p.tool_input.questions }, p, res);
+      }
+      s.status = 'working';
+      addActivity(s, 'tool', describeTool(p.tool_name, p.tool_input), { tool: p.tool_name });
+      break;
+    case 'PostToolUse':
+      settleStatus(s, 'working');
+      if ((steering = takeQueue(s, 'while you were working'))) out = { hookSpecificOutput: { hookEventName: 'PostToolUse', additionalContext: steering } };
+      break;
+    case 'PermissionRequest':
+      if (watching && p.tool_name !== 'AskUserQuestion') {
+        const canAlways = Array.isArray(p.permission_suggestions) && p.permission_suggestions.length > 0;
+        return hold(s, 'permission', { tool: p.tool_name, input: p.tool_input, canAlways }, p, res);
+      }
+      s.status = 'vscode';
+      break;
+    case 'Notification':
+      if (p.notification_type === 'permission_prompt' && hasPending(s)) break; // already on the dashboard
+      addActivity(s, 'notice', p.message || '');
+      if (p.notification_type === 'idle_prompt') settleStatus(s, 'idle');
+      break;
+    case 'Stop':
+      if ((steering = takeQueue(s, 'stop'))) {
+        out = { decision: 'block', reason: steering };
+        break;
+      }
+      if (watching && effectiveHold(s)) {
+        return hold(s, 'stop', { message: truncate(p.last_assistant_message || lastAssistantText(s.transcriptPath), 20000) }, p, res);
+      }
+      settleStatus(s, 'idle');
+      addActivity(s, 'stop', 'Finished turn');
+      break;
+    case 'SubagentStop':
+      addActivity(s, 'notice', 'Subagent finished');
+      break;
+  }
+  broadcast();
+  res.writeHead(200, { 'content-type': 'application/json' });
+  res.end(JSON.stringify(out));
+}
+
+// ---------- dashboard plumbing ----------
+
+function snapshot() {
+  return {
+    settings,
+    usage,
+    codexUsage,
+    // activity stays server-side (it feeds lastAction); the dashboard reads the transcript instead.
+    sessions: [...sessions.values()].map(({ activity, ...s }) => ({ ...s, holdOverride: s.hold, hold: effectiveHold(s), drive: driveOf(s), running: runners.has(s.id) })),
+    pending: [...pending.values()].map((e) => e.item),
+  };
+}
+
+let broadcastQueued = false;
+function broadcast() {
+  if (broadcastQueued) return;
+  broadcastQueued = true;
+  setTimeout(() => {
+    broadcastQueued = false;
+    const msg = `event: state\ndata: ${JSON.stringify(snapshot())}\n\n`;
+    for (const c of clients.keys()) c.write(msg);
+  }, 30);
+}
+
+function readBody(req, limit = 32 * 1024 * 1024) {
+  return new Promise((resolve, reject) => {
+    let size = 0;
+    const chunks = [];
+    req.on('data', (c) => {
+      size += c.length;
+      if (size > limit) {
+        reject(new Error('body too large'));
+        req.destroy();
+      } else chunks.push(c);
+    });
+    req.on('end', () => {
+      try {
+        resolve(JSON.parse(Buffer.concat(chunks).toString('utf8').replace(/^/, '') || '{}'));
+      } catch (err) {
+        reject(err);
+      }
+    });
+    req.on('error', reject);
+  });
+}
+
+const json = (res, code, obj) => {
+  res.writeHead(code, { 'content-type': 'application/json' });
+  res.end(JSON.stringify(obj));
+};
+
+const STATIC = {
+  '/': ['index.html', 'text/html; charset=utf-8'],
+  '/app.js': ['app.js', 'text/javascript; charset=utf-8'],
+  '/style.css': ['style.css', 'text/css; charset=utf-8'],
+};
+
+const ALLOWED_HOSTS = new Set([`127.0.0.1:${PORT}`, `localhost:${PORT}`]);
+const ALLOWED_ORIGINS = new Set([...ALLOWED_HOSTS].map((h) => `http://${h}`));
+
+const server = http.createServer(async (req, res) => {
+  // Only this machine, and never another website (DNS rebinding / cross-site POSTs).
+  if (!ALLOWED_HOSTS.has(req.headers.host) || (req.headers.origin && !ALLOWED_ORIGINS.has(req.headers.origin))) {
+    return json(res, 403, { error: 'forbidden' });
+  }
+  const url = new URL(req.url, `http://${req.headers.host}`);
+
+  try {
+    if (req.method === 'POST' && url.pathname === '/hook') {
+      return handleHook(await readBody(req), res);
+    }
+
+    if (req.method === 'GET' && STATIC[url.pathname]) {
+      const [file, type] = STATIC[url.pathname];
+      res.writeHead(200, { 'content-type': type, 'cache-control': 'no-store' });
+      return res.end(fs.readFileSync(path.join(PUBLIC_DIR, file)));
+    }
+
+    if (req.method === 'GET' && url.pathname === '/events') {
+      res.writeHead(200, { 'content-type': 'text/event-stream', 'cache-control': 'no-store', connection: 'keep-alive' });
+      res.write(`event: state\ndata: ${JSON.stringify(snapshot())}\n\n`);
+      clients.set(res, { id: url.searchParams.get('client') || '', focused: url.searchParams.get('focused') === '1' });
+      onAttentionChanged();
+      if (!usage || Date.now() - usage.fetchedAt > 60000) fetchUsage();
+      const ping = setInterval(() => res.write(': ping\n\n'), 20000);
+      req.on('close', () => {
+        clearInterval(ping);
+        clients.delete(res);
+        onAttentionChanged();
+      });
+      return;
+    }
+
+    if (req.method === 'GET' && url.pathname === '/api/transcript') {
+      const s = sessions.get(url.searchParams.get('session'));
+      if (!s) return json(res, 404, { error: 'unknown session' });
+      const c = s.transcriptPath && readTranscript(s.transcriptPath);
+      if (!c) return json(res, 200, { epoch: '', reset: true, messages: [] });
+      // Same epoch: only messages after the dashboard's last one. Otherwise start over.
+      const reset = url.searchParams.get('epoch') !== c.epoch;
+      const after = Number(url.searchParams.get('after')) || 0;
+      return json(res, 200, { epoch: c.epoch, reset, messages: reset ? c.messages.slice(-120) : c.messages.filter((m) => m.seq > after) });
+    }
+
+    if (req.method === 'GET' && url.pathname === '/api/preview/apps') {
+      const s = sessions.get(url.searchParams.get('session'));
+      if (!s) return json(res, 404, { error: 'unknown session' });
+      return json(res, 200, { apps: await findApps(s.cwd), detects: process.platform === 'win32' });
+    }
+
+    if (req.method === 'POST' && url.pathname.startsWith('/api/')) {
+      // A custom header forces a CORS preflight, which we never approve.
+      if (req.headers['x-agenter'] !== '1') return json(res, 403, { error: 'forbidden' });
+      const body = await readBody(req);
+
+      if (url.pathname === '/api/respond') {
+        const s = sessions.get(pending.get(body.id)?.item.sessionId);
+        const ok = respond(body.id, body.action, body);
+        // Handing something back to VS Code: bring up that project's window so it's right there.
+        if (ok && body.action === 'pass') openInVSCode(s?.cwd);
+        return json(res, ok ? 200 : 404, {});
+      }
+      if (url.pathname === '/api/focus') {
+        for (const c of clients.values()) if (c.id === body.client) c.focused = !!body.focused;
+        onAttentionChanged();
+        return json(res, 200, {});
+      }
+      if (url.pathname === '/api/settings') {
+        if (typeof body.holdOnStop === 'boolean') settings.holdOnStop = body.holdOnStop;
+        if (Number.isFinite(body.holdMinutes) && body.holdMinutes >= 0) settings.holdMinutes = body.holdMinutes;
+        saveSettings();
+        broadcast();
+        return json(res, 200, settings);
+      }
+      if (url.pathname === '/api/session/steer') {
+        const s = sessions.get(body.sessionId);
+        const text = String(body.message || '').trim();
+        // A closed Claude session can only be continued by Agenter; Codex queues for its app either way.
+        if (!s || !text || (s.agent !== 'codex' && driveOf(s) === 'vscode' && (s.status === 'dormant' || s.status === 'ended'))) return json(res, 404, {});
+        return json(res, 200, { result: await steer(s, text) });
+      }
+      if (url.pathname === '/api/session/new') {
+        const cwd = String(body.cwd || '').trim().replace(/^"(.*)"$/, '$1');
+        const text = String(body.message || '').trim();
+        const codex = body.agent === 'codex';
+        if (!text) return json(res, 400, { error: `Type a first message for ${codex ? 'Codex' : 'Claude'}.` });
+        let isDir = false;
+        try {
+          isDir = path.isAbsolute(cwd) && fs.statSync(cwd).isDirectory();
+        } catch {}
+        if (!isDir) return json(res, 400, { error: "That folder doesn't exist. Use the full path, like C:\\Users\\you\\project." });
+        if (codex) {
+          if (!findCodex()) return json(res, 400, { error: "Couldn't find Codex. Install the Codex VS Code extension, or set AGENTER_CODEX_BIN to codex.exe." });
+          // Codex names the session itself, so it's registered once Codex has started it.
+          const draft = Object.assign(newSession(''), { agent: 'codex', title: text.split('\n')[0].slice(0, 140), lastEventAt: Date.now() });
+          setCwd(draft, path.resolve(cwd));
+          const started = await Promise.race([startCodexRun(draft, text, { fresh: true }), new Promise((r) => setTimeout(() => r({ error: 'Codex took too long to start.' }), 60000))]);
+          if (!started?.id) return json(res, 500, { error: `Codex couldn't start: ${started?.error || 'unknown error'}` });
+          settings.drive = { ...settings.drive, [started.id]: 'agenter' };
+          saveSettings();
+          addActivity(started, 'prompt', text, { fromDashboard: true });
+          broadcast();
+          return json(res, 200, { sessionId: started.id });
+        }
+        if (!findClaude()) return json(res, 400, { error: "Couldn't find Claude Code. Install the VS Code extension, or set AGENTER_CLAUDE to claude.exe." });
+        const s = getOrCreateSession(crypto.randomUUID());
+        setCwd(s, path.resolve(cwd));
+        s.title = text.split('\n')[0].slice(0, 140);
+        s.lastEventAt = Date.now();
+        settings.drive = { ...settings.drive, [s.id]: 'agenter' };
+        saveSettings();
+        if (!startRun(s, text, { fresh: true })) {
+          sessions.delete(s.id);
+          return json(res, 500, { error: "Couldn't start Claude." });
+        }
+        addActivity(s, 'prompt', text, { fromDashboard: true });
+        return json(res, 200, { sessionId: s.id });
+      }
+      if (url.pathname === '/api/session/drive') {
+        const s = sessions.get(body.sessionId);
+        if (!s) return json(res, 404, {});
+        settings.drive = { ...settings.drive };
+        if (body.drive === 'agenter') {
+          settings.drive[s.id] = 'agenter';
+          // Let go of a finished turn VS Code is spinning on; from now on Agenter runs the turns.
+          for (const [id, e] of [...pending]) if (e.item.sessionId === s.id && e.item.kind === 'stop') respond(id, 'pass');
+        } else delete settings.drive[s.id];
+        saveSettings();
+        if (s.agent === 'codex') s.status = codexStatus(s);
+        broadcast();
+        return json(res, 200, { cli: !!(s.agent === 'codex' ? findCodex() : findClaude()) });
+      }
+      if (url.pathname === '/api/session/interrupt') {
+        const child = runners.get(body.sessionId);
+        if (child) {
+          child.interrupted = true;
+          child.kill();
+        }
+        return json(res, child ? 200 : 404, {});
+      }
+      if (url.pathname === '/api/session/unqueue') {
+        const s = sessions.get(body.sessionId);
+        if (s) s.queue = s.queue.filter((m) => m.id !== body.id);
+        broadcast();
+        return json(res, 200, {});
+      }
+      if (url.pathname === '/api/session/hold') {
+        const s = sessions.get(body.sessionId);
+        if (!s) return json(res, 404, {});
+        s.hold = typeof body.hold === 'boolean' ? body.hold : null;
+        broadcast();
+        return json(res, 200, {});
+      }
+      if (url.pathname === '/api/session/remove') {
+        for (const id of body.sessionIds || []) {
+          const s = sessions.get(id);
+          if (s && !hasPending(s) && !runners.has(id)) {
+            sessions.delete(id);
+            dismissed.add(id);
+            if (settings.drive?.[id]) delete settings.drive[id];
+          }
+        }
+        saveSettings();
+        broadcast();
+        return json(res, 200, {});
+      }
+      if (url.pathname === '/api/usage/refresh') {
+        await fetchUsage({ force: true }); // you asked: try even while backing off
+        return json(res, 200, usage || {});
+      }
+      if (url.pathname === '/api/session/open') {
+        const s = sessions.get(body.sessionId);
+        return json(res, s && openInVSCode(s.cwd) ? 200 : 400, {});
+      }
+    }
+
+    json(res, 404, { error: 'not found' });
+  } catch (err) {
+    if (!res.headersSent) json(res, 400, { error: err.message });
+  }
+});
+
+server.requestTimeout = 0; // hooks can legitimately wait a long time for you
+server.on('error', (err) => {
+  if (err.code === 'EADDRINUSE') console.error(`Port ${PORT} is busy. Is Agenter already running? (Set AGENTER_PORT to use another port.)`);
+  else console.error(err);
+  process.exit(1);
+});
+server.listen(PORT, HOST, () => {
+  const url = `http://localhost:${PORT}`;
+  console.log(`Agenter dashboard: ${url}`);
+  startDiscovery();
+  startCodexDiscovery();
+  fetchUsage();
+  setInterval(fetchUsage, USAGE_INTERVAL_MS);
+  if (!process.argv.includes('--no-open')) openDashboard(url);
+});