@clastres/groundcontrol 0.1.7 → 0.1.9

package/daemon.mjs

@@ -15,14 +15,14 @@ import net from 'node:net';
 import os from 'node:os';
 import path from 'node:path';
 import readline from 'node:readline';
-import { spawn, execFile, execSync } from 'node:child_process';
+import { spawn, spawnSync, execFile, execSync } from 'node:child_process';
 import { promisify } from 'node:util';
 import { fileURLToPath } from 'node:url';
 import { createRequire } from 'node:module';
 
 const execFileP = promisify(execFile);
 
-const VERSION = '0.1.7';
+const VERSION = '0.1.9';
 const PACKAGE = '@clastres/groundcontrol';
 
 // ---------- config / pairing ----------
@@ -638,23 +638,40 @@ widenPath();
 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)'}`);
+// Every agent binary is resolved on use rather than at startup. launchd starts
+// this at login and it then runs for weeks, while CLIs get installed
+// underneath it. Session discovery already rescans the disk every few seconds,
+// so a `const` resolved at boot produces the worst possible split: the new
+// session appears on the phone, its transcript streams, and sending fails with
+// "binary not found" until someone restarts the daemon. Cached for a minute so
+// a prompt does not pay for a PATH scan.
+const binMemo = new Map(); // label -> { at, path }
+function resolveBin(label, find) {
+  const c = binMemo.get(label);
+  if (c && Date.now() - c.at < 60_000) return c.path;
+  let p = null;
+  try { p = find() || null; } catch {}
+  binMemo.set(label, { at: Date.now(), path: p });
+  return p;
+}
+
+const claudeBin = () => resolveBin('claude', () => 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');
+const codexBin = () => resolveBin('codex', () => 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
+const kimiCodeInstalled = () => fs.existsSync(path.join(os.homedir(), '.kimi-code'));
+const kimiCodeBin = () => resolveBin('kimicode', () => (kimiCodeInstalled()
   ? which('kimi') || executable(path.join(os.homedir(), '.kimi-code', 'bin', 'kimi'))
-  : null;
-const kimiLegacyBin = which('kimi-legacy') || (kimiCodeInstalled ? null : which('kimi'));
+  : null));
+const kimiLegacyBin = () => resolveBin('kimi', () => which('kimi-legacy') || (kimiCodeInstalled() ? null : which('kimi')));
 
 // ---------- Claude Code session discovery ----------
 
@@ -850,6 +867,7 @@ function readMessages(sessionId, maxBytes = 512 * 1024, limit = 80) {
   // 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(GROKBOT_DIR + path.sep)) return readGrokBotMessages(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;
@@ -1214,14 +1232,38 @@ function readKimiLegacySessions() {
 // 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.
+// Kimi Code journal: turn.prompt opens a turn; turn.ended, turn.cancel, an
+// Interrupt, or a text-only assistant message closes it.
+//
+// The reply itself needs two readers. Current Kimi Code writes the assistant's
+// answer only as content parts on the loop event stream and never writes an
+// assistant context.append_message at all, so a reader waiting for one shows
+// your question and never the answer, and leaves the session marked busy until
+// the staleness timeout gives up. Older builds do write that message, so both
+// paths stay, with a dedupe for any build that writes both.
 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();
+
+  // A step can emit its text in several parts. Those are one reply, so they
+  // join rather than arriving as a burst of one line messages. Parts join raw:
+  // trimming each one first would weld "Connection " to "looks good." with no
+  // space between them. The seams are trimmed once, at the end.
+  let openStep = null;
+  const pushAssistant = (text, ts, stepUuid) => {
+    const last = messages[messages.length - 1];
+    if (stepUuid && openStep === stepUuid && last?.role === 'assistant') {
+      last.text = `${last.text}${text}`.slice(0, 4000);
+      return;
+    }
+    if (last?.role === 'assistant' && last.text.trim() === text.trim()) return;
+    messages.push({ role: 'assistant', text: text.slice(0, 4000), ts });
+    openStep = stepUuid || null;
+  };
+
   for (const line of lines) {
     if (!line.trim()) continue;
     let e; try { e = JSON.parse(line); } catch { continue; }
@@ -1232,12 +1274,23 @@ function kimiCodeScan(wireFile, maxBytes = 512 * 1024, limit = 80) {
       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 === 'turn.ended') {
+      lastEnd = Math.max(lastEnd, e.time || 0);
+    } else if (e.type === 'context.append_loop_event') {
+      const ev = e.event || {};
+      const part = ev.part || {};
+      // 'think' parts are reasoning, which belongs on the Mac and not in a
+      // phone transcript.
+      if (ev.type === 'content.part' && part.type === 'text') {
+        const text = typeof part.text === 'string' ? part.text : '';
+        if (text.trim()) pushAssistant(text, ts, ev.stepUuid);
+      }
     } 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 });
+        if (text) pushAssistant(text, ts, null);
         lastEnd = Math.max(lastEnd, e.time || 0);
       }
     } else if (e.type === 'interaction.request') {
@@ -1249,7 +1302,7 @@ function kimiCodeScan(wireFile, maxBytes = 512 * 1024, limit = 80) {
     }
   }
   return {
-    messages: messages.slice(-limit),
+    messages: messages.slice(-limit).map((m) => ({ ...m, text: m.text.trim() })),
     busy: lastPrompt > lastEnd,
     // Same tail-window caveat as Codex: no markers seen means a long turn
     // pushed them out, so freshness decides.
@@ -1258,6 +1311,49 @@ function kimiCodeScan(wireFile, maxBytes = 512 * 1024, limit = 80) {
   };
 }
 
+// Kimi Code records nothing that says a session ended: no pid in state.json, no
+// ended flag, and `lastTurnReason: "completed"` reads the same whether you
+// answered and walked away or quit the CLI outright. An idle session holds no
+// file open either, so freshness alone kept a session you killed on the island
+// for the full two hour window as a pilot nobody was home for.
+//
+// What the system does know is how many kimi processes are running and where.
+// A directory with one live process has one live session, whatever its journals
+// say, so sessions are ranked by recency inside their directory and the newest
+// N survive.
+//
+// It is a heuristic, and it is wrong in exactly one direction: two sessions open
+// in the same directory with one of them killed keeps whichever spoke last
+// rather than whichever is actually alive. Every other case is right, and a
+// directory nobody is working in empties out, which is the case that made the
+// island lie. When lsof cannot answer, nothing is pruned.
+//
+// `-Fn` has to be one token: this lsof (4.91, the one Apple ships) reads `-F n`
+// as an empty field list followed by a file named "n".
+let kimiProcCache = { at: 0, counts: null };
+function liveKimiCwdCounts() {
+  if (Date.now() - kimiProcCache.at < 5_000) return kimiProcCache.counts;
+  kimiProcCache.at = Date.now();
+  const r = spawnSync('lsof', ['-c', 'kimi', '-a', '-d', 'cwd', '-Fn'], { encoding: 'utf8', timeout: 4000 });
+  // status 1 is "no matching process", which is a real answer: nobody is
+  // running kimi, so no session in any directory is live.
+  if (r.error || r.status === null || r.status > 1) {
+    kimiProcCache.counts = null;
+    return null;
+  }
+  const counts = new Map();
+  for (const line of (r.stdout || '').split('\n')) {
+    if (!line.startsWith('n')) continue;
+    counts.set(line.slice(1), (counts.get(line.slice(1)) || 0) + 1);
+  }
+  kimiProcCache.counts = counts;
+  return counts;
+}
+
+/// lsof reports a resolved cwd, so a session whose recorded cwd runs through a
+/// symlink has to be resolved the same way before the two can be compared.
+const realpathOf = (p) => { try { return fs.realpathSync(p); } catch { return p; } };
+
 function readKimiCodeMessages(file, maxBytes = 512 * 1024, limit = 80) {
   return kimiCodeScan(file, maxBytes, limit).messages;
 }
@@ -1267,6 +1363,11 @@ function readKimiCodeSessions() {
   const root = path.join(KIMICODE_DIR, 'sessions');
   let wdKeys = [];
   try { wdKeys = fs.readdirSync(root); } catch { return sessions; }
+
+  // Two passes: gather the candidates inside the activity window, ask lsof
+  // about all of them at once, then decide. One process table walk per scan
+  // rather than one per session.
+  const candidates = [];
   for (const wdKey of wdKeys) {
     let ids = [];
     try { ids = fs.readdirSync(path.join(root, wdKey)); } catch { continue; }
@@ -1280,27 +1381,53 @@ function readKimiCodeSessions() {
       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,
-      });
+      candidates.push({ state, wire, mtime });
+    }
+  }
+
+  // Keep the newest N in each directory, N being the number of kimi processes
+  // working there. A null count means lsof could not answer, so nothing is
+  // pruned and this behaves as it did before.
+  const counts = liveKimiCwdCounts();
+  let keep = candidates;
+  if (counts) {
+    const byDir = new Map();
+    for (const c of candidates) {
+      const dir = c.state.cwd ? realpathOf(c.state.cwd) : '';
+      if (!byDir.has(dir)) byDir.set(dir, []);
+      byDir.get(dir).push(c);
+    }
+    keep = [];
+    for (const [dir, group] of byDir) {
+      // A session with no recorded directory cannot be matched to a process,
+      // and hiding a session on a guess is worse than showing a stale one.
+      if (!dir) { keep.push(...group); continue; }
+      group.sort((a, b) => b.mtime - a.mtime);
+      keep.push(...group.slice(0, counts.get(dir) || 0));
     }
   }
