@clastres/groundcontrol 0.1.5 → 0.1.6

package/daemon.mjs

@@ -54,7 +54,7 @@ if (process.argv.includes('--help') || process.argv.includes('-h')) {
   process.exit(0);
 }
 if (process.argv.includes('--version')) {
-  console.log('0.1.5');
+  console.log('0.1.6');
   process.exit(0);
 }
 
@@ -346,10 +346,27 @@ function widenPath() {
 }
 widenPath();
 
-let claudeBin = null;
-try { claudeBin = execSync('command -v claude', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim() || null; } catch {}
+const which = (cmd) => { try { return execSync(`command -v ${cmd}`, { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim() || null; } catch { return null; } };
+const executable = (p) => { try { fs.accessSync(p, fs.constants.X_OK); return p; } catch { return null; } };
+
+const claudeBin = which('claude');
 console.log(`[daemon] claude binary: ${claudeBin || 'NOT FOUND (phone prompts to idle sessions without a visible terminal will fail)'}`);
 
+// Codex ships a full CLI inside the ChatGPT desktop app, so Codex Desktop
+// users can receive phone prompts even without a standalone install.
+const codexBin = which('codex') || executable('/Applications/ChatGPT.app/Contents/Resources/codex');
+
+// Kimi Code renames a legacy Python `kimi` shim to `kimi-legacy` on install,
+// so when the Kimi Code store (~/.kimi-code) exists, `kimi` on PATH belongs
+// to Kimi Code and `kimi-legacy` is the old CLI. Without the store, `kimi` is
+// the legacy one. The two binaries cannot resume each other's sessions, so
+// neither ever doubles for the other.
+const kimiCodeInstalled = fs.existsSync(path.join(os.homedir(), '.kimi-code'));
+const kimiCodeBin = kimiCodeInstalled
+  ? which('kimi') || executable(path.join(os.homedir(), '.kimi-code', 'bin', 'kimi'))
+  : null;
+const kimiLegacyBin = which('kimi-legacy') || (kimiCodeInstalled ? null : which('kimi'));
+
 // ---------- Claude Code session discovery ----------
 
 const CLAUDE = path.join(os.homedir(), '.claude');
@@ -541,6 +558,11 @@ function extractText(message) {
 function readMessages(sessionId, maxBytes = 512 * 1024, limit = 80) {
   const file = findTranscript(sessionId);
   if (!file) return [];
+  // path.sep keeps the prefixes unambiguous: without it ~/.kimi would also
+  // match every ~/.kimi-code path and routing would depend on check order.
+  if (file.startsWith(CODEX_SESS_DIR + path.sep)) return readCodexMessages(file, maxBytes, limit);
+  if (file.startsWith(KIMICODE_DIR + path.sep)) return readKimiCodeMessages(file, maxBytes, limit);
+  if (file.startsWith(KIMI_DIR + path.sep)) return readKimiLegacyMessages(file, maxBytes, limit);
   let raw;
   try {
     const size = fs.statSync(file).size;
@@ -566,7 +588,7 @@ function readMessages(sessionId, maxBytes = 512 * 1024, limit = 80) {
   return out.slice(-limit);
 }
 
-function readSessions() {
+function readClaudeSessions() {
   const sessions = [];
   let files = [];
   try { files = fs.readdirSync(SESSIONS_DIR); } catch {}
@@ -579,6 +601,7 @@ function readSessions() {
     const tty = ttyOf(s.pid);
     sessions.push({
       id: s.sessionId,
+      provider: 'claude',
       name: s.name || path.basename(s.cwd || '?'),
       cwd: s.cwd || '',
       project: path.basename(s.cwd || '?'),
@@ -590,6 +613,414 @@ function readSessions() {
       live: canInject(tty),
     });
   }
+  return sessions;
+}
+
+// ---------- Codex session discovery ----------
+// Codex (CLI, VS Code extension, and the Codex Desktop app) all write the same
+// rollout JSONL files under ~/.codex/sessions/YYYY/MM/DD/. There is no pid or
+// tty on disk, so a session counts as present while its rollout stays fresh,
+// and busy while its last task_started has no matching end event. Prompts go
+// through `codex exec resume`, which appends to the same rollout file.
+
+const CODEX_DIR = path.join(os.homedir(), '.codex');
+const CODEX_SESS_DIR = path.join(CODEX_DIR, 'sessions');
+const CODEX_INDEX = path.join(CODEX_DIR, 'session_index.jsonl');
+const CODEX_ACTIVE_WINDOW_MS = 2 * 60 * 60 * 1000; // rollout idle this long = off the island
+const CODEX_BUSY_STALE_MS = 10 * 60 * 1000; // a working turn keeps writing; silence means it died
+
+// Codex Desktop names threads ("Polish Slack message"); the index maps id -> name.
+// The index is append-only and grows for as long as Codex is used, so it is
+// only re-parsed when its size or mtime actually moved.
+let codexNames = new Map();
+let codexNamesAt = 0;
+let codexNamesStat = '';
+function codexThreadNames() {
+  if (Date.now() - codexNamesAt < 30_000) return codexNames;
+  codexNamesAt = Date.now();
+  try {
+    const st = fs.statSync(CODEX_INDEX);
+    const sig = `${st.size}:${st.mtimeMs}`;
+    if (sig === codexNamesStat) return codexNames;
+    codexNamesStat = sig;
+    for (const line of fs.readFileSync(CODEX_INDEX, 'utf8').split('\n')) {
+      if (!line.trim()) continue;
+      try {
+        const e = JSON.parse(line);
+        if (e.id && e.thread_name) codexNames.set(e.id, e.thread_name);
+      } catch {}
+    }
+  } catch {}
+  return codexNames;
+}
+
+const codexMetaCache = new Map(); // rollout path -> {size, meta} from the first line
+
+function codexMetaOf(file) {
+  // A parse failure usually means the scan raced Codex mid-write of the first
+  // line, so a failed result is only trusted while the file has not grown;
+  // caching null forever would hide the session for the daemon's lifetime.
+  let size = 0;
+  try { size = fs.statSync(file).size; } catch { return null; }
+  const cached = codexMetaCache.get(file);
+  if (cached && (cached.meta || cached.size === size)) return cached.meta;
+  let meta = null;
+  try {
+    // The first line nests the full system prompt, so it can run past 100KB;
+    // keep reading until the line actually ends.
+    const fd = fs.openSync(file, 'r');
+    const chunks = [];
+    const buf = Buffer.alloc(64 * 1024);
+    for (let pos = 0; pos < 1024 * 1024; ) {
+      const n = fs.readSync(fd, buf, 0, buf.length, pos);
+      if (n === 0) break;
+      chunks.push(Buffer.from(buf.subarray(0, n)));
+      pos += n;
+      if (buf.subarray(0, n).includes(0x0a)) break;
+    }
+    fs.closeSync(fd);
+    const j = JSON.parse(Buffer.concat(chunks).toString('utf8').split('\n')[0]);
+    if (j.type === 'session_meta' && j.payload?.session_id) {
+      meta = {
+        id: j.payload.session_id,
+        cwd: j.payload.cwd || '',
+        startedAt: Date.parse(j.payload.timestamp || j.timestamp) || 0,
+      };
+    }
+  } catch {}
+  codexMetaCache.set(file, { size, meta });
+  return meta;
+}
+
+function tailLines(file, maxBytes) {
+  const size = fs.statSync(file).size;
+  const fd = fs.openSync(file, 'r');
+  const start = Math.max(0, size - maxBytes);
+  const buf = Buffer.alloc(size - start);
+  fs.readSync(fd, buf, 0, buf.length, start);
+  fs.closeSync(fd);
+  return buf.toString('utf8').split('\n');
+}
+
+// Journal scans re-run on every cache refresh; keying results on (mtime, size)
+// makes the rescan free for every file that did not change since last time.
+const scanMemo = new Map(); // key -> {m, s, v}
+function memoScan(key, file, fn) {
+  let st;
+  try { st = fs.statSync(file); } catch { return fn(); }
+  const c = scanMemo.get(key);
+  if (c && c.m === st.mtimeMs && c.s === st.size) return c.v;
+  const v = fn();
+  scanMemo.set(key, { m: st.mtimeMs, s: st.size, v });
+  return v;
+}
+
+// The user_message / agent_message events carry only genuinely typed and
+// spoken turns; injected context blocks only appear as response_items.
+function readCodexMessages(file, maxBytes = 512 * 1024, limit = 80) {
+  let lines;
+  try { lines = tailLines(file, maxBytes); } catch { return []; }
+  const out = [];
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    let e; try { e = JSON.parse(line); } catch { continue; }
+    if (e.type !== 'event_msg') continue;
+    const p = e.payload || {};
+    if (p.type === 'user_message' && p.message) {
+      out.push({ role: 'user', text: String(p.message).trim().slice(0, 4000), ts: e.timestamp || null });
+    } else if (p.type === 'agent_message' && p.message) {
+      out.push({ role: 'assistant', text: String(p.message).trim().slice(0, 4000), ts: e.timestamp || null });
+    }
+  }
+  return out.slice(-limit);
+}
+
+function codexActivityOf(file) {
+  let lines;
+  try { lines = tailLines(file, 64 * 1024); } catch { return { busy: false, sawMarkers: true, lastMessage: null }; }
+  let lastStart = 0, lastEnd = 0, lastMessage = null;
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    let e; try { e = JSON.parse(line); } catch { continue; }
+    if (e.type !== 'event_msg') continue;
+    const p = e.payload || {};
+    const ts = Date.parse(e.timestamp) || 0;
+    if (p.type === 'task_started') lastStart = Math.max(lastStart, ts);
+    else if (p.type === 'task_complete' || p.type === 'task_aborted' || p.type === 'turn_aborted' || p.type === 'error') lastEnd = Math.max(lastEnd, ts);
+    else if (p.type === 'user_message' && p.message) lastMessage = { role: 'user', text: String(p.message).trim().slice(0, 4000), ts: e.timestamp || null };
+    else if (p.type === 'agent_message' && p.message) lastMessage = { role: 'assistant', text: String(p.message).trim().slice(0, 4000), ts: e.timestamp || null };
+  }
+  // No turn markers in the tail means a long streaming turn pushed them out
+  // (a finished turn always ends with its completion event in the tail), so
+  // the caller must treat freshness as the busy signal, not assume idle.
+  return { busy: lastStart > lastEnd, sawMarkers: lastStart > 0 || lastEnd > 0, lastMessage };
+}
+
+// Walking every date dir stays cheap at this scale, and a resumed months-old
+// thread appends to its original file, so no date cutoff during the walk.
+function codexRolloutFiles() {
+  const files = [];
+  const walk = (dir, depth) => {
+    let entries = [];
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      const p = path.join(dir, e.name);
+      if (e.isDirectory() && depth < 3) walk(p, depth + 1);
+      else if (e.isFile() && e.name.endsWith('.jsonl')) files.push(p);
+    }
+  };
+  walk(CODEX_SESS_DIR, 0);
+  return files;
+}
+
+let codexCache = { at: 0, sessions: [] };
+function readCodexSessions() {
+  if (Date.now() - codexCache.at < 10_000) return codexCache.sessions;
+  codexCache.at = Date.now();
+  const names = codexThreadNames();
+  const sessions = [];
+  for (const file of codexRolloutFiles()) {
+    let mtime;
+    try { mtime = fs.statSync(file).mtimeMs; } catch { continue; }
+    if (Date.now() - mtime > CODEX_ACTIVE_WINDOW_MS) continue;
+    const meta = codexMetaOf(file);
+    if (!meta) continue;
+    const act = memoScan(`codex:${file}`, file, () => codexActivityOf(file));
+    const busy = (act.busy || (!act.sawMarkers && Date.now() - mtime < 60_000))
+      && Date.now() - mtime < CODEX_BUSY_STALE_MS;
+    transcriptCache.set(meta.id, file);
+    sessions.push({
+      id: meta.id,
+      provider: 'codex',
+      name: names.get(meta.id) || path.basename(meta.cwd || '?'),
+      cwd: meta.cwd,
+      project: path.basename(meta.cwd || '?'),
+      status: headlessActive.has(meta.id) || busy ? 'busy' : 'idle',
+      updatedAt: mtime,
+      startedAt: meta.startedAt,
+      lastMessage: act.lastMessage,
+      tty: '',
+      live: false,
+    });
+  }
+  codexCache.sessions = sessions;
+  return sessions;
+}
+
+// ---------- Kimi session discovery ----------
+// Two on-disk generations exist. The legacy Python CLI keeps sessions in
+// ~/.kimi/sessions/<md5(workdir)>/<uuid>/ with a context.jsonl history and a
+// wire.jsonl event log (TurnBegin/TurnEnd bracket a working turn). The new
+// Kimi Code CLI keeps ~/.kimi-code/sessions/<wdKey>/<sessionId>/ with
+// state.json metadata and a per-agent journal in agents/main/wire.jsonl whose
+// records are {type, time, ...payload}. Neither writes a pid, so presence and
+// busyness come from journal freshness, like Codex.
+
+const KIMI_DIR = path.join(os.homedir(), '.kimi');
+const KIMICODE_DIR = path.join(os.homedir(), '.kimi-code');
+const KIMI_ACTIVE_WINDOW_MS = CODEX_ACTIVE_WINDOW_MS;
+// Wide enough that a turn quietly grinding through a long tool run (build,
+// test suite) does not flip to idle and admit a second writer.
+const KIMI_BUSY_STALE_MS = 5 * 60 * 1000;
+
+const readJson = (file) => { try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return null; } };
+
+const kosongText = (content) => {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) return content.filter((p) => p && (p.type === 'text' || p.text)).map((p) => p.text || '').join('\n');
+  return '';
+};
+
+// Legacy ~/.kimi: kimi.json maps workdirs to their md5 bucket names.
+function kimiWorkdirByBucket() {
+  const map = new Map();
+  const meta = readJson(path.join(KIMI_DIR, 'kimi.json'));
+  for (const wd of meta?.work_dirs || []) {
+    if (wd?.path) map.set(crypto.createHash('md5').update(wd.path).digest('hex'), wd.path);
+  }
+  return map;
+}
+
+function readKimiLegacyMessages(file, maxBytes = 512 * 1024, limit = 80) {
+  let lines;
+  try { lines = tailLines(file, maxBytes); } catch { return []; }
+  const out = [];
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    let e; try { e = JSON.parse(line); } catch { continue; }
+    if (e.partial || (e.role !== 'user' && e.role !== 'assistant')) continue;
+    const text = kosongText(e.content).trim();
+    if (!text) continue;
+    out.push({ role: e.role, text: text.slice(0, 4000), ts: null });
+  }
+  return out.slice(-limit);
+}
+
+function kimiLegacyBusy(wireFile) {
+  let lines;
+  try { lines = tailLines(wireFile, 64 * 1024); } catch { return { busy: false, sawMarkers: true }; }
+  let busy = false, sawMarkers = false;
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    let e; try { e = JSON.parse(line); } catch { continue; }
+    const t = e.message?.type;
+    if (t === 'TurnBegin') { busy = true; sawMarkers = true; }
+    else if (t === 'TurnEnd' || t === 'StepInterrupted') { busy = false; sawMarkers = true; }
+  }
+  return { busy, sawMarkers };
+}
+
+function readKimiLegacySessions() {
+  const sessions = [];
+  const root = path.join(KIMI_DIR, 'sessions');
+  let buckets = [];
+  try { buckets = fs.readdirSync(root); } catch { return sessions; }
+  const workdirs = kimiWorkdirByBucket();
+  for (const bucket of buckets) {
+    let ids = [];
+    try { ids = fs.readdirSync(path.join(root, bucket)); } catch { continue; }
+    for (const id of ids) {
+      const dir = path.join(root, bucket, id);
+      const context = path.join(dir, 'context.jsonl');
+      const wire = path.join(dir, 'wire.jsonl');
+      let mtime = 0, started = 0;
+      try {
+        const st = fs.statSync(context);
+        mtime = st.mtimeMs;
+        started = st.birthtimeMs || st.ctimeMs;
+      } catch { continue; }
+      try { mtime = Math.max(mtime, fs.statSync(wire).mtimeMs); } catch {}
+      if (Date.now() - mtime > KIMI_ACTIVE_WINDOW_MS) continue;
+      const cwd = workdirs.get(bucket) || '';
+      const state = readJson(path.join(dir, 'state.json'));
+      if (state?.archived) continue;
+      const msgs = memoScan(`kimi:${context}`, context, () => readKimiLegacyMessages(context, 64 * 1024, 1));
+      const act = memoScan(`kimi:${wire}`, wire, () => kimiLegacyBusy(wire));
+      const busy = (act.busy || (!act.sawMarkers && Date.now() - mtime < 60_000))
+        && Date.now() - mtime < KIMI_BUSY_STALE_MS;
+      transcriptCache.set(id, context);
+      sessions.push({
+        id,
+        provider: 'kimi',
+        name: state?.custom_title || path.basename(cwd || '?'),
+        cwd,
+        project: path.basename(cwd || '?'),
+        status: headlessActive.has(id) || busy ? 'busy' : 'idle',
+        updatedAt: mtime,
+        startedAt: started,
+        lastMessage: msgs.length ? msgs[msgs.length - 1] : null,
+        tty: '',
+        live: false,
+      });
+    }
+  }
+  return sessions;
+}
+
+// A truthy but unparseable time value must not throw: this runs inside the
+// snapshot interval, where an exception would crash-loop the whole daemon.
+const isoOf = (t) => { try { return t ? new Date(t).toISOString() : null; } catch { return null; } };
+
+// Kimi Code journal: turn.prompt opens a turn; a text-only assistant message
+// (no tool calls), a turn.cancel, or an Interrupt closes it.
+function kimiCodeScan(wireFile, maxBytes = 512 * 1024, limit = 80) {
+  let lines;
+  try { lines = tailLines(wireFile, maxBytes); } catch { return { messages: [], busy: false, sawMarkers: true, waiting: false }; }
+  const messages = [];
+  let lastPrompt = 0, lastEnd = 0;
+  const pendingInteractions = new Set();
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    let e; try { e = JSON.parse(line); } catch { continue; }
+    const ts = isoOf(e.time);
+    if (e.type === 'turn.prompt' || e.type === 'turn.steer') {
+      lastPrompt = Math.max(lastPrompt, e.time || 0);
+      const text = kosongText(e.input).trim();
+      if (text) messages.push({ role: 'user', text: text.slice(0, 4000), ts });
+    } else if (e.type === 'turn.cancel') {
+      lastEnd = Math.max(lastEnd, e.time || 0, lastPrompt);
+    } else if (e.type === 'context.append_message') {
+      const m = e.message || {};
+      const text = kosongText(m.content).trim();
+      const toolCalls = m.toolCalls || m.tool_calls;
+      if (m.role === 'assistant' && !(toolCalls && toolCalls.length)) {
+        if (text) messages.push({ role: 'assistant', text: text.slice(0, 4000), ts });
+        lastEnd = Math.max(lastEnd, e.time || 0);
+      }
+    } else if (e.type === 'interaction.request') {
+      const key = e.id ?? e.interaction_id;
+      if (key) pendingInteractions.add(key);
+    } else if (e.type === 'interaction.resolved') {
+      const key = e.id ?? e.interaction_id;
+      if (key) pendingInteractions.delete(key); else pendingInteractions.clear();
+    }
+  }
+  return {
+    messages: messages.slice(-limit),
+    busy: lastPrompt > lastEnd,
+    // Same tail-window caveat as Codex: no markers seen means a long turn
+    // pushed them out, so freshness decides.
+    sawMarkers: lastPrompt > 0 || lastEnd > 0,
+    waiting: pendingInteractions.size > 0,
+  };
+}
+
+function readKimiCodeMessages(file, maxBytes = 512 * 1024, limit = 80) {
+  return kimiCodeScan(file, maxBytes, limit).messages;
+}
+
+function readKimiCodeSessions() {
+  const sessions = [];
+  const root = path.join(KIMICODE_DIR, 'sessions');
+  let wdKeys = [];
+  try { wdKeys = fs.readdirSync(root); } catch { return sessions; }
+  for (const wdKey of wdKeys) {
+    let ids = [];
+    try { ids = fs.readdirSync(path.join(root, wdKey)); } catch { continue; }
+    for (const id of ids) {
+      const dir = path.join(root, wdKey, id);
+      const state = readJson(path.join(dir, 'state.json'));
+      if (!state?.id || state.archived) continue;
+      const wire = path.join(dir, 'agents', 'main', 'wire.jsonl');
+      // A brand new session has state.json before its first journal write;
+      // state.updatedAt keeps it visible during that gap.
+      let mtime = state.updatedAt || 0;
+      try { mtime = Math.max(mtime, fs.statSync(wire).mtimeMs); } catch {}
+      if (Date.now() - mtime > KIMI_ACTIVE_WINDOW_MS) continue;
+      const scan = memoScan(`kimicode:${wire}`, wire, () => kimiCodeScan(wire, 64 * 1024, 1));
+      const busy = (scan.busy || (!scan.sawMarkers && Date.now() - mtime < 60_000))
+        && Date.now() - mtime < KIMI_BUSY_STALE_MS;
+      // A pending approval outranks busy: the agent is stopped on a human.
+      const status = scan.waiting ? 'waiting' : (headlessActive.has(state.id) || busy ? 'busy' : 'idle');
+      transcriptCache.set(state.id, wire);
+      sessions.push({
+        id: state.id,
+        provider: 'kimicode',
+        name: state.title || (state.lastPrompt || '').slice(0, 40) || path.basename(state.cwd || '?'),
+        cwd: state.cwd || '',
+        project: path.basename(state.cwd || '?'),
+        status,
+        updatedAt: mtime,
+        startedAt: state.createdAt || 0,
+        lastMessage: scan.messages.length ? scan.messages[scan.messages.length - 1] : null,
+        tty: '',
+        live: false,
+      });
+    }
+  }
+  return sessions;
+}
+
+let kimiCache = { at: 0, sessions: [] };
+function readKimiSessions() {
+  if (Date.now() - kimiCache.at < 10_000) return kimiCache.sessions;
+  kimiCache.at = Date.now();
+  kimiCache.sessions = [...readKimiLegacySessions(), ...readKimiCodeSessions()];
+  return kimiCache.sessions;
+}
+
+function readSessions() {
+  const sessions = [...readClaudeSessions(), ...readCodexSessions(), ...readKimiSessions()];
   sessions.sort((a, b) => a.startedAt - b.startedAt);
   return sessions;
 }
