@clastres/groundcontrol 0.1.8 → 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.8';
+const VERSION = '0.1.9';
 const PACKAGE = '@clastres/groundcontrol';
 
 // ---------- config / pairing ----------
@@ -1232,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; }
@@ -1250,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') {
@@ -1267,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.
@@ -1276,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;
 }
@@ -1285,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; }
@@ -1298,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;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clastres/groundcontrol",
-  "version": "0.1.8",
+  "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"

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);