+
+  for (const { state, wire, mtime } of keep) {
+    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;
 }
 
@@ -1312,6 +1439,157 @@ function readKimiSessions() {
   return kimiCache.sessions;
 }
 
+// ---------- Grok Bot session discovery ----------
+// Grok Bot's agents run on a cloud VM, so unlike every other provider there is
+// nothing local to attach to: no process, no tty, no working directory, and no
+// way to send. What the desktop app does keep is a replica of what it has
+// synced, under ~/Library/Application Support/Grok Bot/sand-client-persistence,
+// one JSON blob per store key with the key base32 encoded into the filename.
+// Two keys matter:
+//   <account>.roster.last-roster        one row per Bot
+//   <account>.transcript.replicas.<id>  that Bot's conversation
+//
+// Read only, deliberately. The replica is the app's cache and not the source of
+// truth (that lives on the VM at /home/box/sand-data/agents/<id>/store.db), so
+// a message written in here is a message the app overwrites rather than sends.
+//
+// It also only advances while the desktop app is running. Bots keep working
+// with the app closed and the island cannot see it, so a Bot left mid turn is
+// the app having quit, not the Bot being stuck: busy expires on staleness the
+// same way the other journal-freshness providers do.
+
+const GROKBOT_DIR = path.join(os.homedir(), 'Library', 'Application Support', 'Grok Bot', 'sand-client-persistence');
+const GROKBOT_BUSY_STALE_MS = 5 * 60 * 1000;
+
+// RFC 4648 base32, lowercase and unpadded, which is how the app names blobs.
+// A name that is not one of ours decodes to junk and simply matches nothing,
+// so guessing wrong costs a string compare.
+const B32_ALPHABET = 'abcdefghijklmnopqrstuvwxyz234567';
+function b32decode(name) {
+  let bits = 0;
+  let value = 0;
+  const out = [];
+  for (const ch of name.toLowerCase()) {
+    if (ch === '=') break;
+    const i = B32_ALPHABET.indexOf(ch);
+    if (i < 0) return '';
+    value = (value << 5) | i;
+    bits += 5;
+    if (bits >= 8) { out.push((value >>> (bits - 8)) & 0xff); bits -= 8; }
+  }
+  return Buffer.from(out).toString('utf8');
+}
+
+// The names are long and never change, so decode each one once.
+const grokbotKeys = new Map(); // filename -> decoded store key
+const grokbotKeyOf = (name) => {
+  if (!grokbotKeys.has(name)) grokbotKeys.set(name, b32decode(name.replace(/\.blob$/, '')));
+  return grokbotKeys.get(name);
+};
+
+const grokbotEntriesOf = (file) => {
+  const entries = readJson(file)?.value?.entries;
+  return Array.isArray(entries) ? entries : [];
+};
+
+// Two entry kinds carry a turn: a typed one is {kind:'message', role, content}
+// and a Bot one is {kind:'send-message', message:{type,content}}. Everything
+// else in the stream (tool calls, approvals, status) has no place in a phone
+// transcript.
+function grokbotMessages(entries, limit = 80) {
+  const out = [];
+  for (const e of entries) {
+    let role = null;
+    let text = '';
+    if (e?.kind === 'message' && (e.role === 'user' || e.role === 'assistant')) {
+      role = e.role;
+      text = typeof e.content === 'string' ? e.content : '';
+    } else if (e?.kind === 'send-message' && e.message?.type === 'text') {
+      role = 'assistant';
+      text = typeof e.message.content === 'string' ? e.message.content : '';
+    }
+    text = text.trim();
+    if (!role || !text) continue;
+    out.push({ role, text: text.slice(0, 4000), ts: isoOf(e.timestampMs) });
+  }
+  return out.slice(-limit);
+}
+
+// One JSON object rather than a journal, so the tail slice every other provider
+// reads with would just be a syntax error. Whole file, with a ceiling that only
+// exists so a pathological blob cannot stall the daemon.
+function readGrokBotMessages(file, maxBytes = 512 * 1024, limit = 80) {
+  try { if (fs.statSync(file).size > 8 * 1024 * 1024) return []; } catch { return []; }
+  return grokbotMessages(grokbotEntriesOf(file), limit);
+}
+
+function scanGrokBotSessions() {
+  const sessions = [];
+  let files = [];
+  try { files = fs.readdirSync(GROKBOT_DIR); } catch { return sessions; }
+
+  let rosterFile = null;
+  const transcripts = new Map(); // botId -> blob path
+  for (const name of files) {
+    if (!name.endsWith('.blob')) continue;
+    const key = grokbotKeyOf(name);
+    if (key.endsWith('.roster.last-roster')) rosterFile = path.join(GROKBOT_DIR, name);
+    else {
+      const m = key.match(/\.transcript\.replicas\.([0-9a-f-]{36})$/);
+      if (m) transcripts.set(m[1], path.join(GROKBOT_DIR, name));
+    }
+  }
+  const rows = rosterFile ? readJson(rosterFile)?.value?.rows : null;
+  if (!Array.isArray(rows)) return sessions;
+
+  for (const row of rows) {
+    // A Bot is a standing teammate rather than a session that ends, so the
+    // roster is mirrored as it stands: what the Grok Bot sidebar lists, the
+    // island shows.
+    if (!row?.id || row.isHiddenFromSidebar) continue;
+    const file = transcripts.get(row.id) || null;
+    const scan = file
+      ? memoScan(`grokbot:${file}`, file, () => {
+        const entries = grokbotEntriesOf(file);
+        return { messages: grokbotMessages(entries, 1), streaming: entries.some((e) => e?.isStreaming === true) };
+      })
+      : { messages: [], streaming: false };
+    let updatedAt = row.lastActivityAt || row.updatedAt || 0;
+    if (file) { try { updatedAt = Math.max(updatedAt, fs.statSync(file).mtimeMs); } catch {} }
+    const busy = scan.streaming && Date.now() - updatedAt < GROKBOT_BUSY_STALE_MS;
+    if (file) transcriptCache.set(row.id, file);
+    sessions.push({
+      id: row.id,
+      provider: 'grokbot',
+      name: row.name || 'Bot',
+      // Its working directory is on a machine that is not this one, and
+      // claiming otherwise would put a path on the island you cannot open.
+      cwd: '',
+      project: 'Grok Bot',
+      // awaitingUserResponse is how the app marks a Bot stopped on you, which
+      // is the same pink invader as a held permission request.
+      status: row.awaitingUserResponse ? 'waiting' : (busy ? 'busy' : 'idle'),
+      updatedAt,
+      startedAt: row.createdAt || 0,
+      lastMessage: scan.messages.length ? scan.messages[scan.messages.length - 1] : null,
+      tty: '',
+      live: false,
+      // Nothing reads this yet. It is what a build that greys out the compose
+      // box will key on, instead of re-deriving read-only from the provider.
+      readOnly: true,
+    });
+  }
+  return sessions;
+}
+
+let grokbotCache = { at: 0, sessions: [] };
+function readGrokBotSessions() {
+  if (Date.now() - grokbotCache.at < 10_000) return grokbotCache.sessions;
+  grokbotCache.at = Date.now();
+  grokbotCache.sessions = scanGrokBotSessions();
+  return grokbotCache.sessions;
+}
+
 /// The phone-facing shape of a held request.
 const askPayload = (ask, queued) => ({
   id: ask.id,
@@ -1323,7 +1601,7 @@ const askPayload = (ask, queued) => ({
 });
 
 function readSessions() {
-  const sessions = [...readClaudeSessions(), ...readCodexSessions(), ...readKimiSessions()];
+  const sessions = [...readClaudeSessions(), ...readCodexSessions(), ...readKimiSessions(), ...readGrokBotSessions()];
   const known = new Set(sessions.map((s) => s.id));
   for (const s of sessions) {
     const queue = askQueue.get(s.id);
@@ -1758,7 +2036,14 @@ function watchTranscript(sessionId) {
   if (!file) return;
   let debounce;
   try {
-    const w = fs.watch(file, () => {
+    // Journals are appended to, so watching the file is enough. Grok Bot
+    // rewrites its replica blob wholesale, and a rename leaves a file watch
+    // bound to an inode nothing writes to again: watch the directory instead
+    // and filter, which survives the swap.
+    const inGrokBot = file.startsWith(GROKBOT_DIR + path.sep);
+    const target = inGrokBot ? GROKBOT_DIR : file;
+    const w = fs.watch(target, (_ev, changed) => {
+      if (inGrokBot && changed && changed !== path.basename(file)) return;
       clearTimeout(debounce);
       debounce = setTimeout(() => {
         ws?.send(seal({ type: 'transcript', sessionId, messages: readMessages(sessionId) }));
@@ -1828,6 +2113,15 @@ 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' }));
 
+    // A Bot lives on a cloud VM this daemon has no channel to. Saying so beats
+    // a send that looks accepted and arrives nowhere.
+    if (session.provider === 'grokbot') {
+      return ws?.send(seal({
+        type: 'promptResult', sessionId: cmd.sessionId, ok: false,
+        error: 'Grok Bot runs in the cloud, so Ground Control can only watch it. Open the Grok Bot app to reply.',
+      }));
+    }
+
     if (session.provider && session.provider !== 'claude') return promptHeadless(session, cmd.text);
 
     // Preferred path: type into the real terminal so the desktop updates live.
@@ -1849,7 +2143,8 @@ async function handleCommand(cmd) {
       }
     }
     if (session.status === 'busy') return ws?.send(seal({ type: 'promptResult', sessionId: cmd.sessionId, ok: false, error: 'session is busy, wait for it to go idle' }));
-    if (!claudeBin) {
+    const bin = claudeBin();
+    if (!bin) {
       console.log('[daemon] prompt failed: claude binary not found on PATH');
       return ws?.send(seal({
         type: 'promptResult', sessionId: cmd.sessionId, ok: false,
@@ -1859,7 +2154,7 @@ async function handleCommand(cmd) {
     console.log(`[daemon] prompt -> ${session.name}: ${cmd.text.slice(0, 60)}`);
     headlessActive.add(cmd.sessionId);
     sendSnapshot(true);
-    const child = spawn(claudeBin, ['--resume', cmd.sessionId, '-p', cmd.text], {
+    const child = spawn(bin, ['--resume', cmd.sessionId, '-p', cmd.text], {
       cwd: fs.existsSync(session.cwd || '') ? session.cwd : os.homedir(),
       env: process.env,
       stdio: ['ignore', 'pipe', 'pipe'],
@@ -1898,14 +2193,15 @@ async function handleCommand(cmd) {
 // 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)] },
+  codex: () => { const bin = codexBin(); return bin && { bin, args: (id, text) => ['exec', 'resume', id, '--skip-git-repo-check', '--', text] }; },
+  kimicode: () => { const bin = kimiCodeBin(); return bin && { bin, args: (id, text) => ['--session', id, '-p', defuse(text)] }; },
+  kimi: () => { const bin = kimiLegacyBin(); return bin && { bin, args: (id, text) => ['--print', '--session', id, '-p', defuse(text)] }; },
 };
 
 function bustProviderCaches() {
   codexCache.at = 0;
   kimiCache.at = 0;
+  grokbotCache.at = 0;
 }
 
 function promptHeadless(session, text) {
@@ -1918,7 +2214,7 @@ function promptHeadless(session, text) {
     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.`,
+      error: `The daemon could not find the ${session.provider === 'codex' ? 'codex' : 'kimi'} command on this Mac, so it cannot reach this session. If you just installed it, try again in a minute.`,
     }));
   }
   console.log(`[daemon] prompt -> ${session.provider} ${session.name}: ${text.slice(0, 60)}`);
@@ -2060,6 +2356,7 @@ function watchProviderDir(dir, cache, label) {
     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(CODEX_SESS_DIR, codexCache, `codex sessions (codex binary: ${codexBin() || 'not found yet, rechecked on each prompt'})`);
 watchProviderDir(path.join(KIMI_DIR, 'sessions'), kimiCache, 'kimi sessions');
 watchProviderDir(path.join(KIMICODE_DIR, 'sessions'), kimiCache, 'kimi code sessions');
+watchProviderDir(GROKBOT_DIR, grokbotCache, 'grok bot roster (read only, replies happen in the Grok Bot app)');

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "@clastres/groundcontrol",
-  "version": "0.1.7",
-  "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.",
+  "version": "0.1.9",
+  "description": "See and command your coding agents from your iPhone. Pairs the Ground Control app with Claude Code, Codex, Kimi and Grok Bot sessions running on this Mac, end to end encrypted.",
   "bin": {
     "groundcontrol": "bin/groundcontrol.mjs"
   },
+  "scripts": {
+    "test": "node test/run.mjs"
+  },
   "type": "module",
   "engines": {
     "node": ">=20"
@@ -16,6 +19,9 @@
   "keywords": [
     "claude",
     "claude-code",
+    "codex",
+    "kimi",
+    "grok",
     "ai",
     "agents",
     "cli",

package/test/binaries.mjs

@@ -0,0 +1,68 @@
+// Agent binaries are looked up on use, not at daemon startup.
+//
+// This is a regression test for a real failure: the daemon had been running
+// since Aug 4, Kimi Code was installed on Aug 12, and because the binary
+// consts were resolved once at boot the session showed up on the phone,
+// streamed its transcript, and refused every prompt with "binary not found"
+// for eight days. Session discovery rescans the disk constantly; binary
+// lookup did not.
+//
+// The resolver block is extracted from daemon.mjs rather than copied, with an
+// injected clock so the one minute memo can be stepped over instantly.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const DAEMON = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'daemon.mjs');
+const src = fs.readFileSync(DAEMON, 'utf8');
+const start = src.indexOf('// Every agent binary is resolved on use');
+const end = src.indexOf('// ---------- Claude Code session discovery ----------');
+if (start < 0 || end < 0 || end < start) throw new Error('could not locate the binary resolver block in daemon.mjs');
+const block = src.slice(start, end);
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'gc-bin-'));
+const home = path.join(tmp, 'home');
+fs.mkdirSync(path.join(home, '.kimi-code', 'bin'), { recursive: true });
+const kimiPath = path.join(home, '.kimi-code', 'bin', 'kimi');
+
+let now = 1_000_000;
+const clock = { now: () => now };
+const fakeOs = { ...os, homedir: () => home };
+const executable = (p) => { try { fs.accessSync(p, fs.constants.X_OK); return p; } catch { return null; } };
+const which = () => null;           // nothing on PATH, which is the real case here
+const quiet = { log: () => {} };    // swallow the startup banner
+
+const load = () => new Function('fs', 'os', 'path', 'Date', 'which', 'executable', 'console',
+  `${block}\n return { kimiCodeBin, claudeBin, codexBin, resolveBin };`)(
+  fs, fakeOs, path, clock, which, executable, quiet);
+
+const { kimiCodeBin } = load();
+
+let failures = 0;
+const check = (label, cond) => { console.log(`${cond ? 'ok  ' : 'FAIL'} ${label}`); if (!cond) failures++; };
+
+// Boot: ~/.kimi-code exists but the binary is not installed yet.
+check('not installed yet reads as missing', kimiCodeBin() === null);
+
+// Kimi Code installs while the daemon keeps running. This is the exact case
+// that left a session readable but unanswerable.
+fs.writeFileSync(kimiPath, '#!/bin/sh\n');
+fs.chmodSync(kimiPath, 0o755);
+
+check('still cached inside the memo window', kimiCodeBin() === null);
+now += 61_000;
+check('picked up a minute after install', kimiCodeBin() === kimiPath);
+
+// And the reverse: an uninstall is noticed rather than cached forever.
+fs.rmSync(kimiPath);
+now += 61_000;
+check('uninstall clears back to missing', kimiCodeBin() === null);
+
+// A lookup that throws must not take a prompt down with it.
+const { resolveBin } = load();
+check('a throwing lookup returns null', resolveBin('boom', () => { throw new Error('nope'); }) === null);
+
+fs.rmSync(tmp, { recursive: true, force: true });
+console.log(failures ? `\n${failures} FAILURE(S)` : '\nall checks passed');
+process.exit(failures ? 1 : 0);

package/test/grokbot.mjs

@@ -0,0 +1,86 @@
+// Runs the real Grok Bot reader out of daemon.mjs against whatever replica this
+// Mac has. The block is extracted from source rather than copied, so the test
+// cannot drift from what the daemon ships.
+//
+// The daemon is one long script that connects to the relay on import, so there
+// is nothing to import: pulling the section out by its comment markers and
+// evaluating it with its handful of helpers injected is what keeps this honest.
+//
+// On a Mac without Grok Bot installed the roster assertions are skipped and the
+// machine independent ones still run.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const DAEMON = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'daemon.mjs');
+const src = fs.readFileSync(DAEMON, 'utf8');
+const start = src.indexOf('// ---------- Grok Bot session discovery ----------');
+const end = src.indexOf('/// The phone-facing shape of a held request.');
+if (start < 0 || end < 0 || end < start) throw new Error('could not locate the Grok Bot block in daemon.mjs');
+const block = src.slice(start, end);
+
+const readJson = (file) => { try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return null; } };
+const isoOf = (t) => { try { return t ? new Date(t).toISOString() : null; } catch { return null; } };
+const memoScan = (_key, _file, fn) => fn();
+const transcriptCache = new Map();
+
+const load = (source, cache) => new Function('fs', 'os', 'path', 'readJson', 'isoOf', 'memoScan', 'transcriptCache',
+  `${source}\n return { readGrokBotSessions, readGrokBotMessages, b32decode, GROKBOT_DIR };`)(
+  fs, os, path, readJson, isoOf, memoScan, cache);
+
+const { readGrokBotSessions, readGrokBotMessages, b32decode, GROKBOT_DIR } = load(block, transcriptCache);
+
+let failures = 0;
+const check = (label, cond, detail = '') => {
+  console.log(`${cond ? 'ok  ' : 'FAIL'} ${label}${detail ? `  ${detail}` : ''}`);
+  if (!cond) failures++;
+};
+
+// A store key the app really writes, so a change to the encoding is caught here
+// rather than by an empty island.
+const known = 'onqw4zbomnwgszlooqxhg3djmnss4y3mnfsw45bnnvsxiyjomfrwg33vnz2c243mn52a';
+check('b32decode reads a real store key', b32decode(known) === 'sand.client.slice.client-meta.account-slot', b32decode(known));
+check('b32decode rejects junk', b32decode('!!!!') === '');
+
+// A Mac without Grok Bot must return an empty list rather than throw.
+check('missing install returns empty, does not throw',
+  load(block.replace(/const GROKBOT_DIR = .*/, "const GROKBOT_DIR = '/nope/not/here';"), new Map())
+    .readGrokBotSessions().length === 0);
+
+const sessions = fs.existsSync(GROKBOT_DIR) ? readGrokBotSessions() : [];
+if (!sessions.length) {
+  console.log(`\nskipped the roster checks: no Bots found in ${GROKBOT_DIR}`);
+  console.log(failures ? `\n${failures} FAILURE(S)` : '\nall checks passed');
+  process.exit(failures ? 1 : 0);
+}
+
+console.log(`\n${sessions.length} bot(s) found\n`);
+for (const s of sessions) {
+  check(`${s.name}: id is a uuid`, /^[0-9a-f-]{36}$/.test(s.id));
+  check(`${s.name}: status is one the app understands`, ['idle', 'busy', 'waiting'].includes(s.status));
+  check(`${s.name}: has a name`, !!s.name);
+  check(`${s.name}: startedAt set`, s.startedAt > 0);
+  check(`${s.name}: updatedAt set`, s.updatedAt > 0);
+  check(`${s.name}: read only flagged`, s.readOnly === true);
+  // Every field the Swift Session struct decodes as non-optional must be here,
+  // or the phone drops the whole snapshot, not just this row.
+  for (const k of ['id', 'name', 'cwd', 'project', 'status', 'updatedAt', 'startedAt']) {
+    check(`${s.name}: ${k} present for Swift decode`, s[k] !== undefined && s[k] !== null);
+  }
+
+  const file = transcriptCache.get(s.id);
+  check(`${s.name}: transcript located`, !!file);
+  if (!file) continue;
+  const msgs = readGrokBotMessages(file);
+  check(`${s.name}: transcript has messages`, msgs.length > 0);
+  check(`${s.name}: roles are user/assistant only`, msgs.every((m) => m.role === 'user' || m.role === 'assistant'));
+  check(`${s.name}: every message has a timestamp`, msgs.every((m) => !!m.ts));
+  check(`${s.name}: lastMessage matches transcript tail`, s.lastMessage?.text === msgs[msgs.length - 1]?.text);
+  // The app stores a ProseMirror doc beside every typed turn. Leaking it into
+  // the transcript would put raw JSON on the phone.
+  check(`${s.name}: no raw richText leaked into text`, msgs.every((m) => !m.text.includes('"type":"doc"')));
+}
+
+console.log(failures ? `\n${failures} FAILURE(S)` : '\nall checks passed');
+process.exit(failures ? 1 : 0);

package/test/kimi-liveness.mjs

@@ -0,0 +1,78 @@
+// Kimi Code records nothing on disk that says a session is over. There is no
+// pid, no ended flag, and `lastTurnReason: "completed"` looks identical whether
+// you answered and walked away or quit the CLI outright. Presence came from
+// journal freshness alone, so a session you killed stayed on the island for the
+// full two hour window as a pilot nobody was home for.
+//
+// An open handle on the journal looked like the answer and was not: that turned
+// out to be a writer mid turn, and an idle session holds nothing at all. What is
+// left is process count per directory, which is what this checks.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const DAEMON = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'daemon.mjs');
+const src = fs.readFileSync(DAEMON, 'utf8');
+const start = src.indexOf('// Kimi Code records nothing that says a session ended');
+const end = src.indexOf('function readKimiCodeMessages');
+if (start < 0 || end < 0 || end < start) throw new Error('could not locate the liveness block in daemon.mjs');
+
+// fs matters as much as spawnSync: the resolver realpaths every directory
+// before comparing, and without it the symlink case silently degrades.
+const load = (spawn) => new Function('fs', 'spawnSync', 'Date',
+  `${src.slice(start, end)}\n return { liveKimiCwdCounts, realpathOf };`)(fs, spawn, Date);
+
+let failures = 0;
+const check = (label, cond, detail = '') => {
+  console.log(`${cond ? 'ok  ' : 'FAIL'} ${label}${detail ? `  ${detail}` : ''}`);
+  if (!cond) failures++;
+};
+
+// Two processes in one directory, one in another, in lsof's -F output shape.
+const fakeLsof = (stdout, status = 0) => () => ({ status, stdout, error: null });
+let { liveKimiCwdCounts } = load(fakeLsof('p101\nfcwd\nn/Users/x/one\np102\nfcwd\nn/Users/x/one\np103\nfcwd\nn/Users/x/two\n'));
+let counts = liveKimiCwdCounts();
+check('two processes in a directory count as two', counts.get('/Users/x/one') === 2);
+check('one process elsewhere counts as one', counts.get('/Users/x/two') === 1);
+check('a directory with no process is absent', counts.get('/Users/x/three') === undefined);
+
+// lsof exits 1 when no process matches. That is an answer, not a failure: it
+// means nobody is running kimi, so nothing should survive.
+({ liveKimiCwdCounts } = load(fakeLsof('', 1)));
+counts = liveKimiCwdCounts();
+check('no kimi running is a real answer, not unknown', counts instanceof Map && counts.size === 0);
+
+// A missing or broken lsof must not prune anything.
+({ liveKimiCwdCounts } = load(() => ({ status: null, stdout: '', error: new Error('ENOENT') })));
+check('a missing lsof reports unknown', liveKimiCwdCounts() === null);
+({ liveKimiCwdCounts } = load(fakeLsof('garbage', 9)));
+check('a failing lsof reports unknown', liveKimiCwdCounts() === null);
+
+// realpathOf has to resolve, because lsof answers with the resolved path and
+// macOS puts every temp directory behind a symlink.
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'gc-live-'));
+const target = path.join(tmp, 'work');
+const link = path.join(tmp, 'link');
+fs.mkdirSync(target);
+fs.symlinkSync(target, link);
+const { realpathOf } = load(fakeLsof(''));
+check('a symlinked directory resolves to its target', realpathOf(link) === fs.realpathSync(target));
+check('a path that does not exist is returned unchanged', realpathOf('/nope/not/here') === '/nope/not/here');
+fs.rmSync(tmp, { recursive: true, force: true });
+
+// Against this Mac, with the real lsof.
+const { liveKimiCwdCounts: real } = load(spawnSync);
+const live = real();
+if (live === null) {
+  console.log('\nlsof could not answer on this Mac, so nothing would be pruned');
+} else if (live.size === 0) {
+  console.log('\nno kimi processes running: every Kimi session would leave the island');
+} else {
+  console.log(`\nlive kimi working directories:`);
+  for (const [dir, n] of live) console.log(`  ${n} process(es)  ${dir}`);
+}
+
+console.log(failures ? `\n${failures} FAILURE(S)` : '\nall checks passed');
+process.exit(failures ? 1 : 0);

package/test/kimi.mjs

@@ -0,0 +1,138 @@
+// Kimi Code writes the user's turn as `turn.prompt` but the assistant's reply
+// only as `content.part` loop events, with no assistant `context.append_message`
+// anywhere in the journal. A reader that waits for that message shows your
+// question and never the answer, and never sees the turn close, so the session
+// also stays busy until the staleness timeout gives up.
+//
+// This runs the real kimiCodeScan out of daemon.mjs against a synthetic journal
+// in both shapes, then against whatever real sessions this Mac has.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const DAEMON = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'daemon.mjs');
+const src = fs.readFileSync(DAEMON, 'utf8');
+const start = src.indexOf('// Kimi Code journal: turn.prompt opens a turn');
+const end = src.indexOf('function readKimiCodeMessages');
+if (start < 0 || end < 0 || end < start) throw new Error('could not locate kimiCodeScan in daemon.mjs');
+
+const tailLines = (file, maxBytes) => {
+  const size = fs.statSync(file).size;
+  const fd = fs.openSync(file, 'r');
+  const startAt = Math.max(0, size - maxBytes);
+  const buf = Buffer.alloc(size - startAt);
+  fs.readSync(fd, buf, 0, buf.length, startAt);
+  fs.closeSync(fd);
+  return buf.toString('utf8').split('\n');
+};
+const isoOf = (t) => { try { return t ? new Date(t).toISOString() : null; } 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 '';
+};
+
+const { kimiCodeScan } = new Function('fs', 'tailLines', 'isoOf', 'kosongText',
+  `${src.slice(start, end)}\n return { kimiCodeScan };`)(fs, tailLines, isoOf, kosongText);
+
+let failures = 0;
+const check = (label, cond, detail = '') => {
+  console.log(`${cond ? 'ok  ' : 'FAIL'} ${label}${detail ? `  ${detail}` : ''}`);
+  if (!cond) failures++;
+};
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'gc-kimi-'));
+const write = (name, records) => {
+  const p = path.join(tmp, name);
+  fs.writeFileSync(p, records.map((r) => JSON.stringify(r)).join('\n'));
+  return p;
+};
+
+// The shape Kimi Code actually writes today, taken from a live journal.
+const loopEvents = write('loop.jsonl', [
+  { type: 'turn.prompt', time: 1000, input: [{ type: 'text', text: 'are you there?' }] },
+  // Injected context arrives as a user append_message and is not a typed turn.
+  { type: 'context.append_message', time: 1001, message: { role: 'user', content: [{ type: 'text', text: '<system-reminder>\nAuto permission mode is active.' }] } },
+  { type: 'context.append_loop_event', time: 1002, event: { type: 'content.part', stepUuid: 's1', part: { type: 'think', think: 'a simple check in' } } },
+  { type: 'context.append_loop_event', time: 1003, event: { type: 'content.part', stepUuid: 's1', part: { type: 'text', text: "Yes, I'm here." } } },
+  { type: 'turn.ended', time: 1004, turnId: 0, reason: 'completed' },
+]);
+
+let scan = kimiCodeScan(loopEvents);
+check('the reply is read off the loop events', scan.messages.some((m) => m.role === 'assistant' && m.text === "Yes, I'm here."));
+check('the question is still there', scan.messages.some((m) => m.role === 'user' && m.text === 'are you there?'));
+check('reasoning stays off the phone', !scan.messages.some((m) => m.text.includes('a simple check in')));
+check('injected context is not a message', !scan.messages.some((m) => m.text.includes('system-reminder')));
+check('turn.ended closes the turn, so not stuck busy', scan.busy === false);
+check('every message carries a timestamp', scan.messages.every((m) => !!m.ts));
+
+// A reply streamed as several text parts in one step is one message.
+const split = write('split.jsonl', [
+  { type: 'turn.prompt', time: 2000, input: [{ type: 'text', text: 'hi' }] },
+  { type: 'context.append_loop_event', time: 2001, event: { type: 'content.part', stepUuid: 's2', part: { type: 'text', text: 'Connection ' } } },
+  { type: 'context.append_loop_event', time: 2002, event: { type: 'content.part', stepUuid: 's2', part: { type: 'text', text: 'looks good.' } } },
+  { type: 'turn.ended', time: 2003, reason: 'completed' },
+]);
+scan = kimiCodeScan(split);
+const replies = scan.messages.filter((m) => m.role === 'assistant');
+check('split parts join into one reply', replies.length === 1 && replies[0].text === 'Connection looks good.',
+  JSON.stringify(replies.map((m) => m.text)));
+
+// An older build that writes the assistant message too must not double up.
+const both = write('both.jsonl', [
+  { type: 'turn.prompt', time: 3000, input: [{ type: 'text', text: 'hi' }] },
+  { type: 'context.append_loop_event', time: 3001, event: { type: 'content.part', stepUuid: 's3', part: { type: 'text', text: 'Hello there.' } } },
+  { type: 'context.append_message', time: 3002, message: { role: 'assistant', content: [{ type: 'text', text: 'Hello there.' }] } },
+]);
+scan = kimiCodeScan(both);
+check('a build writing both shapes does not double the reply',
+  scan.messages.filter((m) => m.role === 'assistant').length === 1);
+
+// And the legacy shape on its own still works.
+const legacyOnly = write('legacy.jsonl', [
+  { type: 'turn.prompt', time: 4000, input: [{ type: 'text', text: 'hi' }] },
+  { type: 'context.append_message', time: 4001, message: { role: 'assistant', content: [{ type: 'text', text: 'Legacy reply.' }] } },
+]);
+scan = kimiCodeScan(legacyOnly);
+check('the older assistant message shape still reads', scan.messages.some((m) => m.role === 'assistant' && m.text === 'Legacy reply.'));
+check('the older shape still closes the turn', scan.busy === false);
+
+// A turn that has been opened and not closed is genuinely busy.
+const working = write('busy.jsonl', [
+  { type: 'turn.prompt', time: 5000, input: [{ type: 'text', text: 'do a long thing' }] },
+]);
+check('an open turn still reads as busy', kimiCodeScan(working).busy === true);
+
+fs.rmSync(tmp, { recursive: true, force: true });
+
+// Against whatever this Mac actually has.
+const root = path.join(os.homedir(), '.kimi-code', 'sessions');
+const wires = [];
+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 < 4) walk(p, depth + 1);
+    else if (e.name === 'wire.jsonl') wires.push(p);
+  }
+};
+walk(root, 0);
+
+if (!wires.length) {
+  console.log('\nskipped the live checks: no Kimi Code sessions on this Mac');
+} else {
+  console.log(`\n${wires.length} live journal(s)`);
+  for (const w of wires) {
+    const live = kimiCodeScan(w);
+    const answered = live.messages.filter((m) => m.role === 'assistant').length;
+    const asked = live.messages.filter((m) => m.role === 'user').length;
+    console.log(`  ${path.basename(path.dirname(path.dirname(path.dirname(w))))}: ${asked} asked, ${answered} answered, busy=${live.busy}`);
+    // The whole point: a journal with questions in it must have answers too.
+    if (asked > 0) check(`live journal has replies, not just prompts`, answered > 0);
+  }
+}
+
+console.log(failures ? `\n${failures} FAILURE(S)` : '\nall checks passed');
+process.exit(failures ? 1 : 0);

package/test/providers.mjs

@@ -0,0 +1,67 @@
+// Every pilot on the island wears a tag saying which agent it is, and the tag
+// comes from the `provider` field on the session. A reader that builds a session
+// without one puts an unlabelled pilot on the island, which is a silent failure:
+// the invader looks fine and simply refuses to say what it is.
+//
+// This is a static check on the source rather than a runtime one, because
+// building a real session means having that agent installed. Cheap, and it
+// catches the actual mistake: adding a provider and forgetting the field.
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const DAEMON = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'daemon.mjs');
+const src = fs.readFileSync(DAEMON, 'utf8');
+const lines = src.split('\n');
+
+let failures = 0;
+const check = (label, cond, detail = '') => {
+  console.log(`${cond ? 'ok  ' : 'FAIL'} ${label}${detail ? `  ${detail}` : ''}`);
+  if (!cond) failures++;
+};
+
+// Find every `sessions.push({ ... })` and read the object literal that follows,
+// counting braces so a nested object cannot end the block early.
+const blocks = [];
+lines.forEach((line, i) => {
+  if (!/sessions\.push\(\{\s*$/.test(line.trim())) return;
+  let depth = 1;
+  const body = [];
+  for (let j = i + 1; j < lines.length && depth > 0; j++) {
+    for (const ch of lines[j]) {
+      if (ch === '{') depth++;
+      else if (ch === '}') depth--;
+    }
+    if (depth > 0) body.push(lines[j]);
+  }
+  blocks.push({ line: i + 1, body: body.join('\n') });
+});
+
+check('found the session builders', blocks.length >= 4, `${blocks.length} found`);
+
+for (const b of blocks) {
+  const match = b.body.match(/provider:\s*'([^']+)'/);
+  check(`daemon.mjs:${b.line} sets a provider`, !!match, match ? match[1] : b.body.split('\n')[0].trim());
+}
+
+// The Swift side switches on these exact strings. A provider the app has never
+// heard of still renders, uppercased, but a rename would silently drop a brand
+// name that used to be there, so the known set is pinned.
+const providers = new Set(blocks.map((b) => (b.body.match(/provider:\s*'([^']+)'/) || [])[1]).filter(Boolean));
+for (const known of ['claude', 'codex', 'kimi', 'kimicode', 'grokbot']) {
+  check(`${known} is still a provider the daemon emits`, providers.has(known));
+}
+
+const MODELS = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', '..', 'ios', 'GroundControl', 'Models.swift');
+if (fs.existsSync(MODELS)) {
+  const swift = fs.readFileSync(MODELS, 'utf8');
+  check('the app decodes provider at all', /let provider: String\?/.test(swift));
+  for (const p of providers) {
+    check(`the app has a label for ${p}`, swift.includes(`"${p}"`));
+  }
+} else {
+  console.log('skipped the app side: Models.swift not found');
+}
+
+console.log(failures ? `\n${failures} FAILURE(S)` : '\nall checks passed');
+process.exit(failures ? 1 : 0);

package/test/run.mjs

@@ -0,0 +1,23 @@
+// Every test in this directory, in one run. Plain node, no framework, matching
+// the rest of the CLI: the daemon ships with two runtime dependencies and a
+// test runner is not going to be the third.
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const dir = path.dirname(fileURLToPath(import.meta.url));
+const files = fs.readdirSync(dir).filter((f) => f.endsWith('.mjs') && f !== 'run.mjs').sort();
+
+let failed = 0;
+for (const f of files) {
+  console.log(`\n=== ${f} ===`);
+  try {
+    execFileSync(process.execPath, [path.join(dir, f)], { stdio: 'inherit' });
+  } catch {
+    failed++;
+  }
+}
+
+console.log(failed ? `\n${failed} of ${files.length} test file(s) failed` : `\n${files.length} test file(s) passed`);
+process.exit(failed ? 1 : 0);