relay-companion 0.1.98 → 0.1.99

package/overlay/main.cjs

@@ -2180,10 +2180,14 @@ async function openPacketInCurrent(packetId, { sent = false } = {}) {
         console.error("[overlay] claude session resolution failed:", error && error.message);
       }
     }
-    if (!target) return fallbackFresh("No live Claude chat found");
+    // Tier 0 (focus log) returns null when Claude Desktop reports NO chat on
+    // screen — the Home screen. That is a real answer, not a failure: there is
+    // no "current chat" to hand this to, so say so instead of guessing at the
+    // last chat the user happened to visit.
+    if (!target) return fallbackFresh("No chat is open in Claude");
     console.error(
       `[overlay] openInCurrent ${packetId}: staging for claude session ${String(target.sessionId).slice(0, 8)}… ` +
-        `(${target.source}${target.label ? `, "${target.label}"` : ""}, active ${Math.round((Date.now() - target.lastActiveAt) / 1000)}s ago` +
+        `(${target.source} via ${target.via || "ranking"}${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 = () => {

package/package.json

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

package/src/claude-inject.cjs

@@ -37,6 +37,21 @@ const SESSION_MAX_AGE_MS = 6 * 60 * 60 * 1000; // a "current" session was active
 // user is actually looking at (field-observed: an Open-in-current-chat landed
 // inside another session's workflow subagent, invisibly).
 const DESKTOP_FOCUS_PRIORITY_MS = 15 * 60 * 1000;
+// Claude Desktop's main process logs every focus change as
+//   ... [CCD] LocalSessions.setFocusedSession: sessionId=local_<uuid>|null
+// That line is the ONLY signal that states what is on screen NOW rather than
+// when something was last touched, and it is a plain file in the user's own
+// Logs directory (no permission of any kind). Two measured failures it fixes,
+// both field-reported as relays landing in the wrong chat:
+//   1. lastFocusedAt is written to disk 2-4s AFTER a switch, so clicking right
+//      after switching chats targeted the chat the user had just left.
+//   2. sessionId=null means "no chat is open" (the Home screen) — a state the
+//      timestamp ranking cannot represent at all, so it always named some chat.
+// Treated as a strong hint, never a contract: it is an internal log, so a
+// missing/stale/renamed format falls back to the timestamp ranking below.
+const FOCUS_LOG_MAX_AGE_MS = 12 * 60 * 60 * 1000;
+const FOCUS_LOG_TAIL_BYTES = 256 * 1024;
+const FOCUS_LINE_RE = /^(\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2})[^\n]*setFocusedSession:\s*sessionId=(null|local_[0-9A-Za-z._-]+)/;
 const RENDEZVOUS_PRUNE_AGE_MS = 7 * 24 * 60 * 60 * 1000;
 const INJECT_DIR = "claude-inject";
 const RENDEZVOUS_DIR = "claude-sessions";
@@ -255,6 +270,107 @@ function hookResponseFor(eventName, instruction) {
 
 // ---- current-session resolution (pill side) --------------------------------
 
+// Default location of Claude Desktop's main-process logs (override for tests).
+function defaultClaudeLogDir() {
+  return process.env.CLAUDE_LOG_DIR || path.join(os.homedir(), "Library", "Logs", "Claude");
+}
+
+// The rotated main logs, freshest first (main.log, main1.log, ... main4.log).
+function claudeLogFiles(logDir) {
+  let names = [];
+  try {
+    names = fs.readdirSync(logDir).filter((n) => /^main\d*\.log$/.test(n));
+  } catch {
+    return [];
+  }
+  return names
+    .map((n) => {
+      const file = path.join(logDir, n);
+      let mtimeMs = 0;
+      try {
+        mtimeMs = fs.statSync(file).mtimeMs;
+      } catch {}
+      return { file, mtimeMs };
+    })
+    .sort((a, b) => b.mtimeMs - a.mtimeMs)
+    .map((x) => x.file);
+}
+
+// The LAST focus transition Claude Desktop recorded. Reads only the tail of each
+// log (these grow to megabytes; the newest line is what matters). Returns:
+//   { localId: "local_…", at }  a chat is on screen
+//   { localId: null, at }       no chat is open (Home screen)
+//   null                        no usable signal — caller must fall back
+function readFocusedSessionFromLog({ logDir = defaultClaudeLogDir(), nowMs = Date.now(), maxAgeMs = FOCUS_LOG_MAX_AGE_MS } = {}) {
+  for (const file of claudeLogFiles(logDir)) {
+    let text = "";
+    try {
+      const fd = fs.openSync(file, "r");
+      try {
+        const size = fs.fstatSync(fd).size;
+        const length = Math.min(size, FOCUS_LOG_TAIL_BYTES);
+        const buf = Buffer.alloc(length);
+        fs.readSync(fd, buf, 0, length, size - length);
+        text = buf.toString("utf8");
+      } finally {
+        fs.closeSync(fd);
+      }
+    } catch {
+      continue;
+    }
+    const lines = text.split("\n");
+    for (let i = lines.length - 1; i >= 0; i -= 1) {
+      const m = FOCUS_LINE_RE.exec(lines[i]);
+      if (!m) continue;
+      const at = Date.parse(m[1].replace(" ", "T"));
+      if (!Number.isFinite(at)) continue;
+      // A log left behind by a long-dead Claude says nothing about now.
+      if (nowMs - at > maxAgeMs) return null;
+      return { localId: m[2] === "null" ? null : m[2], at };
+    }
+  }
+  return null;
+}
+
+// Resolve Claude Desktop's local_<uuid> to the CLI session id the hook runtime
+// uses (plus the chat's title for the confirmation).
+function desktopSessionByLocalId(desktopSessionsDir, localId) {
+  if (!desktopSessionsDir || !localId) return null;
+  const wanted = `${localId}.json`;
+  const stack = [desktopSessionsDir];
+  while (stack.length) {
+    const dir = stack.pop();
+    let entries = [];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(full);
+        continue;
+      }
+      if (entry.name !== wanted) continue;
+      try {
+        const meta = JSON.parse(fs.readFileSync(full, "utf8"));
+        const sessionId = String(meta.cliSessionId || "").trim();
+        if (!sessionId) return null;
+        return {
+          sessionId,
+          label: String(meta.title || "").trim() || cwdLabel(meta.cwd || meta.originCwd),
+          cwd: String(meta.cwd || meta.originCwd || ""),
+          archived: meta.isArchived === true,
+        };
+      } catch {
+        return null;
+      }
+    }
+  }
+  return null;
+}
+
 // 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.
@@ -410,7 +526,37 @@ function findCurrentClaudeSession({
   nowMs = Date.now(),
   maxAgeMs = SESSION_MAX_AGE_MS,
   focusPriorityMs = DESKTOP_FOCUS_PRIORITY_MS,
+  logDir = defaultClaudeLogDir(),
+  useFocusLog = true,
 } = {}) {
+  // TIER 0 — what is on screen RIGHT NOW, straight from Claude Desktop.
+  // Everything below this point reasons about timestamps of past events, which
+  // is why it used to answer with the chat the user had just left (the write of
+  // lastFocusedAt trails a switch by 2-4s) and could never say "no chat open".
+  if (useFocusLog) {
+    const focused = readFocusedSessionFromLog({ logDir, nowMs });
+    if (focused && focused.localId === null) {
+      // The user is on the Home screen: there IS no current chat. Refusing here
+      // is the honest answer — the caller opens a new chat and says why.
+      return null;
+    }
+    if (focused && focused.localId) {
+      const resolved = desktopSessionByLocalId(desktopSessionsDir, focused.localId);
+      if (resolved && !resolved.archived) {
+        return {
+          sessionId: resolved.sessionId,
+          lastActiveAt: focused.at,
+          source: "desktop",
+          label: resolved.label,
+          cwd: resolved.cwd,
+          skippedStubs: 0,
+          via: "focus-log",
+        };
+      }
+    }
+    // No usable line, an unknown local id, or an unreadable session file: fall
+    // through to the ranking rather than failing the click.
+  }
   const merged = new Map(); // sessionId -> { sessionId, lastActiveAt, desktop, focusedAt, ... }
   const fold = (candidate) => {
     const existing = merged.get(candidate.sessionId);
@@ -471,12 +617,16 @@ function findCurrentClaudeSession({
         label: chosen.label || "",
         cwd: chosen.cwd || "",
         skippedStubs: all.length - pool.length,
+        via: "ranking",
       }
     : null;
 }
 
 module.exports = {
   SESSION_MAX_AGE_MS,
+  FOCUS_LOG_MAX_AGE_MS,
+  readFocusedSessionFromLog,
+  desktopSessionByLocalId,
   DESKTOP_FOCUS_PRIORITY_MS,
   BROADCAST_KEY,
   buildInjectionInstruction,