@clastres/groundcontrol 0.1.9 → 0.1.11

package/daemon.mjs

@@ -22,7 +22,7 @@ import { createRequire } from 'node:module';
 
 const execFileP = promisify(execFile);
 
-const VERSION = '0.1.9';
+const VERSION = '0.1.11';
 const PACKAGE = '@clastres/groundcontrol';
 
 // ---------- config / pairing ----------
@@ -867,7 +867,6 @@ 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;
@@ -996,6 +995,15 @@ function codexMetaOf(file) {
         id: j.payload.session_id,
         cwd: j.payload.cwd || '',
         startedAt: Date.parse(j.payload.timestamp || j.timestamp) || 0,
+        // Codex spawns its own helpers (the review subagent, for one) as
+        // separate rollout files that carry the *parent's* session_id. Two
+        // files, one id: the phone would draw one pilot and leave a hole
+        // where the other should be, because both the crew list and the
+        // island key on the session id. A helper is not a pilot anyway, so
+        // it is marked here and dropped by the scan, which keeps the answer
+        // in the cache rather than re-reading a growing file every sweep.
+        helper: j.payload.thread_source === 'subagent'
+          || (!!j.payload.parent_thread_id && j.payload.parent_thread_id !== j.payload.id),
       };
     }
   } catch {}
