@double_geste/agent-standup 1.26.0 → 1.28.0

package/README.md

@@ -1,6 +1,6 @@
 # Agent Standup (command line)
 
-Your Claude Code sessions as a live team call, without any editor. Free, MIT, and it never calls Claude: it only reads the session files Claude Code already writes.
+Your Claude Code and Codex sessions as a live team call, without any editor. Free, MIT, and it never calls Claude: it only reads the session files Claude Code and Codex already write.
 
 ```bash
 npx @double_geste/agent-standup            # then open http://localhost:4747   (add --open to open it for you)
@@ -15,4 +15,4 @@ Install once for status bars (faster than npx): `npm i -g @double_geste/agent-st
 
 Full documentation, the VS Code extension, the desktop app and the demo: https://atoll92.github.io/agent-standup/ · https://github.com/Atoll92/agent-standup.git
 
-Unofficial: not affiliated with Anthropic.
+Unofficial: not affiliated with Anthropic or OpenAI.

package/bin/agent-standup.js

@@ -9,12 +9,12 @@ const pkg = require('../package.json');
 const argv = process.argv.slice(2), flags = {}, rest = [];
 for (let i = 0; i < argv.length; i++) {
   const a = argv[i], val = () => argv[++i];
-  if (a === '--port') flags.port = val(); else if (a === '--projects') flags.projects = val(); else if (a === '--characters') flags.characters = val(); else if (a === '--config-dir') flags.config = val();
+  if (a === '--port') flags.port = val(); else if (a === '--projects') flags.projects = val(); else if (a === '--codex') flags.codex = val(); else if (a === '--characters') flags.characters = val(); else if (a === '--config-dir') flags.config = val();
   else if (a === '--open') flags.open = true; else if (a === '--here') flags.here = true; else if (a === '--json') flags.json = true; else if (a === '--titles') flags.titles = true;
   else if (a === '-h' || a === '--help') flags.help = true; else if (a === '-v' || a === '--version') flags.version = true; else rest.push(a);
 }
 const cmd = rest[0] || 'serve';
