@clastres/groundcontrol 0.1.8 → 0.1.10

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.10';
 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;
 }
 
@@ -1564,6 +1673,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 };
@@ -1997,6 +2110,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() }));
@@ -2149,6 +2270,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() {

package/package.json

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

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