@@ -1090,17 +1098,29 @@ function readCodexSessions() {
   codexCache.at = Date.now();
   const names = codexThreadNames();
   const sessions = [];
+  // One pilot per folder, not one per run.
+  //
+  // Codex has no long lived session the way Claude Code does: every `codex
+  // exec` writes its own rollout, so asking it to review a change three times
+  // in an afternoon used to put three identical pilots on the island, all in
+  // the same directory, none of them the one you meant. The freshest rollout
+  // in a folder is the one worth talking to, and prompting resumes it by id,
+  // so the older ones have nothing left to offer.
+  const newestPerCwd = new Map(); // cwd -> index into 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;
+    if (!meta || meta.helper) 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;
+    const key = meta.cwd || `id:${meta.id}`;
+    const seen = newestPerCwd.get(key);
+    if (seen !== undefined && sessions[seen].updatedAt >= mtime) continue;
     transcriptCache.set(meta.id, file);
-    sessions.push({
+    const session = {
       id: meta.id,
       provider: 'codex',
       name: names.get(meta.id) || path.basename(meta.cwd || '?'),
@@ -1112,7 +1132,9 @@ function readCodexSessions() {
       lastMessage: act.lastMessage,
       tty: '',
       live: false,
-    });
+    };
+    if (seen !== undefined) sessions[seen] = session;
+    else { newestPerCwd.set(key, sessions.length); sessions.push(session); }
   }
   codexCache.sessions = sessions;
   return sessions;
@@ -1439,157 +1461,6 @@ 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,
@@ -1601,7 +1472,7 @@ const askPayload = (ask, queued) => ({
 });
 
 function readSessions() {
-  const sessions = [...readClaudeSessions(), ...readCodexSessions(), ...readKimiSessions(), ...readGrokBotSessions()];
+  const sessions = [...readClaudeSessions(), ...readCodexSessions(), ...readKimiSessions()];
   const known = new Set(sessions.map((s) => s.id));
   for (const s of sessions) {
     const queue = askQueue.get(s.id);
@@ -1640,7 +1511,20 @@ function readSessions() {
   }
 
   sessions.sort((a, b) => a.startedAt - b.startedAt);
-  return sessions;
+  // One row per id, whatever the providers hand over.
+  //
+  // The phone keys every pilot on the session id: the crew list draws a
+  // ForEach over it and the island keeps one sprite per id. Two rows sharing
+  // one id do not draw twice, they draw once and leave a hole the height of a
+  // card where the other should be, which reads as a layout bug rather than
+  // as bad data. Codex was the source of that once already; this is here so
+  // the next provider that repeats an id cannot do it again.
+  const byId = new Map();
+  for (const s of sessions) {
+    const seen = byId.get(s.id);
+    if (!seen || (s.updatedAt || 0) > (seen.updatedAt || 0)) byId.set(s.id, s);
+  }
+  return byId.size === sessions.length ? sessions : sessions.filter((s) => byId.get(s.id) === s);
 }
 
 // ---------- remote approvals: runtime ----------
@@ -1673,6 +1557,10 @@ function hostState() {
       settingsOk: settings !== null,
       socketOk: approvalServerUp,
     },
+    // Which agents the phone may start here. An empty list is a real answer
+    // (nothing launchable found); the whole field missing is an older daemon,
+    // and the app hides the button rather than offering one that cannot work.
+    launch: { providers: launchProviders() },
     updateAvailable: availableUpdate,
   };
   hostCache = { at: Date.now(), value };
@@ -1817,6 +1705,9 @@ function onPermissionRequest(req, socket) {
     at: Date.now(),
     socket,
     done: false,
+    // Set once Claude Code has actually reported this session as waiting, so
+    // releaseAnsweredOnMac knows there was a prompt on the Mac to answer.
+    sawWaiting: false,
   };
   ask.holdTimer = setTimeout(
     () => settleAsk(ask, null, 'released', 'held too long, prompting on the Mac instead'),
@@ -1901,10 +1792,30 @@ const ANSWERED_GRACE_MS = 6000;
 function releaseAnsweredOnMac() {
   if (!pendingAsks.size) return;
   for (const ask of [...pendingAsks.values()]) {
-    if (Date.now() - ask.at < ANSWERED_GRACE_MS) continue;
     const status = lastRawStatus.get(ask.sessionId);
     // Unknown session: nothing to conclude, leave it to the socket or the cap.
-    if (!status || status === 'waiting') continue;
+    if (!status) continue;
+    // Recorded before the grace period is checked, not after: the prompt is
+    // most likely to be showing as waiting in exactly those first seconds.
+    if (status === 'waiting') { ask.sawWaiting = true; continue; }
+    if (Date.now() - ask.at < ANSWERED_GRACE_MS) continue;
+    // Not waiting is only evidence of an answer if we watched the prompt go
+    // up in the first place.
+    //
+    // Claude Code writes "waiting" for the prompt it draws itself, and a
+    // permission request raised from inside a running turn never gets one:
+    // the session sits on "busy" for as long as the hook blocks. Concluding
+    // from that alone declared every gated command inside a turn answered six
+    // seconds after it was asked, so the card vanished off the phone mid tap
+    // and the session stayed stopped on a question nobody could answer from
+    // there any more.
+    //
+    // Idle is the signal that is safe to read instead. A session cannot go
+    // idle while a hook is blocking a tool call, so idle means the turn ran
+    // to the end and this request is long settled, whatever settled it. Busy
+    // and shell mean the turn is still in flight, which is exactly when the
+    // card has to stay put.
+    if (!ask.sawWaiting && (status === 'busy' || status === 'shell')) continue;
     settleAsk(ask, null, 'gone', 'answered on the Mac');
   }
 }
@@ -2036,14 +1947,8 @@ function watchTranscript(sessionId) {
   if (!file) return;
   let debounce;
   try {
-    // 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;
+    // Journals are appended to, so watching the file is enough.
+    const w = fs.watch(file, () => {
       clearTimeout(debounce);
       debounce = setTimeout(() => {
         ws?.send(seal({ type: 'transcript', sessionId, messages: readMessages(sessionId) }));
@@ -2106,6 +2011,14 @@ async function handleCommand(cmd) {
       settleAsk(ask, { behavior: 'deny', message: reason || 'Denied from the Ground Control app.' },
         'denied', reason ? `from the phone: ${reason.slice(0, 60)}` : 'from the phone');
     }
+  } else if (cmd.type === 'projects') {
+    ws?.send(seal({
+      type: 'projects',
+      projects: knownProjects().map((p) => ({ path: p.path, name: p.name, at: p.at })),
+      providers: launchProviders(),
+    }));
+  } else if (cmd.type === 'launch') {
+    await launchSession(cmd);
   } else if (cmd.type === 'ping' && cmd.sessionId) {
     const s = readSessions().find((x) => x.id === cmd.sessionId);
     ws?.send(seal({ type: 'pong', sessionId: cmd.sessionId, alive: !!s, status: s?.status || 'gone', at: Date.now() }));
@@ -2113,15 +2026,6 @@ 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.
@@ -2201,7 +2105,6 @@ const headlessPromptSpec = {
 function bustProviderCaches() {
   codexCache.at = 0;
   kimiCache.at = 0;
-  grokbotCache.at = 0;
 }
 
 function promptHeadless(session, text) {
@@ -2258,6 +2161,166 @@ function promptHeadless(session, text) {
   watchTranscript(session.id);
 }
 
+// ---------- launching a new pilot ----------
+// Everything above answers a session that already exists. This starts one.
+//
+// The phone never sends a path. It picks from a list this daemon built out of
+// what is already on disk, and the launch validates the choice against that
+// same list before running anything, so the worst a stolen channel can do is
+// open a terminal in a folder you have already worked in today.
+
+const PROJECT_LIMIT = 40;
+/// A folder nobody has touched in three months is not what you meant to open
+/// from your phone, and the list has to fit on a phone screen.
+const PROJECT_MAX_AGE_MS = 90 * 24 * 60 * 60 * 1000;
+
+/// The real working directory behind one of Claude Code's project folders.
+///
+/// The folder name is the path with every slash turned into a dash, which
+/// cannot be undone: a directory with a dash in its own name decodes to
+/// something that was never there. The transcripts inside record the actual
+/// cwd, so read it rather than guess it.
+function projectCwd(dir) {
+  let files = [];
+  try {
+    files = fs.readdirSync(dir)
+      .filter((f) => f.endsWith('.jsonl'))
+      .map((f) => {
+        const p = path.join(dir, f);
+        try { return { p, at: fs.statSync(p).mtimeMs }; } catch { return null; }
+      })
+      .filter(Boolean)
+      .sort((a, b) => b.at - a.at);
+  } catch { return null; }
+  if (!files.length) return null;
+
+  for (const { p, at } of files.slice(0, 3)) {
+    let head = '';
+    try {
+      const fd = fs.openSync(p, 'r');
+      const buf = Buffer.alloc(64 * 1024);
+      const read = fs.readSync(fd, buf, 0, buf.length, 0);
+      fs.closeSync(fd);
+      head = buf.subarray(0, read).toString('utf8');
+    } catch { continue; }
+    for (const line of head.split('\n')) {
+      if (!line.trim()) continue;
+      let e; try { e = JSON.parse(line); } catch { continue; }
+      if (typeof e.cwd === 'string' && e.cwd) return { cwd: e.cwd, at };
+    }
+  }
+  return null;
+}
+
+let projectsCache = { at: 0, value: [] };
+function knownProjects() {
+  if (Date.now() - projectsCache.at < 60_000) return projectsCache.value;
+  const byPath = new Map();
+  const note = (cwd, at) => {
+    if (!cwd || !fs.existsSync(cwd)) return;
+    const prev = byPath.get(cwd);
+    if (!prev || prev.at < at) byPath.set(cwd, { path: cwd, name: path.basename(cwd) || cwd, at });
+  };
+
+  let dirs = [];
+  try { dirs = fs.readdirSync(PROJECTS_DIR); } catch {}
+  for (const d of dirs) {
+    const found = projectCwd(path.join(PROJECTS_DIR, d));
+    if (found) note(found.cwd, found.at);
+  }
+  // Whatever is flying right now, even if its transcript has not landed yet.
+  for (const s of readSessions()) note(s.cwd, Date.now());
+
+  const cutoff = Date.now() - PROJECT_MAX_AGE_MS;
+  const value = [...byPath.values()]
+    .filter((p) => p.at >= cutoff)
+    .sort((a, b) => b.at - a.at)
+    .slice(0, PROJECT_LIMIT);
+  projectsCache = { at: Date.now(), value };
+  return value;
+}
+
+/// Which agents this Mac can start from the phone.
+///
+/// Claude Code only, on purpose. Every provider here has to be one whose bare
+/// command opens an interactive session that then shows up on the island, and
+/// claude is the one that has been checked. Codex and the kimi CLIs are read
+/// and written by the daemon already, but nobody has watched either of them
+/// come up this way, so offering them would be a button that might do nothing.
+function launchProviders() {
+  return claudeBin() ? ['claude'] : [];
+}
+
+/// Single quotes for the shell, then AppleScript quoting on top. Both layers
+/// matter: the directory comes from disk and the first order comes from your
+/// thumbs.
+const shq = (s) => `'${String(s).replace(/'/g, `'\\''`)}'`;
+
+let lastLaunchAt = 0;
+
+async function launchSession(cmd) {
+  const fail = (error) => ws?.send(seal({ type: 'launchResult', ok: false, error }));
+
+  const providers = launchProviders();
+  const provider = cmd.provider || 'claude';
+  if (!providers.includes(provider)) {
+    return fail(`This Mac cannot start a ${provider} session from the phone. Ground Control could not find the ${provider} command on your PATH.`);
+  }
+  const target = knownProjects().find((p) => p.path === cmd.cwd);
+  if (!target) {
+    // The list is a minute old at most, so this is almost always a folder that
+    // was renamed or deleted since it was drawn.
+    return fail('That folder is not on this Mac any more. Pull the list again.');
+  }
+  if (Date.now() - lastLaunchAt < 5000) {
+    return fail('One at a time. Give the last launch a few seconds.');
+  }
+
+  const apps = terminalApps();
+  const first = (cmd.text || '').trim();
+  // Claude Code takes an opening prompt as a positional argument and starts the
+  // normal interactive session with it already submitted, which beats waiting a
+  // guessed number of seconds for a REPL to boot and then typing at it.
+  const line = `cd ${shq(target.path)} && ${provider}${first ? ` ${shq(first)}` : ''}`;
+
+  lastLaunchAt = Date.now();
+  let opened = null;
+  if (apps.iterm) {
+    const r = await osascript(`tell application "iTerm2"
+  activate
+  set w to (create window with default profile)
+  tell current session of w to write text "${escapeAS(line)}"
+  return "ok"
+end tell`);
+    if (r === 'ok') opened = 'iTerm2';
+  }
+  if (!opened) {
+    // Terminal.app is on every Mac, and telling it to do a script launches it
+    // if it was closed, so this is the path that always exists.
+    const r = await osascript(`tell application "Terminal"
+  activate
+  do script "${escapeAS(line)}"
+  return "ok"
+end tell`);
+    if (r === 'ok') opened = 'Terminal';
+  }
+
+  if (!opened) {
+    lastLaunchAt = 0;
+    if (automationDenied) {
+      return fail('Your Mac is blocking terminal control. Open System Settings, Privacy and Security, Automation, and allow node to control your terminal app. Then try again.');
+    }
+    return fail('Could not open a terminal window on your Mac.');
+  }
+
+  console.log(`[daemon] launched ${provider} in ${target.path} via ${opened}`);
+  // The new session reaches the island through the same discovery every other
+  // one does, which takes a few seconds. Say so rather than implying the pilot
+  // is already there.
+  ws?.send(seal({ type: 'launchResult', ok: true, cwd: target.path, note: `${provider} is starting in ${target.name}` }));
+  sendSnapshot(true);
+}
+
 let lastPongAt = Date.now();
 
 function connect() {
@@ -2359,4 +2422,3 @@ function watchProviderDir(dir, cache, label) {
 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,7 +1,7 @@
 {
   "name": "@clastres/groundcontrol",
-  "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.",
+  "version": "0.1.11",
+  "description": "See and command your coding agents from your iPhone. Pairs the Ground Control app with Claude Code, Codex and Kimi sessions running on this Mac, end to end encrypted.",
   "bin": {
     "groundcontrol": "bin/groundcontrol.mjs"
   },
@@ -21,7 +21,6 @@
     "claude-code",
     "codex",
     "kimi",
-    "grok",
     "ai",
     "agents",
     "cli",

package/test/approvals.mjs

@@ -0,0 +1,121 @@
+// A held permission request must clear when it is answered on the Mac, and
+// must NOT clear while it is still genuinely waiting on you. That balance has
+// been wrong twice, in both directions, so it gets a test.
+//
+// The fast path is the hook's socket closing, and in practice it almost never
+// fires: 182 of 189 settlements in a real daemon log came from this function
+// instead. So the status reading is the mechanism, not the safety net.
+//
+// Wrong the first way: any status other than "waiting" counted as answered.
+// Claude Code only writes "waiting" for the prompt it draws itself, and a
+// permission request raised from inside a running turn never gets one, so
+// every gated command inside a turn was declared answered six seconds after
+// it was asked. The card vanished off the phone mid tap and the session
+// stayed stopped on a question nobody could answer from there.
+//
+// Wrong the second way: requiring "waiting" to have been seen at all. That is
+// correct and it never lets go, so a request genuinely answered on the Mac
+// leaves a phantom card until the twelve hour hold cap.
+//
+// Right: hold through busy and shell, let go on idle. A session cannot report
+// idle while a hook is blocking a tool call.
+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 start = src.indexOf('const ANSWERED_GRACE_MS');
+const end = src.indexOf('/// Sitting back down at the Mac clears the phone card.');
+if (start < 0 || end < 0 || end < start) throw new Error('could not locate releaseAnsweredOnMac in daemon.mjs');
+
+let failures = 0;
+const check = (label, cond, detail = '') => {
+  console.log(`${cond ? 'ok  ' : 'FAIL'} ${label}${detail ? `  ${detail}` : ''}`);
+  if (!cond) failures++;
+};
+
+const settled = [];
+const pendingAsks = new Map();
+const lastRawStatus = new Map();
+const settleAsk = (ask, _decision, outcome, note) => {
+  pendingAsks.delete(ask.id);
+  settled.push({ id: ask.id, outcome, note });
+};
+
+const { releaseAnsweredOnMac, ANSWERED_GRACE_MS } = new Function(
+  'pendingAsks', 'lastRawStatus', 'settleAsk',
+  `${src.slice(start, end)}\n return { releaseAnsweredOnMac, ANSWERED_GRACE_MS };`,
+)(pendingAsks, lastRawStatus, settleAsk);
+
+/// A held request, aged so the grace period is behind it unless asked otherwise.
+function hold(id, sessionId, { ageMs = ANSWERED_GRACE_MS + 1000, sawWaiting = false } = {}) {
+  const ask = { id, sessionId, at: Date.now() - ageMs, sawWaiting };
+  pendingAsks.set(id, ask);
+  return ask;
+}
+const reset = () => { pendingAsks.clear(); lastRawStatus.clear(); settled.length = 0; };
+const outcomeOf = (id) => settled.find((s) => s.id === id)?.outcome;
+
+// The bug Carlos hit: a gated command inside a running turn. Claude never says
+// waiting, it says busy for as long as the hook blocks.
+reset();
+hold('a1', 's-busy');
+lastRawStatus.set('s-busy', 'busy');
+releaseAnsweredOnMac();
+check('a request held inside a running turn is not declared answered', pendingAsks.has('a1'), outcomeOf('a1') || 'still held');
+
+// Same, for a session running a shell command.
+reset();
+hold('a2', 's-shell');
+lastRawStatus.set('s-shell', 'shell');
+releaseAnsweredOnMac();
+check('nor one held while a shell command runs', pendingAsks.has('a2'));
+
+// The other failure mode: the turn ended, so whatever was holding it is gone.
+reset();
+hold('a3', 's-idle');
+lastRawStatus.set('s-idle', 'idle');
+releaseAnsweredOnMac();
+check('an idle session releases the request', outcomeOf('a3') === 'gone', outcomeOf('a3') || 'still held');
+
+// A busy session that later goes idle has to release, or the card is phantom
+// until the twelve hour cap.
+reset();
+const a4 = hold('a4', 's-turn');
+lastRawStatus.set('s-turn', 'busy');
+releaseAnsweredOnMac();
+const heldDuringTurn = pendingAsks.has('a4');
+lastRawStatus.set('s-turn', 'idle');
+releaseAnsweredOnMac();
+check('held through the turn, released when it ends', heldDuringTurn && outcomeOf('a4') === 'gone');
+check('the ask is not left in the pending map', !pendingAsks.has('a4') && a4.id === 'a4');
+
+// Claude's own prompt does write waiting, and dropping out of it is the
+// original signal, which still has to work.
+reset();
+hold('a5', 's-prompt');
+lastRawStatus.set('s-prompt', 'waiting');
+releaseAnsweredOnMac();
+const heldWhileWaiting = pendingAsks.has('a5');
+lastRawStatus.set('s-prompt', 'busy');
+releaseAnsweredOnMac();
+check('a prompt seen waiting releases as soon as it stops waiting',
+  heldWhileWaiting && outcomeOf('a5') === 'gone', outcomeOf('a5') || 'still held');
+
+// The grace period covers the gap between the hook firing and Claude Code
+// getting round to writing its status.
+reset();
+hold('a6', 's-fresh', { ageMs: 1000 });
+lastRawStatus.set('s-fresh', 'idle');
+releaseAnsweredOnMac();
+check('a request younger than the grace period is left alone', pendingAsks.has('a6'));
+
+// A session the daemon cannot see at all is not evidence of anything.
+reset();
+hold('a7', 's-unknown');
+releaseAnsweredOnMac();
+check('an unknown session releases nothing', pendingAsks.has('a7'));
+
+console.log(failures ? `\n${failures} FAILURE(S)` : '\nall checks passed');
+process.exit(failures ? 1 : 0);

package/test/codex.mjs

@@ -0,0 +1,94 @@
+// Codex writes one rollout file per run, and two of the ways it does that used
+// to put holes in the app.
+//
+// A helper thread (the review subagent) gets its own rollout carrying the
+// *parent's* session_id, so the daemon reported two sessions under one id. The
+// phone keys every pilot on that id, so it drew one and left a card sized gap
+// where the other should have been, on the crew list and on the island both.
+//
+// And a plain `codex exec` starts a fresh rollout every time, so asking Codex
+// to review something three times in one folder put three identical pilots on
+// the island. Only the freshest one in a directory is worth talking to.
+//
+// This runs the real reader out of daemon.mjs against a synthetic ~/.codex.
+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('// ---------- Codex session discovery ----------');
+const end = src.indexOf('// ---------- Kimi session discovery ----------');
+if (start < 0 || end < 0 || end < start) throw new Error('could not locate the Codex block in daemon.mjs');
+
+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-codex-'));
+const day = path.join(tmp, 'sessions', '2026', '09', '05');
+fs.mkdirSync(day, { recursive: true });
+
+/// One rollout: the session_meta line, then a finished turn so the reader has
+/// something to call a last message.
+function rollout(name, meta, { text = 'hello', minutesAgo = 1 } = {}) {
+  const file = path.join(day, `rollout-${name}.jsonl`);
+  const at = new Date(Date.now() - minutesAgo * 60_000).toISOString();
+  fs.writeFileSync(file, [
+    JSON.stringify({ timestamp: at, type: 'session_meta', payload: { timestamp: at, ...meta } }),
+    JSON.stringify({ timestamp: at, type: 'event_msg', payload: { type: 'task_started' } }),
+    JSON.stringify({ timestamp: at, type: 'event_msg', payload: { type: 'agent_message', message: text } }),
+    JSON.stringify({ timestamp: at, type: 'event_msg', payload: { type: 'task_complete' } }),
+    '',
+  ].join('\n'));
+  const when = Date.now() - minutesAgo * 60_000;
+  fs.utimesSync(file, when / 1000, when / 1000);
+  return file;
+}
+
+const PROJECT = '/tmp/project-one';
+const OTHER = '/tmp/project-two';
+
+// The pair that broke it: a run and the review helper it spawned, same second,
+// same id, two files.
+rollout('a-parent', { session_id: 'id-parent', id: 'id-parent', cwd: PROJECT, thread_source: 'user', source: 'exec' },
+  { text: 'the older run', minutesAgo: 9 });
+rollout('a-helper', { session_id: 'id-parent', id: 'id-child', parent_thread_id: 'id-parent', cwd: PROJECT, thread_source: 'subagent', source: { subagent: 'review' } },
+  { text: 'reviewing', minutesAgo: 8 });
+// A second, unrelated run in the same folder, more recent than both.
+rollout('b-newer', { session_id: 'id-newer', id: 'id-newer', cwd: PROJECT, thread_source: 'user', source: 'exec' },
+  { text: 'the newest run', minutesAgo: 2 });
+// A different folder, which must survive on its own.
+rollout('c-other', { session_id: 'id-other', id: 'id-other', cwd: OTHER, thread_source: 'user', source: 'exec' },
+  { text: 'elsewhere', minutesAgo: 3 });
+// Older than the active window: gone from the fleet entirely.
+rollout('d-stale', { session_id: 'id-stale', id: 'id-stale', cwd: '/tmp/project-three', thread_source: 'user', source: 'exec' },
+  { text: 'yesterday', minutesAgo: 60 * 5 });
+
+// tailLines, memoScan and scanMemo all live inside the extracted block, so the
+// only things handed in are the modules and the two maps the daemon shares.
+const block = src.slice(start, end)
+  .replace(/const CODEX_DIR = .*/, `const CODEX_DIR = ${JSON.stringify(tmp)};`);
+
+const { readCodexSessions } = new Function('fs', 'os', 'path', 'transcriptCache', 'headlessActive',
+  `${block}\n return { readCodexSessions };`)(fs, os, path, new Map(), new Set());
+
+const sessions = readCodexSessions();
+const ids = sessions.map((s) => s.id);
+const cwds = sessions.map((s) => s.cwd);
+
+check('the helper thread is not a pilot', !ids.includes('id-child') && ids.filter((i) => i === 'id-parent').length <= 1, ids.join(', '));
+check('no id appears twice', new Set(ids).size === ids.length, ids.join(', '));
+check('one pilot per folder', new Set(cwds).size === cwds.length, cwds.join(', '));
+check('the folder keeps its freshest run', ids.includes('id-newer') && !ids.includes('id-parent'), ids.join(', '));
+check('a second folder still flies', ids.includes('id-other'));
+check('a stale rollout is off the island', !ids.includes('id-stale'));
+check('the surviving pilot carries its own last message',
+  sessions.find((s) => s.id === 'id-newer')?.lastMessage?.text === 'the newest run');
+
+fs.rmSync(tmp, { recursive: true, force: true });
+console.log(failures ? `\n${failures} FAILURE(S)` : '\nall checks passed');
+process.exit(failures ? 1 : 0);

package/test/launch.mjs

@@ -0,0 +1,73 @@
+// Starting a session from the phone crosses the two languages twice: the app
+// sends a command the daemon has to know, and the daemon answers with a reply
+// type the app has to decode. Either half can be renamed on its own and
+// nothing complains until a button on a phone quietly does nothing.
+//
+// Static checks on both sources, in the same spirit as providers.mjs. They do
+// not prove a terminal opens; they prove the two ends are still talking about
+// the same thing.
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const daemon = fs.readFileSync(path.join(here, '..', 'daemon.mjs'), 'utf8');
+const app = path.join(here, '..', '..', 'ios', 'GroundControl');
+const client = fs.readFileSync(path.join(app, 'RelayClient.swift'), 'utf8');
+const models = fs.readFileSync(path.join(app, 'Models.swift'), 'utf8');
+
+let failures = 0;
+const check = (label, cond, detail = '') => {
+  console.log(`${cond ? 'ok  ' : 'FAIL'} ${label}${detail ? `  ${detail}` : ''}`);
+  if (!cond) failures++;
+};
+
+// ---------- every command the app sends, the daemon handles ----------
+
+const sent = [...client.matchAll(/Command\(type:\s*"([^"]+)"/g)].map((m) => m[1]);
+check('the app sends commands at all', sent.length >= 8, `${sent.length} found`);
+for (const type of [...new Set(sent)].sort()) {
+  check(`the daemon handles "${type}"`, daemon.includes(`cmd.type === '${type}'`));
+}
+
+// ---------- every reply the daemon sends, the app decodes ----------
+
+// hb is the daemon's heartbeat. It carries nothing, and the app wants it only
+// for the fact that something arrived, which every message does: receiving it
+// stamps lastActivity and it falls through the switch on purpose.
+const replies = [...daemon.matchAll(/seal\(\{\s*\n?\s*type:\s*'([^']+)'/g)].map((m) => m[1]);
+for (const type of [...new Set(replies)].sort().filter((t) => t !== 'hb')) {
+  // The app switches on envelope type. "snapshot" and the rest each get a case.
+  check(`the app decodes "${type}"`, client.includes(`case "${type}"`));
+}
+
+// ---------- the launch payload ----------
+
+check('the launch command carries a folder', /var cwd: String\?/.test(models));
+check('the launch command carries a provider', /var provider: String\?/.test(models));
+check('the app models the folders the Mac offers', /struct ProjectDir/.test(models));
+check('the app models what the Mac will launch', /struct LaunchInfo/.test(models));
+check('the host block reports launchable providers', /launch:\s*\{\s*providers:\s*launchProviders\(\)\s*\}/.test(daemon));
+
+// ---------- the folder has to come from the Mac's own list ----------
+// The phone must never be able to name a path. If this stops being true, a
+// stolen channel turns into "run an agent anywhere on this Mac".
+
+const body = daemon.slice(daemon.indexOf('async function launchSession'));
+check('a launch validates the folder against the offered list',
+  /knownProjects\(\)\.find\(\(p\) => p\.path === cmd\.cwd\)/.test(body));
+check('a launch refuses a folder that is not on the list',
+  body.indexOf('return fail(') < body.indexOf('osascript'));
+
+// ---------- only what has actually been checked is offered ----------
+// Codex and the kimi CLIs are read and written elsewhere in this daemon, but
+// nobody has watched either of them come up from a cold terminal launch, so
+// they are deliberately not on this list. Adding one here without checking it
+// ships a button that may do nothing.
+
+const providers = daemon.slice(daemon.indexOf('function launchProviders'));
+const listed = providers.slice(0, providers.indexOf('}'));
+check('only claude is offered for launch', /claudeBin\(\) \? \['claude'\] : \[\]/.test(listed));
+
+console.log(failures ? `\n${failures} check(s) failed` : '\nall checks passed');
+process.exit(failures ? 1 : 0);

package/test/providers.mjs

@@ -20,11 +20,14 @@ const check = (label, cond, 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.
+// Find every session object literal and read it, counting braces so a nested
+// object cannot end the block early. Most readers push one straight onto the
+// list; codex builds one first, because it keeps only the freshest rollout per
+// folder and may have to replace a row it already added.
 const blocks = [];
 lines.forEach((line, i) => {
-  if (!/sessions\.push\(\{\s*$/.test(line.trim())) return;
+  const t = line.trim();
+  if (!/sessions\.push\(\{\s*$/.test(t) && !/^const session = \{\s*$/.test(t)) return;
   let depth = 1;
   const body = [];
   for (let j = i + 1; j < lines.length && depth > 0; j++) {
@@ -48,7 +51,7 @@ for (const b of blocks) {
 // 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']) {
+for (const known of ['claude', 'codex', 'kimi', 'kimicode']) {
   check(`${known} is still a provider the daemon emits`, providers.has(known));
 }
 

package/test/grokbot.mjs

@@ -1,86 +0,0 @@
-// 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);