-const HELP = `Agent Standup ${pkg.version} — your Claude Code agents as a live video call
+const HELP = `Agent Standup ${pkg.version} — your Claude Code and Codex agents as a live video call
 
 Usage
   agent-standup [serve] [--port 4747] [--open]   start the local server (http://localhost:4747)
@@ -25,6 +25,7 @@ Options
   --port N          port of the local server (default 4747)
   --open            open the page in your browser
   --projects DIR    where the session files are (default ~/.claude/projects, or $CLAUDE_CONFIG_DIR/projects)
+  --codex DIR       where Codex keeps its files (default ~/.codex, or $CODEX_HOME); "off" to leave Codex sessions out
   --characters DIR  folder with your own pixel-art characters (default ~/.agent-standup/characters)
   --here            status: only sessions of the current folder (matched on its real path, as Claude Code names it)
   --json            status: machine-readable output (add --titles to include session titles)
@@ -32,6 +33,7 @@ Options
 if (flags.help || cmd === 'help') { process.stdout.write(HELP); process.exit(0); }
 if (flags.version || cmd === 'version') { console.log(pkg.version); process.exit(0); }
 if (flags.projects) process.env.AGENT_STANDUP_PROJECTS = path.resolve(flags.projects);
+if (flags.codex !== undefined) process.env.AGENT_STANDUP_CODEX = /^(0|off|no|false)?$/i.test(String(flags.codex)) ? 'off' : path.resolve(String(flags.codex));
 if (flags.config) process.env.CLAUDE_CONFIG_DIR = path.resolve(flags.config);
 if (flags.characters) process.env.AGENT_STANDUP_CHARACTERS = path.resolve(flags.characters);
 if (flags.port !== undefined) {   // a real port number or nothing: no silent fallback to another port
@@ -42,7 +44,7 @@ const server = require('../server.js');
 const projKey = (dir) => String(dir || '').replace(/[^a-zA-Z0-9]/g, '-');   // Claude Code's project folder naming
 
 function snapshot(dir) {
-  const now = Date.now(), all = server.boardRows(), rows = dir ? all.filter((r) => r.proj === projKey(dir)) : all;
+  const now = Date.now(), all = server.boardRows(), rows = dir ? all.filter((r) => r.proj === projKey(dir) || r.dir === projKey(dir)) : all;   // dir: the folder a Codex session was started in, named the same way
   const act = rows.filter((r) => r.state !== 'idle' || now - r.mtime < 15 * 60e3), n = (st) => act.filter((r) => r.state === st).length;
   return { rows: act, needsYou: n('blocked'), working: n('working') + n('waiting'), yourTurn: n('turn'), idle: rows.length - act.length };
 }

package/codex.js

@@ -0,0 +1,209 @@
+// Codex sessions (OpenAI's Codex: the desktop app and the command line) shown as the same call as Claude Code sessions.
+// Codex writes one "rollout" file per thread in <home>/sessions/YYYY/MM/DD/rollout-<time>-<id>.jsonl. Nothing is ever written there, and nothing else in the Codex folder is read
+// but session_index.jsonl (the names of the threads). server.js reads the files with its own incremental reader and hands each record to parser() below, which turns it into the
+// events a Claude Code record gives (say, user, tool, results, usage, compact), so everything after that is shared: the timeline, the live feed, the page.
+// All Codex sessions are listed under one made-up project, PROJ. No Claude Code project folder can have that name: theirs are paths with every other character turned into "-".
+const fs = require('fs'), os = require('os'), path = require('path');
+const PROJ = '_codex';
+// Where Codex keeps its files: AGENT_STANDUP_CODEX (a folder; "0" or "off" turns Codex sessions off), else $CODEX_HOME, else ~/.codex.
+// When AGENT_STANDUP_PROJECTS points the app at one folder of Claude Code sessions (--projects, the tests), Codex is only read if it is asked for too.
+function home() {
+  const v = process.env.AGENT_STANDUP_CODEX;
+  if (v != null) return /^(0|off|no|false)?$/i.test(v.trim()) ? null : v;
+  if (process.env.AGENT_STANDUP_PROJECTS) return null;
+  return process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
+}
+const dirKey = (cwd) => String(cwd || '').replace(/[^a-zA-Z0-9]/g, '-');   // the name Claude Code gives the same folder: how "this project" is asked for everywhere else
+
+// ---- finding the files
+const NAME = /^rollout-.*?([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i;
+let memo = { at: 0, home: undefined, rows: [], byId: new Map() };
+function scan() {   // every rollout file with its date and size, newest first; shared by all the polls of two seconds
+  const h = home(), now = Date.now(); if (memo.home === h && now - memo.at < 2000) return memo;
+  const rows = [], byId = new Map();
+  const walk = (dir, depth) => {
+    let names; try { names = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of names) {
+      const fp = path.join(dir, e.name);
+      if (e.isDirectory()) { if (depth < 4) walk(fp, depth + 1); continue; }
+      const m = NAME.exec(e.name); if (!m) continue;
+      let st; try { st = fs.statSync(fp); } catch { continue; }
+      const row = { id: m[1].toLowerCase(), file: fp, mtime: st.mtimeMs, size: st.size }; rows.push(row); byId.set(row.id, row);
+    }
+  };
+  if (h) walk(path.join(h, 'sessions'), 0);
+  rows.sort((a, b) => b.mtime - a.mtime);
+  memo = { at: now, home: h, rows, byId }; return memo;
+}
+const row = (id) => scan().byId.get(String(id).toLowerCase()) || null;
+const fileOf = (id) => { const r = row(id); return r ? r.file : null; };
+
+// ---- the first line of a file says what the thread is: its folder, and whether another thread started it
+const headCache = new Map();   // file → { ok, cwd, dir, child } (the first line never changes)
+function firstLine(file, max = 1024 * 1024) {
+  let fd; try {
+    fd = fs.openSync(file, 'r'); const parts = []; let pos = 0;
+    while (pos < max) { const buf = Buffer.alloc(64 * 1024), n = fs.readSync(fd, buf, 0, buf.length, pos); if (!n) break; const nl = buf.subarray(0, n).indexOf(10); if (nl >= 0) { parts.push(buf.subarray(0, nl)); return { text: Buffer.concat(parts).toString('utf8'), whole: true }; } parts.push(buf.subarray(0, n)); pos += n; }
+    return { text: Buffer.concat(parts).toString('utf8'), whole: false, capped: pos >= max };
+  } catch { return { text: '', whole: false }; } finally { if (fd != null) fs.closeSync(fd); }
+}
+function head(file) {
+  const hit = headCache.get(file); if (hit) return hit;
+  const { text, whole, capped } = firstLine(file); let out = { ok: false, cwd: '', dir: '', child: false };
+  if (!text) return out;   // not written yet: looked at again next time
+  let p = null; try { const r = JSON.parse(text); if (r && r.type === 'session_meta' && r.payload && typeof r.payload === 'object') p = r.payload; } catch {}
+  if (p) out = { ok: true, cwd: typeof p.cwd === 'string' ? p.cwd : '', child: !!p.parent_thread_id || !!(p.source && typeof p.source === 'object' && p.source.subagent) };
+  else if (capped && /^\{"timestamp":"[^"]*","(?:ordinal":\d+,")?type":"session_meta"/.test(text)) {   // a first line longer than what was read: the two facts, without the rest
+    const cwd = text.match(/"cwd":"((?:[^"\\]|\\.)*)"/); let c = ''; try { c = cwd ? JSON.parse('"' + cwd[1] + '"') : ''; } catch {}
+    out = { ok: true, cwd: c, child: /"parent_thread_id":"[^"]+"/.test(text) || /"source":\{"subagent"/.test(text) };
+  }
+  out.dir = dirKey(out.cwd);
+  if (whole || capped) { if (headCache.size > 5000) headCache.clear(); headCache.set(file, out); }   // a first line still being written is read again next time
+  return out;
+}
+// The threads a person started, newest first. A thread started by another thread (Codex's review of a command before it runs, a sub-agent) is not a session of its own.
+function sessions(limit = 80) {
+  const out = []; for (const r of scan().rows) { const h = head(r.file); if (!h.ok || h.child) continue; out.push({ ...r, cwd: h.cwd, dir: h.dir }); if (out.length >= limit) break; }
+  return out;
+}
+const inProject = (id, key) => { const r = row(id); if (!r || !key) return false; if (key === PROJ) return true; const d = head(r.file).dir; return d === key || d.startsWith(key + '-'); };
+const projectLabel = (cwd) => { const h = os.homedir(), rel = cwd && cwd.startsWith(h + path.sep) ? cwd.slice(h.length + 1) : cwd; return 'Codex' + (rel ? ' · ' + rel.split(path.sep).join('/') : ''); };
+
+// ---- names: the one Codex gave the thread (session_index.jsonl, the last line for an id wins), else the first thing the person typed
+let names = { sig: '', map: new Map() };
+function threadNames() {
+  const h = home(); if (!h) return names.map;
+  const f = path.join(h, 'session_index.jsonl'); let st; try { st = fs.statSync(f); } catch { return names.map; }
+  const sig = f + ':' + st.mtimeMs + ':' + st.size; if (sig === names.sig) return names.map;
+  const map = new Map(); try { for (const l of fs.readFileSync(f, 'utf8').split('\n')) { if (!l) continue; try { const j = JSON.parse(l); if (j && j.id && typeof j.thread_name === 'string' && j.thread_name.trim()) map.set(String(j.id).toLowerCase(), j.thread_name.trim()); } catch {} } } catch {}
+  names = { sig, map }; return map;
+}
+function typed(t) {   // what the person typed, without what Codex wraps around it: the tags of an answer to a question, and the list of attached files ("# Files mentioned by the user:" … "## My request:")
+  let s = String(t == null ? '' : t).replace(/<\/?send_user_message_question_reply>/g, ''); const i = s.indexOf('# Files mentioned by the user:');
+  if (i >= 0) { const rest = s.slice(i), m = /\n## My request[^\n]*:[ \t]*\n?/.exec(rest); s = s.slice(0, i) + (m ? '\n' + rest.slice(m.index + m[0].length) : ''); }
+  return s.trim();
+}
+const partsText = (c) => (typeof c === 'string' ? c : Array.isArray(c) ? c.map((x) => (x && typeof x.text === 'string' ? x.text : '')).filter(Boolean).join('\n') : '');
+const promptCache = new Map();   // file → the first prompt ('' = looked for in the first megabyte and not there)
+function firstPrompt(r) {
+  const hit = promptCache.get(r.file); if (hit != null) return hit;
+  let text = ''; try { const fd = fs.openSync(r.file, 'r'); try { const buf = Buffer.alloc(Math.min(1024 * 1024, r.size)); fs.readSync(fd, buf, 0, buf.length, 0); text = buf.toString('utf8'); } finally { fs.closeSync(fd); } } catch {}
+  let out = '';
+  for (const l of text.split('\n')) {
+    if (!l.includes('"UserMessage"') && !l.includes('"user_message"')) continue; let j; try { j = JSON.parse(l); } catch { continue; }
+    const p = (j && j.payload) || {}, t = p.type === 'user_message' ? typed(p.message) : p.type === 'item_completed' && p.item && p.item.type === 'UserMessage' ? typed(partsText(p.item.content)) : '';
+    if (t) { out = t.replace(/\s+/g, ' ').slice(0, 90); break; }
+  }
+  if (out || r.size > 64 * 1024) { if (promptCache.size > 2000) promptCache.clear(); promptCache.set(r.file, out); }   // a file that has just been created is looked at again
+  return out;
+}
+const title = (r) => threadNames().get(r.id) || firstPrompt(r) || r.id;
+
+// ---- the board: is the agent in the middle of a turn, or is it the person's turn? Read from the end of the file.
+const tailCache = new Map();
+function boardRow(r, now) {
+  const sig = r.mtime + ':' + r.size; let t = tailCache.get(r.file);
+  if (!t || t.sig !== sig) {
+    t = { sig, turn: '' };
+    try {
+      const fd = fs.openSync(r.file, 'r'); let text = ''; try { const n = Math.min(128 * 1024, r.size), buf = Buffer.alloc(n); fs.readSync(fd, buf, 0, n, r.size - n); text = buf.toString('utf8'); } finally { fs.closeSync(fd); }
+      for (const l of text.split('\n')) { const m = /"type":"(task_started|task_complete|turn_started|turn_complete|turn_aborted)"/.exec(l.slice(0, 400)); if (m && l.includes('"event_msg"')) t.turn = /started/.test(m[1]) ? 'open' : 'closed'; }
+    } catch {}
+    if (tailCache.size > 200) tailCache.delete(tailCache.keys().next().value); tailCache.set(r.file, t);
+  }
+  const age = now - r.mtime, state = age >= 30 * 60e3 ? 'idle' : t.turn === 'closed' ? 'turn' : age < 10 * 60e3 ? 'working' : 'idle';
+  return { proj: PROJ, id: r.id, title: title(r), mtime: r.mtime, state, tool: '', ageMs: age, subActive: 0, subTotal: 0, dir: r.dir, source: 'codex' };
+}
+
+// ---- one record of a rollout file → the events of the call
+// Two generations of the format are read. The current one (2026) writes an "item_completed" line for everything that happened: what was typed, what the agent said,
+// each command with its output, each file it changed, each search. The earlier one wrote the messages as "user_message" / "agent_message" events and the tool calls as
+// raw "function_call" records. A file of the current kind also carries those raw records (the script the model wrote around its commands), which would say everything twice:
+// once the first item is seen, the raw tool calls are left alone.
+function parser({ toolLabel, clip, resultMax = {} }) {
+  const shellText = (c) => (Array.isArray(c) ? (c.length === 3 && /^-l?c$/.test(c[1]) ? c[2] : c.join(' ')) : String(c == null ? '' : c));
+  const diffSides = (d) => { const add = [], del = []; for (const l of String(d || '').split('\n')) { if (/^(\+\+\+ |--- |@@|diff |index |\*\*\* )/.test(l)) continue; if (l[0] === '+') add.push(l.slice(1)); else if (l[0] === '-') del.push(l.slice(1)); } return { add: add.join('\n'), del: del.join('\n') }; };
+  const patchFiles = (text) => {   // the "*** Update File: x" blocks of an apply_patch call
+    const out = []; let cur = null;
+    for (const l of String(text || '').split('\n')) { const m = /^\*\*\* (Add|Update|Delete) File: (.+)$/.exec(l); if (m) { cur = { type: m[1].toLowerCase(), file: m[2].trim(), body: [] }; out.push(cur); } else if (cur && !/^\*\*\* (Begin|End) Patch/.test(l)) cur.body.push(l); }
+    return out.map((x) => ({ type: x.type, file: x.file, ...diffSides(x.body.join('\n')) }));
+  };
+  const NO_RESULT = new Set(['TodoWrite']);
+  return function record(st, r) {
+    if (r.type !== 'event_msg' && r.type !== 'response_item' && r.type !== 'turn_context' && r.type !== 'compacted') return;
+    const agent = st.agent, p = r.payload && typeof r.payload === 'object' ? r.payload : {}, cx = st.cx || (st.cx = { items: false, model: '', n: 0, tot: null, last: 0, userAt: -1 });
+    const ts = Math.max(Date.parse(r.timestamp) || 0, st.lastTs || 0); st.lastTs = ts;   // the lines of one file are in order; a line without a time takes the last one
+    const push = (e) => { e.k = agent + ':' + st.raw.length; st.raw.push(e); if (e.ts > cx.last) cx.last = e.ts; return e; };
+    const th = () => { const t = st.th; st.th = ''; return t ? { th: t } : {}; };
+    const say = (text, final) => { const t = String(text == null ? '' : text).trim(); if (!t) return; const e = push({ ts, agent, kind: 'say', text: t, ...th() }); st.act = st.raw.length - 1; if (final && agent === 'main') e.end = 1; };
+    const user = (text) => { const t = typed(text); if (!t) return; push({ ts, agent: 'user', kind: 'user', text: t }); cx.userAt = st.raw.length - 1; };
+    const call = (id, name, input, at) => { const when = Math.max(Math.min(at || ts, ts), cx.last); st.toolName[id] = name; push({ ts: when, agent, kind: 'tool', tool: toolLabel({ id, name, input: input || {} }, when), ...th() }); st.act = st.raw.length - 1; };   // a command is placed when it started, never before what the file already said
+    const result = (id, out, err) => { const n = st.toolName[id]; if (!n || NO_RESULT.has(n)) return; push({ ts, agent, kind: 'results', items: [{ id, err: !!err, out: clip(String(out == null ? '' : out).trimEnd(), resultMax[n] || (/^mcp__/.test(n) ? 900 : 600)) }] }); };
+    const endTurn = () => { if (agent === 'main' && st.act > cx.userAt && st.raw[st.act]) st.raw[st.act].end = 1; };   // the turn is over (or was stopped): the last thing the lead said or did closes it
+
+    if (r.type === 'turn_context') { if (typeof p.model === 'string') cx.model = p.model; return; }
+    if (r.type === 'compacted') { push({ ts, agent, kind: 'compact' }); return; }
+    if (r.type === 'event_msg') {
+      if (p.type === 'item_completed' && p.item && typeof p.item === 'object') {
+        const it = p.item, id = String(it.id || 'cx' + st.raw.length), at = +p.started_at_ms || 0; cx.items = true;
+        if (it.type === 'UserMessage') user(partsText(it.content));
+        else if (it.type === 'AgentMessage') say(partsText(it.content), it.phase === 'final_answer');
+        else if (it.type === 'CommandExecution') { call(id, 'Bash', { command: shellText(it.command) }, at); result(id, it.aggregated_output != null ? it.aggregated_output : [it.stdout, it.stderr].filter(Boolean).join('\n'), it.status === 'failed' || (typeof it.exit_code === 'number' && it.exit_code !== 0)); }
+        else if (it.type === 'FileChange') Object.entries(it.changes && typeof it.changes === 'object' ? it.changes : {}).forEach(([file, c], i) => {
+          const cid = i ? id + ':' + i : id, kind = c && c.type, d = diffSides(c && c.unified_diff);
+          if (kind === 'add') call(cid, 'Write', { file_path: file, content: c.content != null ? String(c.content) : d.add }, at);
+          else call(cid, 'Edit', { file_path: file, old_string: kind === 'delete' && c.content != null ? String(c.content) : d.del, new_string: d.add }, at);
+          result(cid, '', it.status === 'failed');   // the line is written once the change is made: without an answer the call would look like it is still waiting (for an approval, on a file change)
+        });
+        else if (it.type === 'McpToolCall') { call(id, 'mcp__' + (it.server || 'mcp') + '__' + (it.tool || 'tool'), it.arguments && typeof it.arguments === 'object' ? it.arguments : {}, at); result(id, partsText(it.result && it.result.content), it.status === 'failed' || !!(it.result && it.result.isError)); }
+        else if (it.type === 'ImageView') { call(id, 'Read', { file_path: it.path }, at); result(id, ''); }
+        else if (it.type === 'Extension' && /^web\./.test(it.kind || '')) {
+          const a = it.action && typeof it.action === 'object' ? it.action : {}, q = it.query || a.query || (Array.isArray(a.queries) && a.queries[0]) || '';
+          if (a.url) call(id, 'WebFetch', { url: a.url }, at); else call(id, 'WebSearch', { query: q }, at);
+          result(id, (Array.isArray(it.results) ? it.results : []).slice(0, 6).map((x) => (x.title || '') + (x.url ? ' · ' + x.url : '')).join('\n'));
+        }
+        return;
+      }
+      if (p.type === 'user_message') { if (!cx.items) user(p.message); return; }
+      if (p.type === 'agent_message') { if (!cx.items) say(p.message, p.phase === 'final_answer'); return; }
+      if (p.type === 'token_count') {   // what the last request used. The same numbers are written again when only the rate limits moved: the running total tells
+        const info = p.info && typeof p.info === 'object' ? p.info : null, u = info && info.last_token_usage, tot = info && info.total_token_usage ? info.total_token_usage.total_tokens : null;
+        if (!u || (tot != null && tot === cx.tot)) return; cx.tot = tot;
+        const cached = u.cached_input_tokens || 0, w = u.cache_write_input_tokens || 0;
+        st.msgUsage.set('t' + cx.n++, { ts, u: { i: Math.max(0, (u.input_tokens || 0) - cached - w), o: u.output_tokens || 0, r: cached, w }, model: cx.model || 'codex', ...(info.model_context_window > 0 ? { cw: info.model_context_window } : {}) });   // cw: the size of the context window, which Codex states
+        return;
+      }
+      if (p.type === 'task_complete' || p.type === 'turn_complete' || p.type === 'turn_aborted') endTurn();
+      return;
+    }
+    // response_item: what the model sent, raw
+    if (p.type === 'reasoning') {   // the summary Codex keeps of what the agent was thinking: an inner thought on its next line or call
+      const s = (Array.isArray(p.summary) ? p.summary : []).map((x) => (x && typeof x.text === 'string' ? x.text : '')).filter(Boolean).join('\n').replace(/\*\*/g, '');
+      if (s.trim()) st.th = clip(s.replace(/[^\S\n]+/g, ' ').replace(/ ?\n[\n ]*/g, '\n').trim(), 900);
+      return;
+    }
+    const isCall = p.type === 'function_call' || p.type === 'custom_tool_call' || p.type === 'local_shell_call', id = String(p.call_id || p.id || '');
+    if (isCall && id) {
+      let a = {}; if (p.type === 'custom_tool_call') a = { input: p.input }; else if (p.type === 'local_shell_call') a = p.action && typeof p.action === 'object' ? p.action : {}; else { try { const v = typeof p.arguments === 'string' ? JSON.parse(p.arguments) : p.arguments; if (v && typeof v === 'object') a = v; } catch {} }
+      const n = String(p.name || (p.type === 'local_shell_call' ? 'shell' : ''));
+      if (/^request_user_input/.test(n)) { call(id, 'AskUserQuestion', { questions: (Array.isArray(a.questions) ? a.questions : []).map((q) => ({ question: (q && (q.question || q.title)) || '', options: (q && Array.isArray(q.options) && q.options) || [] })) }); return; }   // the agent asks the person something: in both generations
+      if (cx.items) return;
+      if (/^(shell|shell_command|exec_command|local_shell|unified_exec|container\.exec)$/.test(n)) call(id, 'Bash', { command: shellText(a.command != null ? a.command : a.cmd) });
+      else if (n === 'apply_patch') { const fl = patchFiles(a.input != null ? a.input : a.patch); if (!fl.length) call(id, 'Edit', { file_path: '', old_string: '', new_string: clip(a.input || a.patch || '', 500) }); if (fl.length > 1) (cx.more = cx.more || {})[id] = fl.length; fl.forEach((f, i) => { const cid = i ? id + ':' + i : id; if (f.type === 'add') call(cid, 'Write', { file_path: f.file, content: f.add }); else call(cid, 'Edit', { file_path: f.file, old_string: f.del, new_string: f.add }); }); }
+      else if (n === 'update_plan') call(id, 'TodoWrite', { todos: (Array.isArray(a.plan) ? a.plan : []).map((x) => ({ content: (x && x.step) || '', status: (x && x.status) || 'pending' })) });
+      else if (n === 'view_image') call(id, 'Read', { file_path: a.path });
+      else if (n) call(id, p.namespace ? String(p.namespace).replace(/::$/, '') + '__' + n : n, a);
+      return;
+    }
+    if ((p.type === 'function_call_output' || p.type === 'custom_tool_call_output' || p.type === 'local_shell_call_output') && id) {
+      if (cx.items && st.toolName[id] !== 'AskUserQuestion') return;   // in the current format the item already carried the output (an MCP call has the same id in both: it would be answered twice, the second time without its failure)
+      let out = p.output, err = false;
+      if (typeof out === 'string' && out[0] === '{') { try { const j = JSON.parse(out); if (j && typeof j === 'object' && ('output' in j || 'metadata' in j)) { err = !!(j.metadata && typeof j.metadata.exit_code === 'number' && j.metadata.exit_code !== 0); out = j.output != null ? j.output : ''; } } catch {} }
+      else if (out && typeof out === 'object' && !Array.isArray(out)) { err = out.success === false; out = out.content != null ? out.content : ''; }
+      result(id, partsText(out), err); for (let i = 1; i < ((cx.more || {})[id] || 0); i++) result(id + ':' + i, '', err);
+      return;
+    }
+    if (p.type === 'web_search_call' && !cx.items && id) call(id, 'WebSearch', { query: (p.action && p.action.query) || '' });
+  };
+}
+module.exports = { PROJ, home, dirKey, sessions, row, fileOf, inProject, projectLabel, title, boardRow, parser };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@double_geste/agent-standup",
-  "version": "1.26.0",
-  "description": "Your Claude Code agents as a live video call, from the terminal: a local page in your browser, plus one-line status for status bars. Free, open source, zero token cost.",
+  "version": "1.28.0",
+  "description": "Your Claude Code and Codex agents as a live video call, from the terminal: a local page in your browser, plus one-line status for status bars. Free, open source, zero token cost.",
   "bin": {
     "agent-standup": "bin/agent-standup.js"
   },
@@ -9,6 +9,7 @@
   "files": [
     "bin",
     "server.js",
+    "codex.js",
     "kokoro.js",
     "kokoro-worker.js",
     "demo.js",
@@ -33,6 +34,7 @@
   "keywords": [
     "claude-code",
     "claude",
+    "codex",
     "agents",
     "sub-agents",
     "monitoring",

package/public/index.html

@@ -343,7 +343,6 @@ const SUPPORT = { url: 'https://www.buymeacoffee.com/bored_dev_and_his_robots' }
 const CID = Math.random().toString(36).slice(2, 12);   // identifies this window for the audio-ownership handshake
 const Q = new URLSearchParams(location.search);
 const EMBED = Q.get('embed') === '1' || window.parent !== window;
-if (Q.get('pin')) S.pin = Q.get('pin');
 
 let prefs = { lang: 'en', voice: true, roster: true, banter: true, reactions: false, office: false, officeVol: 0.8, vstyle: 'cartoon', notify: false, epi: false, vanish: true, music: false, station: 'fip', musicVol: 0.35, view: 'call', hideCode: false };
 { let loc = {}; try { loc = JSON.parse(localStorage.getItem('cc.prefs') || '{}') || {}; } catch {}   // the settings file (shared by every window) and this origin's copy: the more recent one wins
@@ -355,7 +354,7 @@ let prefsTimer = null;
 const savePrefs = () => { prefs._t = Date.now(); try { localStorage.setItem('cc.prefs', JSON.stringify(prefs)); } catch {} clearTimeout(prefsTimer); prefsTimer = setTimeout(() => { fetch('/api/prefs', { method: 'PUT', headers: { 'content-type': 'application/json' }, body: JSON.stringify(prefs) }).catch(() => {}); }, 400); };
 // Languages: French and English live in the code as pairs L(french, english); every other language is a catalogue public/locales/<code>.json mapping the English text to its translation.
 // A missing string falls back to English, so a half-translated language still works. See public/locales/README.md to add one.
-const LANGS = [['en', 'English', 'en'], ['fr', 'Français', 'fr'], ['zh-TW', '繁體中文', 'zh-Hant-TW'], ['zh-CN', '简体中文', 'zh-Hans-CN'], ['es', 'Español', 'es'], ['de', 'Deutsch', 'de'], ['da', 'Dansk', 'da'], ['pt-BR', 'Português (Brasil)', 'pt-BR'], ['ja', '日本語', 'ja']];
+const LANGS = [['en', 'English', 'en'], ['fr', 'Français', 'fr'], ['zh-TW', '繁體中文', 'zh-Hant-TW'], ['zh-CN', '简体中文', 'zh-Hans-CN'], ['es', 'Español', 'es'], ['de', 'Deutsch', 'de'], ['da', 'Dansk', 'da'], ['pt-BR', 'Português (Brasil)', 'pt-BR'], ['ja', '日本語', 'ja'], ['ko', '한국어', 'ko']];
 let LOC = {};
 const FR = () => prefs.lang === 'fr';
 const FR_W = /\b(le|la|les|des|une|un|et|est|pour|dans|que|qui|pas|sur|avec|je|tu|nous|vous|ce|cette|ça|du|au|aux|mais|sont|été|fait|plus|ne|ont|il|elle|ils|elles|très|aussi|donc|bien|tout|voici|voilà|merci|oui|non|comme|où|déjà|encore)\b/gi, EN_W = /\b(the|and|is|are|to|of|in|that|with|for|this|it|on|you|we|not|have|has|was|be|will|can|from|your|at|as|but|all|now|also|done|here|there|which|what|then|just|so)\b/gi;
@@ -414,7 +413,7 @@ function renderCharInfo() {
 function persona(a) { const p = persona0(a); p.custom = customFor(a.id); return p; }
 function persona0(a) {
   const h = hash(a.id), base = { ...a };
-  if (a.id === 'main') return { ...base, name: 'Claude', role: L('Chef', 'Lead'), shirt: '#e8845f', shape: 0, acc: 1, eye: 0, glasses: false, scene: 6, prop: 1, acc2: '#f5c04a', lead: true, vi: 0, gid: 'main' };
+  if (a.id === 'main') return { ...base, name: a.name || 'Claude', role: L('Chef', 'Lead'), shirt: '#e8845f', shape: 0, acc: 1, eye: 0, glasses: false, scene: 6, prop: 1, acc2: '#f5c04a', lead: true, vi: 0, gid: 'main' };
   if (a.id === 'user') return { ...base, name: L('Vous', 'You'), role: L('Humain', 'Human'), shirt: '#8a94c9', shape: 1, acc: 2, eye: 1, glasses: false, scene: 7, prop: 1, acc2: '#ff7a6b', vi: 3, gid: 'user' };
   return { ...base, name: a.name || uniqueName(a.id, h), roleEn: a.roleEn || a.role, role: (FR() && a.roleFr) || a.roleEn || a.role, shirt: PAL[(h >>> 6) % 8], shape: (h >>> 3) % 5, acc: (h >>> 9) % 6, eye: (h >>> 12) % 3, glasses: ((h >>> 15) % 4) === 0,
            scene: (h >>> 18) % 6, prop: (h >>> 21) % 3, acc2: PAL[(h >>> 24) % 8], vi: h >>> 4, gid: h.toString(36) };
@@ -525,6 +524,7 @@ function avatarSVG(p, o, uid = '') {   // uid keeps SVG ids unique per instance:
 const S = { owner: null, errRun: {}, exQ: [], agents: {}, events: [], idx: 0, playing: false, token: 0, status: {}, tc: {}, cur: null, live: true, userPaused: false, boost: 1, stopAt: 0,
             speakers: new Set(), say: {}, lastTool: {}, level: {}, detail: null, collapsed: new Set(), title: '', idle: false, locked: true, logTo: 0, trOk: true,
             clock: 0, doneAt: {}, gone: new Set(), leaving: new Set(), demo: false, hold: false, late: [], byK: new Map(), pos: 0 };
+if (Q.get('pin')) S.pin = Q.get('pin');   // a session asked for in the address (the status bar opens the call on one): set here, once S exists (set above it, it stopped the whole page)
 const VANISH_MS = 120000;   // a finished agent leaves the call after 2 minutes (playback time)
 // Live: how far the call is behind the real session, and what to do about it (speak faster, say less, skip decoration) so it keeps the rhythm of the real conversation
 const lagMs = (i = S.idx) => {   // how much newer the newest event of the session is than the one being played: 0 when the call is up to date, however long the session has been idle
@@ -1041,7 +1041,7 @@ const applyStatus = (ev) => {
   if (ev.kind === 'user' || (ev.agent === 'main' && (ev.kind === 'say' || ev.kind === 'tools' || (ev.kind === 'order' && !ev.wf)))) S.turnOver = !!ev.end;   // Claude Code marks the message that closes the lead's turn; anything after it opens the next one (not the agents a workflow launches by itself)
 };
 function recomputeStatus(upTo) {
-  S.term = {}; S.todos = {}; S.run = {}; S.act = {}; S.usage = {}; S.errs = {}; S.lastAct = {}; S.waitOn = {}; S.orderTs = {}; S.prevState = {}; S.lastTool = {}; S.mainBusyAt = 0; S.turnOver = false; S.th = {}; S.ctx = {}; S.model = {}; S.compacts = {}; S.ctxWarned = {}; S.rep = {}; S.loops = {}; S.recomputing = true; document.querySelectorAll('.tile').forEach((t) => { clearTimeout(t._byeT); t.classList.remove('bye'); }); hidePresent();
+  S.term = {}; S.todos = {}; S.run = {}; S.act = {}; S.usage = {}; S.errs = {}; S.lastAct = {}; S.waitOn = {}; S.orderTs = {}; S.prevState = {}; S.lastTool = {}; S.mainBusyAt = 0; S.turnOver = false; S.th = {}; S.ctx = {}; S.model = {}; S.cw = {}; S.compacts = {}; S.ctxWarned = {}; S.rep = {}; S.loops = {}; S.recomputing = true; document.querySelectorAll('.tile').forEach((t) => { clearTimeout(t._byeT); t.classList.remove('bye'); }); hidePresent();
   S.status = {}; S.tc = {}; S.doneAt = {}; S.gone.clear(); S.leaving.clear(); document.querySelectorAll('.tile.vanishing').forEach((t) => t.classList.remove('vanishing')); const doneIdx = {}; document.querySelectorAll('.ticker').forEach((x) => { x.classList.remove('on'); x.innerHTML = ''; });
   for (let i = 0; i < upTo; i++) {
     const e = S.events[i]; applyStatus(e); tally(e); if (e.kind === 'tools') S.tc[e.agent] = (S.tc[e.agent] || 0) + e.tools.length;
@@ -1060,7 +1060,7 @@ function syncUI() {
 
 // ---------- tool ticker, shared screen, flying messages ----------
 // ---------- what each agent is doing: tool calls with their real outputs ----------
-S.term = {}; S.todos = {}; S.run = {}; S.act = {}; S.usage = {}; S.errs = {}; S.lastAct = {}; S.waitOn = {}; S.orderTs = {}; S.prevState = {}; S.ctx = {}; S.model = {}; S.compacts = {}; S.ctxWarned = {}; S.rep = {}; S.loops = {}; S.present = null; S.camFor = null; let presentTimer = null;
+S.term = {}; S.todos = {}; S.run = {}; S.act = {}; S.usage = {}; S.errs = {}; S.lastAct = {}; S.waitOn = {}; S.orderTs = {}; S.prevState = {}; S.ctx = {}; S.model = {}; S.cw = {}; S.compacts = {}; S.ctxWarned = {}; S.rep = {}; S.loops = {}; S.present = null; S.camFor = null; let presentTimer = null;
 const later = (k, fn, ms = 160) => { later.p = later.p || {}; if (later.p[k]) return; later.p[k] = setTimeout(() => { later.p[k] = 0; fn(); }, ms); };   // coalesce bursts of repaints
 const fmtTok = (n) => (n < 1000 ? String(n) : n < 1e6 ? (n / 1000).toFixed(n < 1e4 ? 1 : 0) + 'k' : (n / 1e6).toFixed(n < 1e7 ? 2 : 1) + 'M');
 const tokTotal = (u) => (u ? u.i + u.o + u.w : 0);   // headline = input + output + cache writes; cache reads are cheap and shown separately
@@ -1078,14 +1078,14 @@ function ctxWin(model, ctx) { const base = WIN1M.test(model || '') ? 1e6 : 2e5;
 function tally(ev) {   // numbers that pile up over a session: token usage, errors, last sign of life
   if (ev.kind === 'compact') { S.compacts[ev.agent] = (S.compacts[ev.agent] || 0) + 1; delete S.ctxWarned[ev.agent]; }
   const det = loopStep(S.rep, ev); if (det) { S.loops[ev.agent] = det; later('badges', renderBadges, 300); } else if (S.loops[ev.agent] && (ev.kind === 'results' ? (S.loops[ev.agent].kind === 'errors' && ev.items.every((it) => !it.err)) : (ev.kind === 'tools' && S.rep[ev.agent].n < 2))) { delete S.loops[ev.agent]; later('badges', renderBadges, 300); }
-  if (ev.kind === 'usage') { const c = ev.u.i + ev.u.r + ev.u.w; if (c > 0 && ev.model !== '<synthetic>') { S.ctx[ev.agent] = c; S.model[ev.agent] = ev.model; later('tok', renderCtx, 300); } const u = (S.usage[ev.agent] = S.usage[ev.agent] || { i: 0, o: 0, r: 0, w: 0 }); u.i += ev.u.i; u.o += ev.u.o; u.r += ev.u.r; u.w += ev.u.w; later('tok', renderTokens, 300); }
+  if (ev.kind === 'usage') { const c = ev.u.i + ev.u.r + ev.u.w; if (c > 0 && ev.model !== '<synthetic>') { S.ctx[ev.agent] = c; S.model[ev.agent] = ev.model; if (ev.cw) S.cw[ev.agent] = ev.cw; later('tok', renderCtx, 300); } const u = (S.usage[ev.agent] = S.usage[ev.agent] || { i: 0, o: 0, r: 0, w: 0 }); u.i += ev.u.i; u.o += ev.u.o; u.r += ev.u.r; u.w += ev.u.w; later('tok', renderTokens, 300); }
   else if (ev.kind === 'results') ev.items.forEach((it) => { if (it.err) { S.errs[ev.agent] = (S.errs[ev.agent] || 0) + 1; later('badges', renderBadges, 300); oops(ev.agent); noteTrouble(ev.agent, false); } else noteTrouble(ev.agent, true); });
   else if (ev.kind === 'tools' || ev.kind === 'say') S.lastAct[ev.agent] = ev.ts;
   if (ev.th) S.th[ev.agent] = { text: ev.th, ts: ev.ts }; else if (ev.kind === 'user') delete S.th.main;   // your order starts a new chain of thought: what the lead thought before is no longer what it is on
   if (ev.kind === 'results') S.lastAct[ev.agent] = ev.ts; else if (ev.kind === 'user') S.lastAct.main = ev.ts;   // a result coming back and your own order are signs of life too: the lead is thinking about them
 }
 const tokTip = (u) => `${L('Jetons enregistrés par Claude Code (comptés une fois par message, ce n’est pas une facture)', 'Tokens recorded by Claude Code (counted once per message, not a bill)')}\n${L('entrée', 'input')} ${fmtTok(u.i)} · ${L('sortie', 'output')} ${fmtTok(u.o)} · ${L('écriture cache', 'cache write')} ${fmtTok(u.w)} · ${L('lecture cache', 'cache read')} ${fmtTok(u.r)}`;
-const ctxInfo = (id) => { const c = S.ctx[id]; if (!c) return null; const w = ctxWin(S.model[id], c), p = Math.round((c / w) * 100); return { c, w, p, lvl: p >= 88 ? 'hi' : p >= 70 ? 'mid' : 'lo' }; };
+const ctxInfo = (id) => { const c = S.ctx[id]; if (!c) return null; const w = S.cw[id] || ctxWin(S.model[id], c), p = Math.round((c / w) * 100); return { c, w, p, lvl: p >= 88 ? 'hi' : p >= 70 ? 'mid' : 'lo' }; };
 function renderCtx() {   // "context N% full": per agent chip (from 50%), a header chip for the lead, and one warning before auto-compaction
   for (const id in S.agents) { const t = $('#t-' + id); if (!t) continue; const el = t.querySelector('.cx'), x = ctxInfo(id);
     if (el) { if (x && x.p >= 50) { el.textContent = `ctx ${x.p}%`; el.className = 'cx ' + x.lvl; el.title = `${L('Contexte', 'Context')}: ${fmtTok(x.c)} / ${fmtTok(x.w)}`; } else { el.textContent = ''; el.className = 'cx'; } }
@@ -1912,7 +1912,7 @@ async function loadSession(proj, id) {
   if (proj === '_demo') S.events.forEach((e) => { if (e.fr) trMem.set(baseText(e), e.fr); });   // the demo ships its own French
   $('#subtitle').textContent = S.title; recomputeStatus(0); buildStage(); renderHighlights(); setFocus('main'); renderLog(true); computeGantt(); layout(); paintStatus(); prefetchTr(0); return true;
 }
-const niceProj = (p) => (p === '_demo' ? '' : String(p).replace(/^-+/, '').replace(/-/g, '/').split('/').slice(-2).join('/'));
+const niceProj = (p) => (p === '_demo' ? '' : p === '_codex' ? 'Codex' : String(p).replace(/^-+/, '').replace(/-/g, '/').split('/').slice(-2).join('/'));
 async function fillProjects() {   // live view: follow the latest activity anywhere, or pin one project
   const sel = $('#liveProj'); let rows = []; try { rows = await (await fetch('/api/projects')).json(); } catch {}
   sel.innerHTML = `<option value="">${L('Tous les projets (le plus récent)', 'All projects (most recent)')}</option>` + rows.map((r) => `<option value="${esc(r.proj)}">${esc(niceProj(r.proj))}</option>`).join('');

package/public/locales/ko.json

@@ -0,0 +1,221 @@
+{
+ "_meta": {
+  "language": "ko",
+  "reviewed": false,
+  "note": "AI draft, native review welcome"
+ },
+ " full — compaction soon": " 사용 — 곧 압축됩니다",
+ "”": "”",
+ "↗ Open in browser": "↗ 브라우저에서 열기",
+ "▶ Join": "▶ 참가",
+ "▶ Watch the demo": "▶ 데모 보기",
+ "☕ Buy the (replaced) dev a coffee": "☕ (일자리를 잃은) 개발자에게 커피 사 주기",
+ "🎞 Export video": "🎞 동영상 내보내기",
+ "🎬 Clip to share (25 s)": "🎬 공유용 클립 (25초)",
+ "📋 Recap": "📋 요약",
+ "Agent voices": "에이전트 목소리",
+ "Agents": "에이전트",
+ "Agents list (left)": "에이전트 목록 (왼쪽)",
+ "All projects (most recent)": "모든 프로젝트 (최신순)",
+ "Ambience volume": "환경음 볼륨",
+ "An agent may be waiting for you ✋": "에이전트가 기다리고 있을 수 있어요 ✋",
+ "Animal Crossing (babble)": "Animal Crossing (옹알이)",
+ "Asking a question": "질문하는 중",
+ "brief": "지시",
+ "Busiest agents": "가장 바쁜 에이전트",
+ "Buy a coffee": "커피 사 주기",
+ "cache read": "캐시 읽기",
+ "cache write": "캐시 쓰기",
+ "Call": "통화",
+ "Cartoon voices (real voice)": "만화 목소리 (실제 음성)",
+ "Claude Code is not logged in: run “claude” once in a terminal to sign in.": "Claude Code에 로그인되어 있지 않습니다. 터미널에서 “claude”를 한 번 실행해 로그인하세요.",
+ "Claude Code not found: install it (npm i -g @anthropic-ai/claude-code) or set its path in the “agentStandup.claudePath” setting.": "Claude Code를 찾을 수 없습니다. 설치하거나(npm i -g @anthropic-ai/claude-code) “agentStandup.claudePath” 설정에 경로를 지정하세요.",
+ "Click to enable sound and follow your Claude Code session live.": "클릭하면 소리가 켜지고 Claude Code 세션을 실시간으로 따라갑니다.",
+ "Close": "닫기",
+ "commands": "명령",
+ "compaction": "압축",
+ "Context": "컨텍스트",
+ "context ": "컨텍스트 ",
+ "context compacted 🗜": "컨텍스트 압축됨 🗜",
+ "Copied": "복사했습니다",
+ "Copy as Markdown": "Markdown으로 복사",
+ "Copy failed": "복사 실패",
+ "Demo — a team fixes a slow login": "데모 — 팀이 느린 로그인을 고칩니다",
+ "done": "완료",
+ "Done": "완료",
+ "Done. ": "완료. ",
+ "duration": "소요 시간",
+ "Editing ": "편집 중: ",
+ "Editor": "편집기",
+ "EPISODE 1": "제1화",
+ "Episode recap": "에피소드 요약",
+ "errors": "오류",
+ "failing in a loop?": "실패를 반복하는 중?",
+ "Fetching ": "가져오는 중: ",
+ "files": "파일",
+ "Files": "파일",
+ "files changed": "변경된 파일",
+ "Files touched": "건드린 파일",
+ "Final report": "최종 보고",
+ "first error": "첫 오류",
+ "Hide code & file names in videos": "동영상에서 코드와 파일 이름 숨기기",
+ "Highlights": "하이라이트",
+ "Human": "사람",
+ "idle": "유휴",
+ "input": "입력",
+ "is sharing their screen": "님이 화면 공유 중",
+ "Join the call": "통화 참가",
+ "Language": "언어",
+ "Lead": "메인 에이전트",
+ "Lead context": "메인 에이전트 컨텍스트",
+ "left the call": "님이 통화에서 나갔습니다",
+ "lines": "줄",
+ "Listing ": "목록 보는 중: ",
+ "Little lines & animations": "짧은 대사와 애니메이션",
+ "longest wait ": "최장 대기 ",
+ "Looking for a tool": "도구 찾는 중",
+ "looping?": "반복 중?",
+ "Music volume": "음악 볼륨",
+ "Natural voices": "자연스러운 목소리",
+ "need you": "응답 필요",
+ "needs you?": "호출 중?",
+ "needs you? ": "호출 중? ",
+ "No agents were harmed.": "이 과정에서 다친 에이전트는 없습니다.",
+ "No edits.": "편집 없음.",
+ "No French voice installed (Windows: Settings › Time & language › Speech).": "프랑스어 음성이 설치되어 있지 않습니다 (Windows: 설정 › 시간 및 언어 › 음성).",
+ "No recent session": "최근 세션 없음",
+ "No setting found": "일치하는 설정 없음",
+ "No system voice found: agents will mumble.": "시스템 음성을 찾을 수 없습니다. 에이전트가 웅얼거립니다.",
+ "Notify me when agents finish": "에이전트가 끝나면 알림",
+ "Office ambience (keys, coffee…)": "사무실 환경음 (키보드, 커피…)",
+ "Office music (FIP radio)": "사무실 음악 (FIP 라디오)",
+ "OFFLINE": "오프라인",
+ "Opening file…": "파일 여는 중…",
+ "output": "출력",
+ "Pause / Play (space)": "일시정지 / 재생 (스페이스)",
+ "PAUSED": "일시정지됨",
+ "Project to follow": "따라갈 프로젝트",
+ "Prompt from": "프롬프트 보낸 이:",
+ "Radio unreachable: check your connection or pick another station.": "라디오에 연결할 수 없습니다. 연결을 확인하거나 다른 방송국을 선택하세요.",
+ "Reactions": "리액션",
+ "Reactions & jokes": "리액션과 농담",
+ "Reactions bar (👍 👏 ☕)": "리액션 바 (👍 👏 ☕)",
+ "read-only": "읽기 전용",
+ "Reading ": "읽는 중: ",
+ "READY": "준비 완료",
+ "Recent activity": "최근 활동",
+ "Remove finished agents (2 min)": "끝난 에이전트 제거 (2분 후)",
+ "Repeated failures": "반복된 실패",
+ "report": "보고",
+ "report to": "보고 대상:",
+ "Role": "역할",
+ "running": "실행 중",
+ "Running ": "실행 중: ",
+ "running…": "실행 중…",
+ "Said": "발언",
+ "Same call repeated": "같은 호출 반복",
+ "Search the transcript": "대화 기록 검색",
+ "Search…": "검색…",
+ "Searching “": "검색 중: “",
+ "session": "세션",
+ "Sessions": "세션",
+ "Settings": "설정",
+ "Simlish (babble)": "Simlish (옹알이)",
+ "Sound": "소리",
+ "Sound (M key)": "소리 (M 키)",
+ "Sound is playing in another Agent Standup window. Click 🔈 to take it over here.": "다른 Agent Standup 창에서 소리가 재생 중입니다. 🔈 를 클릭하면 이 창으로 가져옵니다.",
+ "Sound is playing in another window — click to take it over here": "다른 창에서 소리가 재생 중입니다 — 클릭하면 이 창으로 가져옵니다",
+ "Source": "소스",
+ "Speed": "속도",
+ "stalled": "멈춤",
+ "stalled · ": "멈춤 · ",
+ "standing by": "대기 중",
+ "Start Claude Code in this folder — the call will start by itself.": "이 폴더에서 Claude Code를 시작하세요 — 통화가 자동으로 시작됩니다.",
+ "Start Claude Code in {0} — the call will start by itself.": "{0}에서 Claude Code를 시작하세요 — 통화가 자동으로 시작됩니다.",
+ "sub-agents active": "서브에이전트 활동 중",
+ "task": "작업",
+ "Tasks": "작업",
+ "THE END": "끝",
+ "This dev was replaced by his own agents. Spare a coffee for his career change? ☕": "이 개발자는 자기 에이전트들에게 일자리를 빼앗겼습니다. 새 출발을 응원하는 커피 한 잔 어떠세요? ☕",
+ "Time": "시간",
+ "to": "대상:",
+ "tokens": "토큰",
+ "Tokens": "토큰",
+ "Tokens recorded by Claude Code (counted once per message, not a bill)": "Claude Code가 기록한 토큰 (메시지당 한 번 집계, 청구 금액 아님)",
+ "tool calls": "도구 호출",
+ "tool errors": "도구 오류",
+ "tools": "도구",
+ "Tools": "도구",
+ "Translation unavailable right now: check that “claude” works in a terminal.": "지금은 번역을 사용할 수 없습니다. 터미널에서 “claude”가 동작하는지 확인하세요.",
+ "Tree": "트리",
+ "Untitled session": "제목 없는 세션",
+ "Updating todo list": "할 일 목록 업데이트 중",
+ "Using skill ": "스킬 사용 중: ",
+ "VS Code was started from inside a Claude Code session: restart VS Code normally (Dock, Spotlight) to enable translation.": "VS Code가 Claude Code 세션 안에서 실행되었습니다. 번역을 사용하려면 VS Code를 일반적인 방법(Dock, Spotlight)으로 다시 시작하세요.",
+ "waiting": "대기 중",
+ "Waiting for a session": "세션을 기다리는 중",
+ "waiting on ": "기다리는 중: ",
+ "waiting on sub-agents": "서브에이전트를 기다리는 중",
+ "Web search": "웹 검색",
+ "working": "작업 중",
+ "Writing ": "작성 중: ",
+ "You": "나",
+ "Your agents are done 🎉": "에이전트 작업이 끝났습니다 🎉",
+ "Your Claude Code agents as a live team call": "Claude Code 에이전트를 실시간 팀 통화로",
+ "your turn": "내 차례",
+ "Characters": "캐릭터",
+ "Reload": "새로고침",
+ "Open folder": "폴더 열기",
+ "custom character(s) loaded": "개의 커스텀 캐릭터를 불러왔습니다",
+ "Drop your pixel art (PNG) in this folder to replace the characters:": "이 폴더에 픽셀 아트(PNG)를 넣으면 캐릭터가 바뀝니다:",
+ "lead.png = the lead · you.png = you · others = the sub-agents · name-talk.png = open mouth": "lead.png = 메인 에이전트 · you.png = 나 · 나머지 = 서브에이전트 · name-talk.png = 입을 벌린 모습",
+ "Downloading, you can carry on: system voices are used meanwhile.": "다운로드 중입니다. 계속 사용하셔도 됩니다. 그동안은 시스템 음성을 사용합니다.",
+ "Good-quality local voices, mostly English (one French voice). Free, nothing leaves your machine.": "품질 좋은 로컬 음성으로, 대부분 영어입니다 (프랑스어 음성은 하나). 무료이며 아무것도 컴퓨터 밖으로 전송되지 않습니다.",
+ "Installing…": "설치 중…",
+ "Loading the model (downloaded on first use, about 305 MB)…": "모델 불러오는 중 (처음 사용할 때 다운로드, 약 305 MB)…",
+ "npm not found: install Node.js to enable this option.": "npm을 찾을 수 없습니다. 이 옵션을 사용하려면 Node.js를 설치하세요.",
+ "The engine stopped: system voices are used instead.": "엔진이 멈췄습니다. 대신 시스템 음성을 사용합니다.",
+ "Very natural voices (installs on demand)": "매우 자연스러운 목소리 (필요할 때 설치)",
+ "Voices ready.": "음성이 준비되었습니다.",
+ "Voice style": "목소리 스타일",
+ "⌨ Keyboard shortcuts (?)": "⌨ 키보드 단축키 (?)",
+ "Keyboard shortcuts": "키보드 단축키",
+ "Mute / unmute": "음소거 / 해제",
+ "Pause / play": "일시정지 / 재생",
+ "Recap": "요약",
+ "This help": "이 도움말",
+ "Transcript": "대화 기록",
+ "Tree view ↔ call": "트리 보기 ↔ 통화",
+ "Tree view: T to go back, ? for help": "트리 보기: T로 돌아가기, ?로 도움말",
+ "You can also switch between Call, Tree and Sessions at the top of the window.": "창 위쪽에서 통화, 트리, 세션을 전환할 수도 있습니다.",
+ "Display": "표시",
+ "Search settings…": "설정 검색…",
+ "may be waiting for your approval": "승인을 기다리고 있을 수 있습니다",
+ "Next / previous agent that needs you": "응답이 필요한 다음 / 이전 에이전트",
+ "Nobody needs you right now": "지금 응답을 기다리는 에이전트가 없습니다",
+ "stalled: a sub-agent has been silent for a long time": "멈춤: 서브에이전트가 오랫동안 조용합니다",
+ "waiting on another agent": "다른 에이전트를 기다리는 중",
+ "What the states mean": "상태의 의미",
+ "Find a session": "세션 찾기",
+ "Find a session…": "세션 찾기…",
+ "Go to a session": "세션으로 이동",
+ "No highlight in this session": "이 세션에는 하이라이트가 없습니다",
+ "Replay: next / previous highlight": "다시 보기: 다음 / 이전 하이라이트",
+ "Replay: previous / next event": "다시 보기: 이전 / 다음 이벤트",
+ "Resumed where you left off": "마지막으로 본 곳부터 이어서 재생합니다",
+ "Chatter between agents": "에이전트 간 잡담",
+ "Lively": "활발하게",
+ "Normal": "보통",
+ "nothing to report": "보고할 것 없음",
+ "Quiet": "조용하게",
+ "Laptop in front of your own characters": "내 캐릭터 앞에 노트북 놓기",
+ "Also ": "또한 ",
+ " on ": " → ",
+ "To sum up: ": "정리하면: ",
+ "Cat pack": "고양이 팩",
+ "characters from the pack": "개의 팩 캐릭터",
+ "Drawn characters": "기본 캐릭터",
+ "To tweak them, copy them into your folder and pick “My folder”.": "수정하려면 내 폴더에 복사한 뒤 “내 폴더”를 선택하세요.",
+ "My folder": "내 폴더",
+ "The characters drawn by the app. Pick “My folder” for your own images, or a pack.": "앱이 그리는 캐릭터입니다. 직접 만든 이미지를 쓰려면 “내 폴더”를, 아니면 팩을 선택하세요."
+}

package/server.js

@@ -6,6 +6,7 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const crypto = require('crypto');
+const codex = require('./codex.js');     // Codex sessions, read as the same call (see codex.js)
 const kokoro = require('./kokoro.js');   // natural voices, installed on demand (see kokoro.js)
 const zlib = require('zlib');
 const { execFileSync } = require('child_process');
@@ -102,8 +103,8 @@ function listSessions() {
 }
 function listSessions0() {
   const rows = [];
-  if (!fs.existsSync(ROOT)) return rows;
-  for (const proj of fs.readdirSync(ROOT)) {
+  for (const r of codex.sessions(30)) rows.push({ proj: codex.PROJ, id: r.id, mtime: r.mtime, size: r.size, agents: 0, cx: r });
+  for (const proj of fs.existsSync(ROOT) ? fs.readdirSync(ROOT) : []) {
     const dir = path.join(ROOT, proj);
     let files;
     try { files = fs.readdirSync(dir).filter((f) => f.endsWith('.jsonl')); } catch { continue; }
@@ -114,8 +115,10 @@ function listSessions0() {
     }
   }
   rows.sort((a, b) => b.mtime - a.mtime);
-  const top = rows.slice(0, 60);
-  for (const r of top) {   // titles come from the cached tail read (custom title, then AI title, then first prompt): no whole-file reads
+  const top = rows.filter((r) => !r.cx).slice(0, 60).concat(rows.filter((r) => r.cx)).sort((a, b) => b.mtime - a.mtime);   // the 60 most recent Claude Code sessions as always, and up to 30 Codex ones beside them: neither pushes the other out
+  for (const r of top) {
+    if (r.cx) { const c = r.cx; delete r.cx; r.title = codex.title(c); r.project = codex.projectLabel(c.cwd); r.source = 'codex'; continue; }
+    // titles come from the cached tail read (custom title, then AI title, then first prompt): no whole-file reads
     let t = null; try { const f = path.join(ROOT, r.proj, r.id + '.jsonl'); t = parseTail(f, fs.statSync(f)).title; } catch {}
     r.title = t || r.id; r.project = r.proj.replace(/^-Users-[^-]+-/, '').replace(/-/g, '/');
   }
@@ -125,7 +128,7 @@ function listSessions0() {
 function stamp(proj, id) {
   const base = path.join(ROOT, proj); let n = 0;
   const add = (f) => { try { const s = fs.statSync(f); n += s.mtimeMs + s.size; } catch {} };
-  add(path.join(base, id + '.jsonl'));
+  add(proj === codex.PROJ ? codex.fileOf(id) || '' : path.join(base, id + '.jsonl'));
   const subs = subFiles(proj, id);   // the transcripts and the folders they are in (a folder changes when a file appears in it, e.g. an agent's meta file), not every file around them
   for (const x of subs) add(x.file); for (const x of subs.journals) add(x.file); for (const d of subs.dirs) n += mtimeOf(d);
   return n;
@@ -210,13 +213,14 @@ function boardRows() {
 }
 function boardRows0() {
   const now = Date.now(), rows = [];
-  if (!fs.existsSync(ROOT)) return rows;
-  for (const proj of fs.readdirSync(ROOT)) {
+  for (const r of codex.sessions()) if (now - r.mtime < 12 * 3600e3) rows.push({ proj: codex.PROJ, id: r.id, st: { mtimeMs: r.mtime, size: r.size }, cx: r });
+  for (const proj of fs.existsSync(ROOT) ? fs.readdirSync(ROOT) : []) {
     const dir = path.join(ROOT, proj); let files; try { files = fs.readdirSync(dir).filter((f) => f.endsWith('.jsonl')); } catch { continue; }
     for (const f of files) { try { const st = fs.statSync(path.join(dir, f)); if (now - st.mtimeMs < 12 * 3600e3) rows.push({ proj, id: f.slice(0, -6), st }); } catch {} }
   }
   rows.sort((a, b) => b.st.mtimeMs - a.st.mtimeMs);
-  return rows.slice(0, 40).map(({ proj, id, st }) => {
+  return rows.filter((r) => !r.cx).slice(0, 40).concat(rows.filter((r) => r.cx).slice(0, 20)).sort((a, b) => b.st.mtimeMs - a.st.mtimeMs).map(({ proj, id, st, cx }) => {
+    if (cx) return codex.boardRow(cx, now);
     const file = path.join(ROOT, proj, id + '.jsonl'); let p; try { p = parseTail(file, st); } catch { p = { pending: [] }; }
     const age = now - st.mtimeMs, lp = (p.pending || [])[(p.pending || []).length - 1]; let state = 'idle', tool = '', ageMs = age;
     if (age < 30 * 60e3) {
@@ -237,17 +241,18 @@ function writePrefs(v) { fs.mkdirSync(path.dirname(PREFS), { recursive: true });
 // Most recently active session (optionally limited to one project dir) — drives the live feed.
 const STICK_MS = 90000;   // a session written to in the last 90 s keeps the call, so another session writing elsewhere does not steal it mid-line
 function sessionMtime(proj, id) {
+  if (proj === codex.PROJ) { const r = codex.row(id); return r ? r.mtime : 0; }
   let m = mtimeOf(path.join(ROOT, proj, id + '.jsonl')); if (!m) return 0; const subs = subFiles(proj, id);
   for (const x of subs) m = Math.max(m, mtimeOf(x.file)); for (const d of subs.dirs) m = Math.max(m, mtimeOf(d)); return m;   // the folders too: a new file in them is activity, as when every file around the transcripts was looked at
 }
 function currentSession(projFilter, idFilter, stick) {
   const safe = (x) => typeof x === 'string' && /^[\w.\-]+$/.test(x) && x !== '..';
-  if (stick && safe(stick.id) && safe(stick.proj) && (!projFilter || stick.proj === projFilter || stick.proj.startsWith(projFilter + '-')) && Date.now() - sessionMtime(stick.proj, stick.id) < STICK_MS) return { proj: stick.proj, id: stick.id, mtime: sessionMtime(stick.proj, stick.id) };
-  if (idFilter && projFilter && projFilter !== '..' && idFilter !== '..' && /^[\w.\-]+$/.test(idFilter) && /^[\w.\-]+$/.test(projFilter) && fs.existsSync(path.join(ROOT, projFilter, idFilter + '.jsonl'))) return { proj: projFilter, id: idFilter, mtime: Date.now() };   // pinned from the board
+  if (stick && safe(stick.id) && safe(stick.proj) && (!projFilter || stick.proj === projFilter || stick.proj.startsWith(projFilter + '-') || (stick.proj === codex.PROJ && codex.inProject(stick.id, projFilter))) && Date.now() - sessionMtime(stick.proj, stick.id) < STICK_MS) return { proj: stick.proj, id: stick.id, mtime: sessionMtime(stick.proj, stick.id) };
+  if (idFilter && projFilter && projFilter !== '..' && idFilter !== '..' && /^[\w.\-]+$/.test(idFilter) && /^[\w.\-]+$/.test(projFilter) && (projFilter === codex.PROJ ? !!codex.fileOf(idFilter) : fs.existsSync(path.join(ROOT, projFilter, idFilter + '.jsonl')))) return { proj: projFilter, id: idFilter, mtime: Date.now() };   // pinned from the board
   let best = null;
-  if (!fs.existsSync(ROOT)) return {};
   const consider = (proj, id, m) => { if (!best || m > best.mtime) best = { proj, id, mtime: m }; };
-  for (const proj of fs.readdirSync(ROOT)) {
+  for (const r of codex.sessions()) if (!projFilter || codex.inProject(r.id, projFilter)) consider(codex.PROJ, r.id, r.mtime);   // a Codex session counts for a project when it was started in that folder
+  for (const proj of fs.existsSync(ROOT) ? fs.readdirSync(ROOT) : []) {
     if (projFilter && proj !== projFilter && !proj.startsWith(projFilter + '-')) continue;   // the folder itself, or a folder inside it
     const dir = path.join(ROOT, proj); let files;
     try { files = fs.readdirSync(dir); } catch { continue; }
@@ -267,7 +272,7 @@ let fileGen = 0;   // each time a transcript is read from its start it gets a ne
 const sameBytes = (file, st) => {   // are the last bytes we read still where we read them? If not, the file was rewritten and not appended to
   let fd; try { fd = fs.openSync(file, 'r'); const b = Buffer.alloc(st.fp.length); fs.readSync(fd, b, 0, b.length, st.offset - b.length); return b.equals(st.fp); } catch { return false; } finally { if (fd != null) fs.closeSync(fd); }
 };
-function readNew(file, agent, journal) {
+function readNew(file, agent, journal, record = parseRecord) {
   let size, mtime; try { const s = fs.statSync(file); size = s.size; mtime = s.mtimeMs; } catch { fileStates.delete(file); return null; }
   let st = fileStates.get(file);
   if (st && size >= st.offset && mtime !== st.mtime && st.fp.length && !sameBytes(file, st)) st = null;   // rewritten in place and not shorter: checked only when the file was written to, with one small read
@@ -284,7 +289,7 @@ function readNew(file, agent, journal) {
       if (!line) continue;
       let r; try { r = JSON.parse(line); } catch { continue; }
       if (!r || typeof r !== 'object') continue;
-      try { parseRecord(st, r); } catch {}   // one odd record must not take the whole timeline down
+      try { record(st, r); } catch {}   // one odd record must not take the whole timeline down
     }
   }
   return st;
@@ -341,16 +346,17 @@ function parseRecord(st, r) {
     }
   }
 }
+const codexRecord = codex.parser({ toolLabel, clip, resultMax: RESULT_MAX });
 const metaCache = new Map();   // meta file path → { mtime, value }
 function readMeta(f) {
   try { const mt = fs.statSync(f).mtimeMs, c = metaCache.get(f); if (c && c.mtime === mt) return c.value; const v = JSON.parse(fs.readFileSync(f, 'utf8')); if (metaCache.size > 3000) metaCache.clear(); metaCache.set(f, { mtime: mt, value: v }); return v; } catch { return {}; }
 }
 
 function buildTimeline(proj, id, files = []) {
-  const base = path.join(ROOT, proj), mainFile = path.join(base, id + '.jsonl');
+  const cx = proj === codex.PROJ, base = path.join(ROOT, proj), mainFile = cx ? codex.fileOf(id) || '' : path.join(base, id + '.jsonl');   // a Codex session is one file somewhere else, in another format (codexRecord); from here on it is a session like any other, without sub-agents
   if (!fs.existsSync(mainFile)) throw new Error('session not found');
-  const agents = { main: { id: 'main', role: 'Lead', type: 'main' } };
-  const states = [readNew(mainFile, 'main')], subs = subFiles(proj, id), runs = {}; files.push(mainFile);   // runs: workflow run → { agents (file name → agent id), by (who launched it), toolId, done }
+  const agents = { main: { id: 'main', role: 'Lead', type: 'main', ...(cx ? { name: 'Codex' } : {}) } };
+  const states = [readNew(mainFile, 'main', false, cx ? codexRecord : parseRecord)], subs = subFiles(proj, id), runs = {}; files.push(mainFile);   // runs: workflow run → { agents (file name → agent id), by (who launched it), toolId, done }
   for (const x of subs) {
     const aid = x.aid, m = readMeta(x.file.replace(/\.jsonl$/, '.meta.json'));
     agents[aid] = { id: aid, role: m.description || m.workflowPhase || m.agentType || 'Agent', type: m.agentType || 'agent', toolUseId: m.toolUseId };
@@ -383,7 +389,7 @@ function buildTimeline(proj, id, files = []) {
       else events.push(e);
     });
     if (run && run.done.has(st.agent) && st.lastTs) finish(st.agent, st.lastTs, parent[st.agent] || 'main');   // the journal has no times: the agent finished when it last wrote
-    for (const [mid, mu] of st.msgUsage) events.push({ ts: mu.ts, agent: st.agent, kind: 'usage', u: mu.u, model: mu.model, k: 'u/' + st.agent + '/' + mid });
+    for (const [mid, mu] of st.msgUsage) events.push({ ts: mu.ts, agent: st.agent, kind: 'usage', u: mu.u, model: mu.model, ...(mu.cw ? { cw: mu.cw } : {}), k: 'u/' + st.agent + '/' + mid });
   }
   for (const e of events) if (e.kind === 'report' && e.to === null) e.to = parent[e.agent] || 'main';
 
@@ -647,7 +653,7 @@ function start(port = PORT) {
     if (url.pathname === '/api/session') {
       const proj = url.searchParams.get('proj') || '', sid = url.searchParams.get('id') || '', SAFE = /^[\w.\-]+$/;
       if (!SAFE.test(proj) || !SAFE.test(sid) || proj === '..' || sid === '..' || proj.length > 200 || sid.length > 200) { res.writeHead(400); return res.end('bad request'); }
-      if (proj !== '_demo' && !fs.existsSync(path.join(ROOT, proj, sid + '.jsonl'))) return json({ error: 'session not found' }, 404);
+      if (proj !== '_demo' && !(proj === codex.PROJ ? codex.fileOf(sid) : fs.existsSync(path.join(ROOT, proj, sid + '.jsonl')))) return json({ error: 'session not found' }, 404);
       const entry = proj === '_demo' ? demoEntry() : timelineEntry(proj, sid), tl = entry.tl;   // built-in fictional session
       const after = url.searchParams.get('after'), ep = url.searchParams.get('ep');
       if (after == null) {   // the whole timeline: serialize once per version, send gzip-compressed when the browser allows it (12 MB → ~1.5 MB)