relay-companion 0.1.94 → 0.1.95

package/overlay/inbox.html

@@ -3597,6 +3597,7 @@
   //               instruction is IN the chat. Green check, then fade.
   // A Codex bridge/automation hand-off keeps the classic brief confirmation.
   const injectedNoteTimers = new Map();
+  const deliveredChatNames = new Map(); // packetId -> chat the injection was staged for
   function fadeRowNoteLater(id, ms) {
     if (injectedNoteTimers.has(id)) clearTimeout(injectedNoteTimers.get(id));
     injectedNoteTimers.set(id, setTimeout(() => {
@@ -3614,7 +3615,12 @@
     if (info.awaitingTurn) {
       // Persistent until delivery / the auto-fresh hop — never a silent limbo.
       if (injectedNoteTimers.has(id)) { clearTimeout(injectedNoteTimers.get(id)); injectedNoteTimers.delete(id); }
-      setRowNote(id, "Handed to your current Claude chat — lands when it next takes a turn. If it\u2019s idle: type anything there, or use Open in New Chat for instant.", "ok");
+      // Name the destination chat when we know it: "your \u201cgranular-relay\u201d chat"
+      // tells the user WHERE to look; "your current chat" leaves them hunting
+      // (field report: the injection landed in a chat they never found).
+      if (info.chat) deliveredChatNames.set(id, info.chat);
+      const where = info.chat ? `your \u201c${info.chat}\u201d chat` : "your current Claude chat";
+      setRowNote(id, `Handed to ${where} — lands when it next takes a turn. If it\u2019s idle: type anything there, or use Open in New Chat for instant.`, "ok");
       return;
     }
     const hostName = info.host === "codex" ? "Codex" : "Claude";
@@ -3622,7 +3628,8 @@
     fadeRowNoteLater(id, 12000);
   });
   if (window.relay.onInjectionDelivered) window.relay.onInjectionDelivered((id) => {
-    setRowNote(id, "✓ Delivered — your current Claude chat is acting on it now.", "ok");
+    const chat = deliveredChatNames.get(id);
+    setRowNote(id, `✓ Delivered — ${chat ? `your \u201c${chat}\u201d chat` : "your current Claude chat"} is acting on it now.`, "ok");
     fadeRowNoteLater(id, 8000);
   });
   if (window.relay.onInjectionAutoFresh) window.relay.onInjectionAutoFresh((id) => {

package/overlay/main.cjs

@@ -2166,7 +2166,8 @@ async function openPacketInCurrent(packetId, { sent = false } = {}) {
     if (!target) return fallbackFresh("No live Claude chat found");
     console.error(
       `[overlay] openInCurrent ${packetId}: staging for claude session ${String(target.sessionId).slice(0, 8)}… ` +
-        `(${target.source}, active ${Math.round((Date.now() - target.lastActiveAt) / 1000)}s ago)`,
+        `(${target.source}${target.label ? `, "${target.label}"` : ""}, active ${Math.round((Date.now() - target.lastActiveAt) / 1000)}s ago` +
+        `${target.skippedStubs ? `, skipped ${target.skippedStubs} never-used chat(s)` : ""})`,
     );
     const stageNow = () => {
       let staged = null;
@@ -2188,7 +2189,10 @@ async function openPacketInCurrent(packetId, { sent = false } = {}) {
       // renderer must show an honest "waiting for that chat's turn" state, not a
       // success toast. The watcher below flips it to Delivered in realtime — or,
       // past the grace window, hops to a fresh chat so the click is never slow.
-      confirmInjected("claude", { awaitingTurn: true });
+      // Name the chat the relay actually went to: "your granular-relay chat"
+      // beats "your current chat" when several are open (field report — the
+      // injection landed somewhere invisible and nothing said where).
+      confirmInjected("claude", { awaitingTurn: true, chat: target.label || "" });
       finish();
       watchInjectionDelivery(packetId, staged.path, {
         onAutoFresh: () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relay-companion",
-  "version": "0.1.94",
+  "version": "0.1.95",
   "description": "Relay companion for ordinary messages, with dormant coordination features available only by explicit opt-in.",
   "type": "module",
   "bin": {

package/src/auto-update.js

@@ -560,6 +560,14 @@ export function spawnDetachedUpdate({
     `start_job "$DAEMON_PLIST" ${DAEMON_LABEL} || true`,
     `ensure_job "$PILL_PLIST" ${PILL_LABEL} || { log_line "pill restart verification FAILED"; RESTART_FAILED=1; }`,
     `ensure_job "$DAEMON_PLIST" ${DAEMON_LABEL} || { log_line "daemon restart verification FAILED"; RESTART_FAILED=1; }`,
+    // A "Boot-out failed: 3: No such process" means launchd had already lost the
+    // job while its PROCESS kept running — bootstrap then registers the job
+    // without replacing that stale pill, which keeps drawing with the old tree's
+    // window state (field report: wedged Space attachment after the 01:58
+    // restart, cured by hand with exactly this kickstart). Forcing the pill once
+    // more guarantees the process on screen came from the new tree. Pill only:
+    // kickstarting the daemon here would kill the job that owns this script.
+    `if [ "$RESTART_FAILED" != 1 ]; then "$LAUNCHCTL" kickstart -k "gui/${uid}/${PILL_LABEL}" >> ${LOG} 2>&1 || log_line "pill kickstart after bootstrap failed (continuing)"; fi`,
     `if [ "$RESTART_FAILED" = 1 ]; then`,
     `  log_line "restart verification FAILED; restoring previous tree"`,
     `  restore_tree`,

package/src/claude-inject.cjs

@@ -255,6 +255,53 @@ function hookResponseFor(eventName, instruction) {
 
 // ---- current-session resolution (pill side) --------------------------------
 
+// A short, human-recognizable name for a chat with no title: its working
+// directory's last segment ("granular-relay"), which is how people refer to
+// their chats anyway.
+function cwdLabel(cwd) {
+  const clean = String(cwd || "").replace(/[/\\]+$/, "");
+  if (!clean) return "";
+  const seg = clean.split(/[/\\]/).filter(Boolean).pop() || "";
+  return seg === "." || seg === ".." ? "" : seg;
+}
+
+// Did a HUMAN ever speak in this session? Reads only the head of the transcript
+// (the first real user message is always near the top), so this stays cheap on
+// multi-megabyte logs. A user line that carries toolUseResult is a tool result
+// being fed back, and isMeta lines are system-injected — neither is a person
+// typing. Returns null when the transcript can't be read: unknown must never
+// masquerade as "nobody spoke here" and disqualify a real chat.
+const TRANSCRIPT_HEAD_BYTES = 512 * 1024;
+function transcriptHasHumanTurn(transcriptPath) {
+  const file = String(transcriptPath || "").trim();
+  if (!file) return null;
+  let fd = null;
+  try {
+    fd = fs.openSync(file, "r");
+    const size = fs.fstatSync(fd).size;
+    const length = Math.min(size, TRANSCRIPT_HEAD_BYTES);
+    const buf = Buffer.alloc(length);
+    fs.readSync(fd, buf, 0, length, 0);
+    const text = buf.toString("utf8");
+    for (const line of text.split("\n")) {
+      if (!line.includes('"type":"user"') && !line.includes('"type": "user"')) continue;
+      if (line.includes('"toolUseResult"') || line.includes('"isMeta":true') || line.includes('"isMeta": true')) continue;
+      return true;
+    }
+    // Only trust a "no" when the whole file was inspected; a longer transcript
+    // whose head is all tool traffic stays unknown.
+    return size <= TRANSCRIPT_HEAD_BYTES ? false : null;
+  } catch {
+    return null;
+  } finally {
+    if (fd !== null) {
+      try {
+        fs.closeSync(fd);
+      } catch {}
+    }
+  }
+}
+
 function listDesktopSessionCandidates(desktopSessionsDir, { nowMs, maxAgeMs }) {
   const candidates = [];
   let orgs = [];
@@ -292,7 +339,21 @@ function listDesktopSessionCandidates(desktopSessionsDir, { nowMs, maxAgeMs }) {
         if (!(lastActiveAt > 0) || nowMs - lastActiveAt > maxAgeMs) continue;
         const sessionId = String(meta.cliSessionId || name.replace(/^local_/, "").replace(/\.json$/, "")).trim();
         if (!sessionId) continue;
-        candidates.push({ sessionId, lastActiveAt, source: "desktop" });
+        // completedTurns is Claude Desktop's own count of finished turns: 0 means
+        // nobody has ever spoken in this chat. Field report (Sven, 2026-08-06): a
+        // never-used stub chat won targeting purely on file/hook activity and the
+        // injection sat there forever. `undefined` (older Desktop builds) stays
+        // unknown rather than false — never exclude on missing data.
+        const turns = Number(meta.completedTurns);
+        candidates.push({
+          sessionId,
+          lastActiveAt,
+          source: "desktop",
+          hasHumanTurn: Number.isFinite(turns) ? turns > 0 : null,
+          // What to call this chat when telling the user where the relay went.
+          label: String(meta.title || "").trim() || cwdLabel(meta.cwd || meta.originCwd),
+          cwd: String(meta.cwd || meta.originCwd || ""),
+        });
       }
     }
   }
@@ -319,7 +380,16 @@ function listRendezvousCandidates(homeDir, { nowMs, maxAgeMs }) {
     if (!(lastActiveAt > 0) || nowMs - lastActiveAt > maxAgeMs) continue;
     const sessionId = String((row && row.sessionId) || name.replace(/\.json$/, "")).trim();
     if (!sessionId) continue;
-    candidates.push({ sessionId, lastActiveAt, source: "terminal" });
+    candidates.push({
+      sessionId,
+      lastActiveAt,
+      source: "terminal",
+      // A terminal session has no turn counter, so ask its transcript whether a
+      // human ever spoke there (null when we cannot tell).
+      hasHumanTurn: transcriptHasHumanTurn(row && row.transcriptPath),
+      label: cwdLabel(row && row.cwd),
+      cwd: String((row && row.cwd) || ""),
+    });
   }
   return candidates;
 }
@@ -341,7 +411,7 @@ function findCurrentClaudeSession({
   maxAgeMs = SESSION_MAX_AGE_MS,
   focusPriorityMs = DESKTOP_FOCUS_PRIORITY_MS,
 } = {}) {
-  const merged = new Map(); // sessionId -> { sessionId, lastActiveAt, desktop, focusedAt }
+  const merged = new Map(); // sessionId -> { sessionId, lastActiveAt, desktop, focusedAt, ... }
   const fold = (candidate) => {
     const existing = merged.get(candidate.sessionId);
     if (!existing) {
@@ -353,20 +423,37 @@ function findCurrentClaudeSession({
         // activity. Track focus separately so priority never leaks to busy
         // background sessions.
         focusedAt: candidate.source === "desktop" ? candidate.lastActiveAt : 0,
+        hasHumanTurn: candidate.hasHumanTurn ?? null,
+        label: candidate.label || "",
+        cwd: candidate.cwd || "",
       });
       return;
     }
     existing.lastActiveAt = Math.max(existing.lastActiveAt, candidate.lastActiveAt);
     existing.desktop = existing.desktop || candidate.source === "desktop";
     if (candidate.source === "desktop") existing.focusedAt = Math.max(existing.focusedAt, candidate.lastActiveAt);
+    // Any surface that can prove a human spoke here settles it; otherwise a
+    // known false only survives while nothing else has evidence.
+    if (candidate.hasHumanTurn === true) existing.hasHumanTurn = true;
+    else if (candidate.hasHumanTurn === false && existing.hasHumanTurn === null) existing.hasHumanTurn = false;
+    // Desktop metadata carries the real chat title; prefer it over a cwd label.
+    if (candidate.label && (!existing.label || candidate.source === "desktop")) existing.label = candidate.label;
+    if (candidate.cwd && !existing.cwd) existing.cwd = candidate.cwd;
   };
   if (desktopSessionsDir) {
     for (const candidate of listDesktopSessionCandidates(desktopSessionsDir, { nowMs, maxAgeMs })) fold(candidate);
   }
   for (const candidate of listRendezvousCandidates(homeDir, { nowMs, maxAgeMs })) fold(candidate);
+  // Chats nobody has ever spoken in are a LAST resort, not a rival: they win on
+  // raw activity (a stub can log file/hook events forever) while being exactly
+  // the place a relay must not be delivered. A never-used chat is still allowed
+  // when it is all that exists — the user may have just opened a fresh one.
+  const all = [...merged.values()];
+  const spoken = all.filter((e) => e.hasHumanTurn !== false);
+  const pool = spoken.length ? spoken : all;
   let bestFocused = null;
   let best = null;
-  for (const entry of merged.values()) {
+  for (const entry of pool) {
     if (entry.focusedAt > 0 && nowMs - entry.focusedAt <= focusPriorityMs) {
       if (!bestFocused || entry.focusedAt > bestFocused.focusedAt) bestFocused = entry;
     }
@@ -376,7 +463,15 @@ function findCurrentClaudeSession({
   }
   const chosen = bestFocused || best;
   return chosen
-    ? { sessionId: chosen.sessionId, lastActiveAt: chosen.lastActiveAt, source: chosen.desktop ? "desktop" : "terminal" }
+    ? {
+        sessionId: chosen.sessionId,
+        lastActiveAt: chosen.lastActiveAt,
+        source: chosen.desktop ? "desktop" : "terminal",
+        // What to call this chat when confirming where the relay went.
+        label: chosen.label || "",
+        cwd: chosen.cwd || "",
+        skippedStubs: all.length - pool.length,
+      }
     : null;
 }