@@ -600,7 +1031,13 @@ let ws = null;
 let lastSnapshotJson = '';
 
 function sendSnapshot(force = false) {
-  const sessions = readSessions();
+  // A parser tripping on a malformed journal must never take the daemon down:
+  // this runs on a bare interval with nothing above it to catch a throw.
+  let sessions;
+  try { sessions = readSessions(); } catch (e) {
+    console.log(`[daemon] snapshot failed: ${e.message}`);
+    return;
+  }
   const json = JSON.stringify(sessions.map(({ lastMessage, ...s }) => ({ ...s, last: lastMessage?.text?.slice(0, 120) })));
   if (!force && json === lastSnapshotJson) return;
   lastSnapshotJson = json;
@@ -649,6 +1086,8 @@ async function handleCommand(cmd) {
     const session = readSessions().find((s) => s.id === cmd.sessionId);
     if (!session) return ws?.send(seal({ type: 'promptResult', sessionId: cmd.sessionId, ok: false, error: 'session not found' }));
 
+    if (session.provider && session.provider !== 'claude') return promptHeadless(session, cmd.text);
+
     // Preferred path: type into the real terminal so the desktop updates live.
     if (session.live) {
       const method = await injectPrompt(session.tty, cmd.text);
@@ -679,7 +1118,7 @@ async function handleCommand(cmd) {
     headlessActive.add(cmd.sessionId);
     sendSnapshot(true);
     const child = spawn(claudeBin, ['--resume', cmd.sessionId, '-p', cmd.text], {
-      cwd: session.cwd || os.homedir(),
+      cwd: fs.existsSync(session.cwd || '') ? session.cwd : os.homedir(),
       env: process.env,
       stdio: ['ignore', 'pipe', 'pipe'],
     });
@@ -707,6 +1146,80 @@ async function handleCommand(cmd) {
   }
 }
 
+// Sends a phone prompt to a Codex or Kimi session. There is no tty path for
+// these (their session files record no pid), so every prompt goes through the
+// provider's headless resume command, which appends the turn to the same
+// journal the transcript watcher follows — desktop app threads included.
+// Codex takes the prompt as a positional, so `--` stops phone text that
+// begins with a dash from being read as CLI flags. The kimi CLIs take it as
+// the -p option value where `--` cannot help, so a leading space defuses a
+// dash there (the models do not care about leading whitespace).
+const defuse = (text) => (/^\s*-/.test(text) ? ` ${text}` : text);
+const headlessPromptSpec = {
+  codex: () => codexBin && { bin: codexBin, args: (id, text) => ['exec', 'resume', id, '--skip-git-repo-check', '--', text] },
+  kimicode: () => kimiCodeBin && { bin: kimiCodeBin, args: (id, text) => ['--session', id, '-p', defuse(text)] },
+  kimi: () => kimiLegacyBin && { bin: kimiLegacyBin, args: (id, text) => ['--print', '--session', id, '-p', defuse(text)] },
+};
+
+function bustProviderCaches() {
+  codexCache.at = 0;
+  kimiCache.at = 0;
+}
+
+function promptHeadless(session, text) {
+  // Anything but idle means another writer owns the session right now: busy
+  // is a running turn, waiting is a human approval the phone cannot answer.
+  if (session.status === 'busy') return ws?.send(seal({ type: 'promptResult', sessionId: session.id, ok: false, error: 'session is busy, wait for it to go idle' }));
+  if (session.status !== 'idle') return ws?.send(seal({ type: 'promptResult', sessionId: session.id, ok: false, error: 'session is waiting for an approval, answer it in the app or terminal first' }));
+  const spec = headlessPromptSpec[session.provider]?.();
+  if (!spec) {
+    console.log(`[daemon] ${session.provider} prompt failed: binary not found`);
+    return ws?.send(seal({
+      type: 'promptResult', sessionId: session.id, ok: false,
+      error: `The daemon could not find the ${session.provider === 'codex' ? 'codex' : 'kimi'} command on this Mac, so it cannot reach this session.`,
+    }));
+  }
+  console.log(`[daemon] prompt -> ${session.provider} ${session.name}: ${text.slice(0, 60)}`);
+  const promptedAt = Date.now();
+  headlessActive.add(session.id);
+  bustProviderCaches();
+  sendSnapshot(true);
+  const child = spawn(spec.bin, spec.args(session.id, text), {
+    cwd: fs.existsSync(session.cwd || '') ? session.cwd : os.homedir(),
+    env: process.env,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  let err = '';
+  let responded = false;
+  const respond = (payload) => {
+    if (responded) return;
+    responded = true;
+    headlessActive.delete(session.id);
+    bustProviderCaches();
+    ws?.send(seal(payload));
+    sendSnapshot(true);
+  };
+  child.stderr.on('data', (d) => { err += d; });
+  child.stdout.on('data', () => {});
+  child.on('error', (e) => {
+    console.log(`[daemon] ${session.provider} spawn failed: ${e.message}`);
+    respond({ type: 'promptResult', sessionId: session.id, ok: false, error: `could not run ${session.provider}: ${e.message}` });
+  });
+  child.on('close', (code) => {
+    // The reply is already in the journal; surface the last assistant turn,
+    // but only one written after this prompt. An older message here would
+    // present a stale answer as the reply (the live transcript stream shows
+    // the real one either way, so an empty text is fine).
+    const msgs = readMessages(session.id, 64 * 1024, 10);
+    const reply = [...msgs].reverse().find((m) => m.role === 'assistant' && Date.parse(m.ts || '') > promptedAt);
+    respond({
+      type: 'promptResult', sessionId: session.id, ok: code === 0,
+      text: code === 0 ? (reply?.text || '').slice(0, 4000) : err.trim().slice(0, 4000),
+    });
+  });
+  watchTranscript(session.id);
+}
+
 let lastPongAt = Date.now();
 
 function connect() {
@@ -754,3 +1267,20 @@ setInterval(() => {
   }
 }, 20_000);
 try { fs.watch(SESSIONS_DIR, () => sendSnapshot()); } catch {}
+// Recursive watches (macOS supports them) so a fresh Codex or Kimi turn busts
+// the scan cache immediately instead of waiting out the 10s refresh. Debounced:
+// a streaming turn appends to its journal many times a second, and every
+// uncached snapshot is a full rescan.
+function watchProviderDir(dir, cache, label) {
+  let debounce;
+  try {
+    fs.watch(dir, { recursive: true }, () => {
+      clearTimeout(debounce);
+      debounce = setTimeout(() => { cache.at = 0; sendSnapshot(); }, 500);
+    });
+    console.log(`[daemon] ${label}: watching ${dir}`);
+  } catch {}
+}
+watchProviderDir(CODEX_SESS_DIR, codexCache, `codex sessions (codex binary: ${codexBin || 'not found, sessions will be read only'})`);
+watchProviderDir(path.join(KIMI_DIR, 'sessions'), kimiCache, 'kimi sessions');
+watchProviderDir(path.join(KIMICODE_DIR, 'sessions'), kimiCache, 'kimi code sessions');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clastres/groundcontrol",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "See and command your Claude Code sessions from your iPhone. Pairs the Ground Control app with the agents running on this Mac, end to end encrypted.",
   "bin": {
     "groundcontrol": "bin/groundcontrol.mjs"