@clastres/groundcontrol 0.1.12 → 0.1.14

package/daemon.mjs

@@ -22,7 +22,7 @@ import { createRequire } from 'node:module';
 
 const execFileP = promisify(execFile);
 
-const VERSION = '0.1.12';
+const VERSION = '0.1.14';
 const PACKAGE = '@clastres/groundcontrol';
 
 // ---------- config / pairing ----------
@@ -84,6 +84,16 @@ const LOG_FILE = path.join(CONF_DIR, 'daemon.log');
 const THIS_FILE = fs.realpathSync(fileURLToPath(import.meta.url));
 const runsFromServiceDir = THIS_FILE.startsWith(SERVICE_DIR + path.sep);
 
+// The service log had no times, so a run of "stale relay link" lines could not
+// be told apart: a Mac waking from sleep, or a link failing every minute.
+// Only daemon lines, and only in the service, so the setup output stays clean.
+if (runsFromServiceDir) {
+  const plain = console.log.bind(console);
+  console.log = (first, ...rest) => (typeof first === 'string' && first.startsWith('[daemon]')
+    ? plain(`${new Date().toISOString()} ${first}`, ...rest)
+    : plain(first, ...rest));
+}
+
 const launchctl = (args) => {
   try { return execSync(`launchctl ${args}`, { stdio: 'pipe' }).toString(); }
   catch (e) { return (e.stdout?.toString() || '') + (e.stderr?.toString() || ''); }
@@ -811,7 +821,7 @@ function canInject(tty) {
 }
 
 // Returns the method used, or null if no terminal path was found.
-async function injectPrompt(tty, text) {
+async function injectNow(tty, text, returns = 2) {
   const dev = `/dev/${tty}`;
   const apps = terminalApps();
   const clean = text.replace(/\r?\n/g, ' ').trim();
@@ -844,7 +854,41 @@ async function injectPrompt(tty, text) {
 end tell`);
     if (r === 'ok') {
       await sleep(150);
-      await osascript(`tell application "iTerm2"
+      await pressEnter(tty, 'iterm');
+      return 'iterm';
+    }
+  }
+  if (apps.terminal) {
+    // do script always ends the text with its own newline, so the text and a
+    // Return arrive as one chunk and Claude Code takes them as a paste. Past
+    // about 40 characters that paste also swallows the next bare Return,
+    // whatever the delay: measured on 2.1.295, a 72 character prompt sat in
+    // the input box until a second Return. A Return on an empty box does
+    // nothing, so short prompts that already went through are safe. A menu
+    // is not an empty box, so the caller asks for fewer around one.
+    const r = await osascript(findTabScript('Terminal', dev, `do script "${escapeAS(clean)}" in tb`));
+    if (r === 'ok') {
+      for (let i = 0; i < returns; i++) {
+        await sleep(200);
+        await pressEnter(tty, 'terminal');
+      }
+      return 'terminal';
+    }
+  }
+  return null;
+}
+
+/// A bare Return into the terminal that hosts tty, through the same route the
+/// prompt took.
+async function pressEnter(tty, method) {
+  const dev = `/dev/${tty}`;
+  if (method === 'tmux') {
+    const pane = terminalApps().tmuxPanes.get(dev);
+    if (!pane) return false;
+    try { execFileSync('tmux', ['send-keys', '-t', pane, 'Enter'], { stdio: 'ignore' }); return true; } catch { return false; }
+  }
+  if (method === 'iterm') {
+    return await osascript(`tell application "iTerm2"
   repeat with w in windows
     repeat with tb in tabs of w
       repeat with s in sessions of tb
@@ -855,19 +899,32 @@ end tell`);
       end repeat
     end repeat
   end repeat
-end tell`);
-      return 'iterm';
-    }
-  }
-  if (apps.terminal) {
-    const r = await osascript(findTabScript('Terminal', dev, `do script "${escapeAS(clean)}" in tb`));
-    if (r === 'ok') {
-      await sleep(200);
-      await osascript(findTabScript('Terminal', dev, 'do script "" in tb'));
-      return 'terminal';
-    }
+end tell`) === 'ok';
   }
-  return null;
+  if (method === 'terminal') return await osascript(findTabScript('Terminal', dev, 'do script "" in tb')) === 'ok';
+  return false;
+}
+
+// One injection per terminal at a time. Each is two writes with a pause
+// between them (the text, then Enter), so two prompts landing together would
+// interleave into one run on prompt and a stray Enter. `watch` is called as
+// the slot opens, so it sees the session as this prompt finds it rather than
+// before the one queued ahead of it. It may return how many Returns to send
+// and a check, which runs inside the slot, so a follow up Return cannot land
+// on the next prompt's text.
+const injecting = new Map(); // tty -> tail of its queue
+function injectPrompt(tty, text, watch) {
+  const run = (injecting.get(tty) || Promise.resolve()).then(async () => {
+    let plan = {};
+    try { plan = watch?.() || {}; } catch {}
+    const method = await injectNow(tty, text, plan.returns);
+    if (method && plan.check) { try { await plan.check(method); } catch {} }
+    return method;
+  });
+  const tail = run.catch(() => null);
+  injecting.set(tty, tail);
+  tail.then(() => { if (injecting.get(tty) === tail) injecting.delete(tty); });
+  return run;
 }
 
 const headlessActive = new Set(); // sessionIds with a headless --resume in flight
@@ -926,11 +983,48 @@ function readMessages(sessionId, maxBytes = 512 * 1024, limit = 80) {
     if (role !== 'user' && role !== 'assistant') continue;
     const text = extractText(e.message).trim();
     if (!text || /^(<system-reminder>|<command-name>|<local-command|<command-message|\[Request interrupted|\[SYSTEM NOTIFICATION)/.test(text)) continue;
-    out.push({ role, text: text.slice(0, 4000), ts: e.timestamp || null });
+    // uuid is Claude Code's own id for the line, stable for as long as the
+    // journal lives. The phone keys its rows on it; text is no identity.
+    out.push({ role, text: text.slice(0, 4000), ts: e.timestamp || null, ...(e.uuid ? { id: e.uuid } : {}) });
   }
   return out.slice(-limit);
 }
 
+// The terminal taking the keys is not Claude taking the prompt: a Return
+// swallowed by a paste leaves the text in the input box, and the phone used
+// to hear ok for it. An idle session writes a prompt to its journal the moment
+// it is submitted, so look for it there, press Return once more if it is
+// missing, and report through `result.landed` if it still is. Leaving idle
+// counts too: a queued prompt or a slow prompt hook journals nothing yet, and
+// a status that has not caught up with the prompt ahead must not read as a
+// lost one. Claude's own dialog and a slash command's picker take every
+// Return as a choice, so those keep the one Return they always got.
+const claudeStatus = (sessionId) => readClaudeSessions().find((s) => s.id === sessionId)?.rawStatus || null;
+const lastUserId = (sessionId) => readMessages(sessionId).findLast((m) => m.role === 'user')?.id || null;
+async function promptLanded(sessionId, before, ms = 2500) {
+  for (let waited = 0; waited < ms; waited += 250) {
+    await sleep(250);
+    if (lastUserId(sessionId) !== before || claudeStatus(sessionId) !== 'idle') return true;
+  }
+  return false;
+}
+function promptWatch(session, text, result) {
+  return () => {
+    const status = claudeStatus(session.id);
+    if (text.trim().startsWith('/') || status === 'waiting') return { returns: 1 };
+    if (status !== 'idle') return {};
+    const before = lastUserId(session.id);
+    return {
+      check: async (how) => {
+        if (await promptLanded(session.id, before)) return;
+        console.log(`[daemon] ${session.name} did not take the prompt, pressing Return again`);
+        await pressEnter(session.tty, how);
+        result.landed = await promptLanded(session.id, before);
+      },
+    };
+  };
+}
+
 function readClaudeSessions() {
   const sessions = [];
   let files = [];
@@ -1506,8 +1600,63 @@ const askPayload = (ask, queued) => ({
   detail: ask.detail,
   at: ask.at,
   queued,
+  // ALWAYS only means something when Claude Code offered a rule to save.
+  // Apps before 0.1.11 ignore this and always show the button.
+  canAlways: ask.suggestions.length > 0,
+  ...(ask.questions ? { questions: ask.questions } : {}),
 });
 
+/// AskUserQuestion is a picker, not a yes or no. Allowing it without answers
+/// lets Claude carry on with nothing chosen, so the phone gets the questions
+/// themselves and answers them through updatedInput. Clipped, because every
+/// byte rides the relay and lands on a phone screen.
+function questionsOf(tool, input) {
+  if (tool !== 'AskUserQuestion' || !Array.isArray(input?.questions)) return null;
+  const qs = questionSources(input)
+    .map((q) => ({
+      question: q.question.slice(0, 600),
+      header: typeof q.header === 'string' ? q.header.slice(0, 40) : '',
+      multiSelect: q.multiSelect === true,
+      // choice is the default; text and number have no options to tap.
+      kind: typeof q.kind === 'string' ? q.kind : 'choice',
+      options: (Array.isArray(q.options) ? q.options : [])
+        .filter((o) => o && typeof o.label === 'string' && o.label)
+        .slice(0, 8)
+        .map((o) => ({
+          label: o.label.slice(0, 200),
+          description: typeof o.description === 'string' ? o.description.slice(0, 300) : '',
+        })),
+    }));
+  return qs.length ? qs : null;
+}
+
+/// The questions as Claude Code wrote them, in the order the phone sees them.
+/// Answers go back keyed by these full texts: the phone only ever sees a
+/// clipped copy, and Claude looks each answer up by the exact question.
+function questionSources(input) {
+  return (Array.isArray(input?.questions) ? input.questions : [])
+    .filter((q) => q && typeof q.question === 'string' && q.question)
+    .slice(0, 6);
+}
+
+/// The phone's picks, checked against the questions it was shown. Keys are
+/// the question text, which is how Claude Code looks them up; a multi select
+/// arrives as several labels and goes back joined, the way Claude's own
+/// picker reports it.
+function answersFor(ask, raw) {
+  if (!ask.questions || !raw || typeof raw !== 'object') return null;
+  const full = questionSources(ask.input);
+  const out = {};
+  ask.questions.forEach((q, i) => {
+    const v = raw[q.question];
+    const picked = (Array.isArray(v) ? v : [v])
+      .filter((x) => typeof x === 'string' && x.trim())
+      .map((x) => x.trim().slice(0, 2000));
+    if (picked.length) out[full[i]?.question ?? q.question] = picked.join(', ');
+  });
+  return Object.keys(out).length ? out : null;
+}
+
 function readSessions() {
   const sessions = [...readClaudeSessions(), ...readCodexSessions(), ...readKimiSessions()];
   const known = new Set(sessions.map((s) => s.id));
@@ -1691,6 +1840,12 @@ function summarizeTool(tool, input) {
       return { line: clip(i.url, 300), detail: clip(i.prompt, 300) };
     case 'WebSearch':
       return { line: clip(i.query, 300), detail: '' };
+    case 'AskUserQuestion': {
+      // The questions travel on their own (questionsOf); the line is just the
+      // first one, for older apps and the crew list.
+      const qs = Array.isArray(i.questions) ? i.questions : [];
+      return { line: clip(qs[0]?.question || 'Claude has a question', 300), detail: '' };
+    }
     default: {
       // Unknown or MCP tools: show whichever field reads most like a target,
       // and fall back to the whole input.
@@ -1716,6 +1871,13 @@ function settleAsk(ask, decision, outcome, note) {
   ask.done = true;
   clearTimeout(ask.holdTimer);
   dropAsk(ask);
+  // A hook that is already gone cannot take the answer. Saying "allowed" to
+  // the phone then would be a lie: the session never got it.
+  if (decision && (ask.socket.destroyed || !ask.socket.writable)) {
+    outcome = 'gone';
+    note = 'the session stopped waiting before your answer arrived';
+    decision = null;
+  }
   try { ask.socket.write(JSON.stringify({ decision: decision || null }) + '\n'); } catch {}
   try { ask.socket.end(); } catch {}
   console.log(`[daemon] permission ${ask.tool} ${outcome}${note ? `: ${note}` : ''}`);
@@ -1740,6 +1902,14 @@ function onPermissionRequest(req, socket) {
     tool: req.toolName || 'tool',
     line,
     detail,
+    // Kept whole for AskUserQuestion, whose answer is the same input with the
+    // answers added. Never sent to the phone as is.
+    input: req.toolInput && typeof req.toolInput === 'object' ? req.toolInput : {},
+    questions: questionsOf(req.toolName, req.toolInput),
+    // What Claude Code would save if you picked "don't ask again" on the Mac.
+    // ALWAYS on the phone sends these back as updatedPermissions; without
+    // them there is no rule to save, so the button is hidden.
+    suggestions: Array.isArray(req.permissionSuggestions) ? req.permissionSuggestions : [],
     cwd: req.cwd || '',
     at: Date.now(),
     socket,
@@ -2003,10 +2173,19 @@ function sendSnapshot(force = false) {
     return;
   }
   for (const s of sessions) if (s.rawStatus) lastRawStatus.set(s.id, s.rawStatus);
+  // A session that left the fleet takes its status with it. Kept, an idle from
+  // its last turn would read as "answered on the Mac" for the next request.
+  const present = new Set(sessions.map((s) => s.id));
+  for (const id of lastRawStatus.keys()) if (!present.has(id)) lastRawStatus.delete(id);
   const host = hostState();
   // Host state joins the dedupe key, otherwise flipping approvals on would not
-  // reach a phone whose session list happened not to change.
-  const json = JSON.stringify([sessions.map(({ lastMessage, ...s }) => ({ ...s, last: lastMessage?.text?.slice(0, 120) })), host]);
+  // reach a phone whose session list happened not to change. The last message
+  // is keyed on its time, role and length as well as its opening: two replies
+  // that start alike would otherwise look like one and the second never sent.
+  const json = JSON.stringify([sessions.map(({ lastMessage, ...s }) => ({
+    ...s,
+    last: lastMessage && [lastMessage.ts, lastMessage.role, lastMessage.text?.length, lastMessage.text?.slice(0, 120)],
+  })), host]);
   if (!force && json === lastSnapshotJson) return;
   lastSnapshotJson = json;
   if (ws?.readyState === 1) {
@@ -2042,33 +2221,58 @@ function watchTranscript(sessionId, holder = 'legacy', now = Date.now()) {
   if (holder === 'legacy') lapsedLegacy.delete(sessionId);
   const until = now + leaseFor(holder);
   const entry = watchers.get(sessionId);
-  if (entry) {
+  // A journal that was replaced or moved leaves the old watch listening to a
+  // file nobody writes. Renewals are the moment to notice and start over.
+  if (entry && !watchStale(sessionId, entry)) {
     entry.leases.set(holder, Math.max(until, entry.leases.get(holder) || 0));
     return 'renewed';
   }
+  const leases = entry ? entry.leases : new Map();
+  if (entry) closeWatch(sessionId, entry);
+  leases.set(holder, Math.max(until, leases.get(holder) || 0));
   const file = findTranscript(sessionId);
   if (!file) return null;
-  const next = { watcher: null, debounce: null, leases: new Map([[holder, until]]) };
+  const next = { watcher: null, debounce: null, firstAt: 0, file, ino: inodeOf(file), leases };
+  const push = () => {
+    clearTimeout(next.debounce);
+    next.debounce = null;
+    next.firstAt = 0;
+    toPhone({ type: 'transcript', sessionId, messages: readMessages(sessionId) });
+  };
   try {
-    // Journals are appended to, so watching the file is enough.
+    // Journals are appended to, so watching the file is enough. Debounced so
+    // a burst of writes is one read, but never for longer than a second: a
+    // turn that keeps writing would otherwise reach the phone only once it
+    // stopped, which is the chat that looks frozen while the Mac is busy.
     next.watcher = fs.watch(file, () => {
+      const t = Date.now();
+      if (!next.firstAt) next.firstAt = t;
       clearTimeout(next.debounce);
-      next.debounce = setTimeout(() => {
-        toPhone({ type: 'transcript', sessionId, messages: readMessages(sessionId) });
-      }, 250);
+      if (t - next.firstAt >= TRANSCRIPT_MAX_WAIT_MS) return push();
+      next.debounce = setTimeout(push, 250);
     });
+    next.watcher.on?.('error', () => closeWatch(sessionId, next, { keepIntent: true }));
     watchers.set(sessionId, next);
     console.log(`[daemon] watching transcript ${sessionId.slice(0, 8)}`);
     return 'created';
   } catch { return null; }
 }
 
+const TRANSCRIPT_MAX_WAIT_MS = 1000;
+const inodeOf = (file) => { try { return fs.statSync(file).ino; } catch { return 0; } };
+function watchStale(sessionId, entry) {
+  if (!entry.watcher) return true;
+  const file = findTranscript(sessionId);
+  return !!file && (file !== entry.file || inodeOf(file) !== entry.ino);
+}
+
 /// Keep an existing lease alive without starting a watch nobody asked for,
 /// except the one an older app's open chat lost to the clock.
 function renewWatch(sessionId, holder, now = Date.now()) {
   const entry = watchers.get(sessionId);
   if (entry?.leases.has(holder)) {
-    entry.leases.set(holder, now + leaseFor(holder));
+    if (watchStale(sessionId, entry)) watchTranscript(sessionId, holder, now);
+    else entry.leases.set(holder, now + leaseFor(holder));
     return;
   }
   if (holder === 'legacy' && lapsedLegacy.has(sessionId)) watchTranscript(sessionId, 'legacy', now);
@@ -2082,10 +2286,14 @@ function unwatchTranscript(sessionId, holder = 'legacy') {
   if (!entry.leases.size) closeWatch(sessionId, entry);
 }
 
-function closeWatch(sessionId, entry) {
+/// keepIntent leaves the leases in place with no watcher behind them, so the
+/// next renewal or getTranscript starts a fresh one instead of the chat going
+/// quiet for good after one watcher error.
+function closeWatch(sessionId, entry, { keepIntent = false } = {}) {
   clearTimeout(entry.debounce);
   try { entry.watcher?.close(); } catch {}
-  watchers.delete(sessionId);
+  entry.watcher = null;
+  if (!keepIntent && watchers.get(sessionId) === entry) watchers.delete(sessionId);
 }
 
 function expireWatches(now = Date.now()) {
@@ -2137,19 +2345,40 @@ async function handleCommand(cmd) {
       error: result.ok ? '' : (result.reason || 'could not change the setting'),
       host: hostState(),
     });
-  } else if (cmd.type === 'approve' || cmd.type === 'deny') {
+  } else if (cmd.type === 'approve' || cmd.type === 'deny' || cmd.type === 'answer') {
     const ask = cmd.askId ? pendingAsks.get(cmd.askId) : null;
     if (!ask) {
       // Answered on the Mac, expired, or the session moved on while the tap
-      // was in flight. Tell the phone so the card clears instead of hanging.
-      return toPhone({
+      // was in flight. Tell the phone so the card clears instead of hanging,
+      // and send the fleet with it: the phone draws the card from the
+      // snapshot, and a deduped one would never come.
+      toPhone({
         type: 'askResolved', askId: cmd.askId || '', sessionId: cmd.sessionId || '',
         outcome: 'gone', note: 'that request is no longer waiting',
       });
+      sendSnapshot(true);
+      return;
     }
-    if (cmd.type === 'approve') {
-      settleAsk(ask, { behavior: 'allow', ...(cmd.always ? { alwaysAllow: true } : {}) },
-        'allowed', cmd.always ? 'from the phone, and always from now on' : 'from the phone');
+    if (cmd.type === 'answer') {
+      const answers = answersFor(ask, cmd.answers);
+      if (!answers) {
+        // Nothing usable picked. Leave the request held; the card stays up.
+        return toPhone({ type: 'askResolved', askId: ask.id, sessionId: ask.sessionId, outcome: 'invalid', note: 'pick an answer first' });
+      }
+      settleAsk(ask, { behavior: 'allow', updatedInput: { ...ask.input, answers } },
+        'answered', 'from the phone');
+    } else if (cmd.type === 'approve' && ask.questions) {
+      // An app too old to show the choices can only say yes, and yes with no
+      // answer is a question skipped. Hand it back so it gets a real answer.
+      settleAsk(ask, null, 'released', 'this needs a choice, update the app or pick it');
+    } else if (cmd.type === 'approve') {
+      // Claude Code reads only behavior, updatedInput and updatedPermissions.
+      // Up to 0.1.12 ALWAYS sent alwaysAllow, which it drops, so the next
+      // matching call asked again. The suggestions are the exact rules it
+      // would have saved from its own "don't ask again" option.
+      const always = cmd.always === true && ask.suggestions.length > 0;
+      settleAsk(ask, { behavior: 'allow', ...(always ? { updatedPermissions: ask.suggestions } : {}) },
+        'allowed', always ? 'from the phone, and always from now on' : 'from the phone');
     } else {
       const reason = (cmd.text || '').trim();
       settleAsk(ask, { behavior: 'deny', message: reason || 'Denied from the Ground Control app.' },
@@ -2174,7 +2403,19 @@ async function handleCommand(cmd) {
 
     // Preferred path: type into the real terminal so the desktop updates live.
     if (session.live) {
-      const method = await injectPrompt(session.tty, cmd.text);
+      const result = { landed: true };
+      const method = await injectPrompt(session.tty, cmd.text, promptWatch(session, cmd.text, result));
+      if (method && !result.landed) {
+        console.log(`[daemon] prompt typed into ${session.name} via ${method} but never submitted`);
+        toPhone({
+          type: 'promptResult', sessionId: cmd.sessionId, ok: false,
+          error: 'Typed into the terminal on your Mac, but Claude did not take it. It may be waiting in the input box there.',
+        });
+        // Pressed by hand on the Mac, it still reaches the phone.
+        watchTranscript(cmd.sessionId, 'prompt');
+        sendSnapshot(true);
+        return;
+      }
       if (method) {
         console.log(`[daemon] injected prompt into ${session.name} via ${method}`);
         toPhone({ type: 'promptResult', sessionId: cmd.sessionId, ok: true, text: '' });

package/hook.mjs

@@ -92,6 +92,9 @@ sock.on('connect', () => {
     cwd: payload.cwd || '',
     permissionMode: payload.permission_mode || '',
     permissionContext: payload.permission_context || null,
+    // The rules Claude Code would save for "don't ask again". ALWAYS on the
+    // phone hands these back; without them it has nothing to save.
+    permissionSuggestions: Array.isArray(payload.permission_suggestions) ? payload.permission_suggestions : [],
   }) + '\n');
 });
 

package/package.json

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

package/test/questions.mjs

@@ -0,0 +1,67 @@
+// Claude's question picker (AskUserQuestion) reaches the phone as questions,
+// and the phone's picks go back as the answers Claude Code reads from
+// updatedInput. Before this, the phone showed ALLOW and DENY for a question,
+// and allowing it let Claude carry on with nothing chosen.
+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('/// The phone-facing shape of a held request.');
+const end = src.indexOf('function readSessions() {');
+if (start < 0 || end < 0 || end < start) throw new Error('could not locate the question helpers in daemon.mjs');
+
+let failures = 0;
+const check = (label, cond, detail = '') => {
+  console.log(`${cond ? 'ok  ' : 'FAIL'} ${label}${detail ? `  ${detail}` : ''}`);
+  if (!cond) failures++;
+};
+
+const { askPayload, questionsOf, answersFor } = new Function(
+  `${src.slice(start, end)}\n return { askPayload, questionsOf, answersFor };`,
+)();
+
+const input = {
+  questions: [
+    { question: 'Which database?', header: 'DB', multiSelect: false,
+      options: [{ label: 'Postgres', description: 'the usual' }, { label: 'SQLite' }] },
+    { question: 'Which extras?', header: 'Extras', multiSelect: true,
+      options: [{ label: 'Auth' }, { label: 'Billing' }, { label: 'Search' }] },
+  ],
+};
+
+const qs = questionsOf('AskUserQuestion', input);
+check('a question picker becomes questions for the phone', qs?.length === 2 && qs[0].options.length === 2);
+check('options keep their descriptions', qs[0].options[0].description === 'the usual');
+check('multi select survives', qs[1].multiSelect === true);
+check('any other tool has no questions', questionsOf('Bash', { command: 'ls' }) === null);
+check('a malformed input has none either', questionsOf('AskUserQuestion', { questions: 'nope' }) === null);
+
+const ask = { id: 'a1', tool: 'AskUserQuestion', line: 'Which database?', detail: '', at: 1, input, questions: qs, suggestions: [] };
+const payload = askPayload(ask, 1);
+check('the payload carries the questions', payload.questions === qs);
+check('and no ALWAYS without a rule to save', payload.canAlways === false);
+check('a request with a suggested rule offers ALWAYS',
+  askPayload({ ...ask, questions: null, suggestions: [{ type: 'addRules' }] }, 1).canAlways === true);
+check('a plain request sends no questions key', !('questions' in askPayload({ ...ask, questions: null }, 1)));
+
+const answers = answersFor(ask, { 'Which database?': 'Postgres', 'Which extras?': ['Auth', 'Search'] });
+check('a single pick answers by question text', answers?.['Which database?'] === 'Postgres');
+check('several picks go back joined', answers?.['Which extras?'] === 'Auth, Search');
+check('a question the phone was never shown is ignored',
+  !('Other?' in (answersFor(ask, { 'Which database?': 'SQLite', 'Other?': 'x' }) || {})));
+check('nothing picked is no answer at all', answersFor(ask, { 'Which database?': '  ' }) === null);
+const long = 'Why? '.repeat(200);
+const longInput = { questions: [{ question: long, options: [{ label: 'Because' }] }] };
+const longQs = questionsOf('AskUserQuestion', longInput);
+const longAnswers = answersFor({ input: longInput, questions: longQs }, { [longQs[0].question]: 'Because' });
+check('a long question is clipped for the phone', longQs[0].question.length === 600);
+check('but answered under its full text, which is what Claude looks up', longAnswers?.[long] === 'Because');
+check('free text is taken as is', answersFor(ask, { 'Which database?': 'MySQL, honestly' })?.['Which database?'] === 'MySQL, honestly');
+
+if (failures) {
+  console.log(`\n${failures} check(s) failed`);
+  process.exit(1);
+}
+console.log('\nall checks passed');

package/test/review-fixes.mjs

@@ -57,6 +57,21 @@ const check = (label, cond, detail = '') => {
     () => { throw new Error('shell'); },
     async () => {}, async () => 'notfound', (s) => s,
   )('ttys009', '-t is not a flag here');
+  // Two prompts at once into one terminal must not interleave.
+  const order = [];
+  const serial = new Function(
+    'terminalApps', 'execFileSync', 'execSync', 'sleep', 'osascript', 'escapeAS',
+    `${slice('// Returns the method used, or null if no terminal path was found.', 'const headlessActive = new Set();')}
+     return injectPrompt;`,
+  )(
+    () => ({ tmuxPanes: new Map([['/dev/ttys009', '%3']]), terminal: false, iterm: false }),
+    (file, args) => { order.push(args.includes('-l') ? args.at(-1) : 'Enter'); return Buffer.from(''); },
+    () => { throw new Error('shell'); },
+    () => new Promise((r) => setTimeout(r, 20)), async () => 'notfound', (s) => s,
+  );
+  await Promise.all([serial('ttys009', 'FIRST'), serial('ttys009', 'SECOND')]);
+  check('two prompts into one terminal go in one after the other',
+    order.join(',') === 'FIRST,Enter,SECOND,Enter', order.join(','));
   check('a prompt starting with a dash is not read as a tmux option',
     dashed[0]?.indexOf('--') === dashed[0]?.length - 2, JSON.stringify(dashed[0]));
 }
@@ -234,6 +249,36 @@ const check = (label, cond, detail = '') => {
   unwatchTranscript('s6', 'legacy');
   renewWatch('s6', 'legacy', now + 1000);
   check('a chat that was closed is not reopened by a later fetch', !watchers.has('s6'));
+
+  // A watcher that errors (journal replaced, volume hiccup) must not leave
+  // the chat silent for good: the next renewal starts a fresh one.
+  watchTranscript('s7', a, now);
+  const first = opened[opened.length - 1];
+  watchers.get('s7').watcher = null;          // what an 'error' leaves behind
+  check('a renewal after a watcher error watches again', watchTranscript('s7', a, now) === 'created'
+    && opened[opened.length - 1] !== first && watchers.has('s7'));
+  watchers.get('s7').watcher = null;
+  renewWatch('s7', a, now);
+  check('so does asking for the log', !!watchers.get('s7').watcher);
+}
+
+// ---------- a turn that never stops writing still streams ----------
+{
+  const opened = [];
+  const fakeFs = { watch(file, cb) { const w = { cb, close() {} }; opened.push(w); return w; } };
+  const sent = [];
+  const api = new Function('fs', 'findTranscript', 'readMessages', 'toPhone',
+    `${slice('const WATCH_LEASE_MS', 'async function handleCommand(cmd) {')}
+     return { watchTranscript };`,
+  )(fakeFs, (id) => `/tmp/${id}.jsonl`, () => [], (m) => sent.push(m));
+  api.watchTranscript('busy', 'phone:x');
+  const realNow = Date.now;
+  let t = realNow();
+  Date.now = () => t;
+  try {
+    for (let i = 0; i < 30; i++) { t += 100; opened[0].cb(); }   // a write every 100 ms for 3 s
+  } finally { Date.now = realNow; }
+  check('continuous writes reach the phone while they last, not only after', sent.length >= 2, `${sent.length} push(es) in 3 s`);
 }
 
 // ---------- the approvals socket comes back after a local takeover ----------

package/test/terminal-submit.mjs

@@ -0,0 +1,138 @@
+// A prompt typed into Terminal.app has to be submitted, not left in the input
+// box. On 2026-10-11 a 72 character prompt from the phone sat there unsent:
+// do script sends the text with its own newline, Claude Code takes that as a
+// paste, and the paste swallows the one Return that followed. Lift the real
+// injection code out of daemon.mjs and run it against a fake Terminal.
+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 from = '// Returns the method used, or null if no terminal path was found.';
+const start = src.indexOf(from);
+const end = src.indexOf('const headlessActive = new Set();', start);
+if (start < 0 || end < 0) throw new Error('could not locate the injection code in daemon.mjs');
+
+let failures = 0;
+const check = (label, cond, detail = '') => {
+  console.log(`${cond ? 'ok  ' : 'FAIL'} ${label}${detail ? `  ${detail}` : ''}`);
+  if (!cond) failures++;
+};
+
+const load = (scripts) => new Function(
+  'terminalApps', 'execFileSync', 'execSync', 'sleep', 'osascript', 'escapeAS', 'findTabScript',
+  `${src.slice(start, end)}
+   return { injectPrompt, pressEnter };`,
+)(
+  () => ({ tmuxPanes: new Map(), terminal: true, iterm: false }),
+  () => { throw new Error('no tmux here'); },
+  () => { throw new Error('no shell'); },
+  async () => {},
+  async (script) => { scripts.push(script.match(/do script "(.*)" in tb/)?.[1] ?? script); return 'ok'; },
+  (s) => s,
+  (app, dev, action) => action,
+);
+
+{
+  const scripts = [];
+  const { injectPrompt } = load(scripts);
+  const method = await injectPrompt('ttys005', 'Do we have pstack installed? Do you need it or do you have enough tools?');
+  check('a Terminal.app session is typed into through Terminal', method === 'terminal', `got ${method}`);
+  check('the text is followed by two bare Returns, enough to get past the paste',
+    scripts.length === 3 && scripts[1] === '' && scripts[2] === '', JSON.stringify(scripts));
+}
+
+{
+  // The session is read as this prompt's slot opens, after the prompt ahead
+  // of it went in, and the follow up check runs inside the slot: its extra
+  // Return must land before the next prompt is typed, not on top of it.
+  const scripts = [];
+  const { injectPrompt, pressEnter } = load(scripts);
+  const watch = (label) => () => { scripts.push(`WATCH ${label}`); return { check: async (how) => { scripts.push('CHECK'); await pressEnter('ttys005', how); } }; };
+  await Promise.all([injectPrompt('ttys005', 'FIRST', watch('1')), injectPrompt('ttys005', 'SECOND', watch('2'))]);
+  check('each prompt is watched from its own slot, with the extra Return before the next prompt',
+    scripts.join(',') === 'WATCH 1,FIRST,,,CHECK,,WATCH 2,SECOND,,,CHECK,', scripts.join(','));
+  let survived = true;
+  try {
+    await injectPrompt('ttys005', 'THIRD', () => ({ check: async () => { throw new Error('boom'); } }));
+    await injectPrompt('ttys005', 'FOURTH', () => { throw new Error('boom'); });
+  } catch { survived = false; }
+  check('a failing check does not turn a typed prompt into an error', survived);
+}
+
+{
+  // Fewer Returns where a Return is a choice: Claude's own dialog, a picker.
+  const scripts = [];
+  const { injectPrompt } = load(scripts);
+  await injectPrompt('ttys005', '/model', () => ({ returns: 1 }));
+  check('a slash command or an open dialog gets the one Return it always got',
+    scripts.length === 2 && scripts[1] === '', JSON.stringify(scripts));
+}
+
+// ---------- the handler's watch: is the prompt really in? ----------
+{
+  const wStart = src.indexOf('// The terminal taking the keys is not Claude taking the prompt');
+  const wEnd = src.indexOf('function readClaudeSessions()', wStart);
+  if (wStart < 0 || wEnd < 0) throw new Error('could not locate the prompt watch in daemon.mjs');
+  // A fake Claude: its status and journal change on cue as Returns are pressed.
+  const rig = ({ status = 'idle', onEnter = () => {} } = {}) => {
+    const st = { status, ids: ['u1'], enters: 0 };
+    const api = new Function(
+      'readClaudeSessions', 'readMessages', 'sleep', 'pressEnter', 'console',
+      `${src.slice(wStart, wEnd)}
+       return { promptWatch };`,
+    )(
+      () => [{ id: 's1', rawStatus: st.status }],
+      () => st.ids.map((id) => ({ role: 'user', id })),
+      async () => {},
+      async () => { st.enters++; onEnter(st); return true; },
+      { log() {} },
+    );
+    return { st, watch: (text = 'Do we have pstack installed? Do you need it or do you have enough tools?') => {
+      const result = { landed: true };
+      return { result, plan: api.promptWatch({ id: 's1', name: 'test', tty: 'ttys005' }, text, result)() };
+    } };
+  };
+
+  {
+    const { st, watch } = rig();
+    const { result, plan } = watch();
+    await plan.check('terminal');
+    check('a prompt stuck in the box gets one more Return, then is reported as not taken',
+      st.enters === 1 && result.landed === false, `enters ${st.enters}, landed ${result.landed}`);
+  }
+  {
+    const { st, watch } = rig({ onEnter: (x) => x.ids.push('u2') });
+    const { result, plan } = watch();
+    await plan.check('terminal');
+    check('one that the extra Return submits counts as landed', st.enters === 1 && result.landed === true);
+  }
+  {
+    const { st, watch } = rig();
+    const { result, plan } = watch();
+    st.ids.push('u2');
+    await plan.check('terminal');
+    check('one that went straight in gets no extra Return', st.enters === 0 && result.landed === true);
+  }
+  {
+    // The status file lags the prompt ahead by about a tenth of a second,
+    // so this one was read as idle and then got queued: nothing journaled.
+    const { st, watch } = rig();
+    const { result, plan } = watch();
+    st.status = 'busy';
+    await plan.check('terminal');
+    check('one queued behind a turn that just started is not called lost', st.enters === 0 && result.landed === true);
+  }
+  const plans = {
+    busy: rig({ status: 'busy' }).watch().plan,
+    waiting: rig({ status: 'waiting' }).watch().plan,
+    slash: rig().watch('/model').plan,
+  };
+  check('a busy session is typed into as usual with nothing to check', !plans.busy.check && plans.busy.returns === undefined);
+  check('Claude\'s own dialog gets one Return and no check', plans.waiting.returns === 1 && !plans.waiting.check);
+  check('a slash command gets one Return and no check', plans.slash.returns === 1 && !plans.slash.check);
+}
+
+console.log(failures ? `\n${failures} check(s) failed` : '\nall checks passed');
+process.exit(failures ? 1 : 0);