agent-companion 0.1.5 → 0.1.7

package/README.md

@@ -22,19 +22,6 @@ npm i -g agent-companion
 agent-companion
 ```
 
-## Options
-Use your hosted relay:
-
-```bash
-agent-companion --relay https://agent-companion-relay.onrender.com
-```
-
-Run with a local relay for development:
-
-```bash
-agent-companion --with-local-relay
-```
-
 ## Pairing flow
 1. Run `agent-companion` on your computer
 2. Copy the pairing code shown in the terminal

package/bridge/defaultState.mjs

@@ -6,6 +6,7 @@ const SESSION_STATES = new Set(["RUNNING", "WAITING_INPUT", "COMPLETED", "FAILED
 const EVENT_CATEGORIES = new Set(["INFO", "ACTION", "INPUT", "ERROR"]);
 const TURN_ROLES = new Set(["USER", "ASSISTANT"]);
 const TURN_KINDS = new Set(["MESSAGE", "FINAL_OUTPUT", "APPROVAL_ACTION"]);
+const SEEDED_SAMPLE_SESSION_IDS = new Set(["s_codex_live_01", "s_claude_live_01", "s_codex_live_02"]);
 
 function safeNumber(value, fallback = 0) {
   const parsed = Number(value);
@@ -290,93 +291,6 @@ function buildDefaultThreads(sessions) {
 }
 
 export function buildDefaultState() {
-  const now = Date.now();
-
-  const sessions = [
-    createSession(
-      "s_codex_live_01",
-      "CODEX",
-      "Refactor notification pipeline",
-      "agent-control-plane",
-      "feature/queue-replay",
-      "RUNNING",
-      16_000,
-      64,
-      {
-        promptTokens: 27120,
-        completionTokens: 18340,
-        totalTokens: 45460,
-        costUsd: 0.62
-      }
-    ),
-    createSession(
-      "s_claude_live_01",
-      "CLAUDE",
-      "Fix websocket reconnect",
-      "agent-bridge",
-      "bugfix/retry-loop",
-      "WAITING_INPUT",
-      75_000,
-      79,
-      {
-        promptTokens: 18110,
-        completionTokens: 11040,
-        totalTokens: 29150,
-        costUsd: 0.43
-      }
-    ),
-    createSession(
-      "s_codex_live_02",
-      "CODEX",
-      "Token analytics API",
-      "agent-api",
-      "feat/token-metrics",
-      "COMPLETED",
-      4_300_000,
-      100,
-      {
-        promptTokens: 32002,
-        completionTokens: 22994,
-        totalTokens: 54996,
-        costUsd: 0.78
-      }
-    )
-  ];
-
-  const pendingInputs = [
-    sanitizePendingInput({
-      id: "p_live_01",
-      sessionId: "s_claude_live_01",
-      prompt: "Can I cap backoff at 45s and ship this patch?",
-      requestedAt: now - 75_000,
-      priority: "HIGH"
-    })
-  ].filter(Boolean);
-
-  const events = [
-    sanitizeEvent({
-      id: "e_live_101",
-      sessionId: "s_codex_live_01",
-      summary: "Running integration tests on queue replay logic.",
-      timestamp: now - 16_000,
-      category: "INFO"
-    }),
-    sanitizeEvent({
-      id: "e_live_201",
-      sessionId: "s_claude_live_01",
-      summary: "Input requested: confirm retry cap before patch.",
-      timestamp: now - 75_000,
-      category: "INPUT"
-    }),
-    sanitizeEvent({
-      id: "e_live_301",
-      sessionId: "s_codex_live_02",
-      summary: "Session completed: endpoint + tests merged.",
-      timestamp: now - 4_300_000,
-      category: "ACTION"
-    })
-  ].filter(Boolean);
-
   const settings = {
     criticalRealtime: true,
     digest: true,
@@ -387,26 +301,13 @@ export function buildDefaultState() {
     workspaceRoot: resolveDefaultWorkspaceRoot()
   };
 
-  const sessionThreads = buildDefaultThreads(sessions);
-  const chatTurns = [
-    sanitizeChatTurn({
-      id: "turn_live_01",
-      sessionId: "s_claude_live_01",
-      role: "ASSISTANT",
-      kind: "FINAL_OUTPUT",
-      text: "Can I cap backoff at 45s and ship this patch?",
-      createdAt: now - 75_000,
-      source: "LEGACY"
-    })
-  ].filter(Boolean);
-
   return {
     source: "bridge",
-    sessions,
-    sessionThreads,
-    chatTurns,
-    pendingInputs,
-    events,
+    sessions: [],
+    sessionThreads: [],
+    chatTurns: [],
+    pendingInputs: [],
+    events: [],
     pendingHandledAt: {},
     settings
   };
@@ -438,23 +339,24 @@ export function sanitizeState(raw) {
     Array.isArray(candidate.sessions) ? candidate.sessions : fallback.sessions
   )
     .map((session) => sanitizeSession(session))
-    .filter(Boolean);
+    .filter((session) => Boolean(session && !SEEDED_SAMPLE_SESSION_IDS.has(session.id)));
 
   const pendingInputs = (
     Array.isArray(candidate.pendingInputs) ? candidate.pendingInputs : fallback.pendingInputs
   )
     .map((item) => sanitizePendingInput(item))
-    .filter(Boolean);
+    .filter((item) => Boolean(item && !SEEDED_SAMPLE_SESSION_IDS.has(item.sessionId)));
 
   const events = (Array.isArray(candidate.events) ? candidate.events : fallback.events)
     .map((event) => sanitizeEvent(event))
-    .filter(Boolean);
+    .filter((event) => Boolean(event && !SEEDED_SAMPLE_SESSION_IDS.has(event.sessionId)));
 
   const sessionThreadMap = new Map();
   const rawThreads = Array.isArray(candidate.sessionThreads) ? candidate.sessionThreads : [];
   for (const item of rawThreads) {
     const sanitized = sanitizeSessionThread(item);
     if (!sanitized) continue;
+    if (SEEDED_SAMPLE_SESSION_IDS.has(sanitized.id)) continue;
     sessionThreadMap.set(sanitized.id, sanitized);
   }
 
@@ -481,7 +383,7 @@ export function sanitizeState(raw) {
 
   const chatTurns = (Array.isArray(candidate.chatTurns) ? candidate.chatTurns : fallback.chatTurns)
     .map((turn) => sanitizeChatTurn(turn))
-    .filter((turn) => Boolean(turn && knownSessionIds.has(turn.sessionId)))
+    .filter((turn) => Boolean(turn && knownSessionIds.has(turn.sessionId) && !SEEDED_SAMPLE_SESSION_IDS.has(turn.sessionId)))
     .sort((a, b) => a.createdAt - b.createdAt);
 
   return {

package/bridge/directIngest.mjs

@@ -28,6 +28,8 @@ const MAX_JSONL_TAIL_BYTES = 1_500_000;
 const MAX_JSONL_TAIL_LINES = 1200;
 const DIRECT_RUNNING_FRESH_WINDOW_SEC = 20;
 const DIRECT_RUNNING_STALE_TIMEOUT_SEC = 180;
+const INTERNAL_PLAN_MODE_SUFFIX =
+  "You are in PLAN MODE. Do not implement changes yet. Return only a concrete plan, then end with a single explicit approval question asking whether to proceed with implementation.";
 const PENDING_PATTERN =
   /input required|needs input|waiting for input|approval[_\s-]*required|awaiting approval|please approve|approve (?:this|the) plan|should i (?:proceed|implement|execute)|would you like me to (?:proceed|implement|execute)|ready to (?:implement|execute)|want me to (?:implement|execute)|proceed with implementation/i;
 
@@ -217,7 +219,7 @@ function parseCodexFile(file, nowMs) {
     }
 
     if (record.type === "event_msg" && record.payload?.type === "user_message") {
-      const message = String(record.payload?.message || "").trim();
+      const message = normalizeVisibleUserText(record.payload?.message || "");
       flushPendingAssistant();
       if (message && !isNoisePrompt(message) && !firstPrompt) firstPrompt = message;
       appendDirectTurn(chatTurns, {
@@ -271,7 +273,7 @@ function parseCodexFile(file, nowMs) {
     if (record.type === "response_item" && record.payload?.type === "message") {
       const role = record.payload?.role;
       if (role === "user") {
-        const text = extractCodexText(record.payload?.content);
+        const text = normalizeVisibleUserText(extractCodexText(record.payload?.content));
         flushPendingAssistant();
         if (text && !isNoisePrompt(text) && !firstPrompt) firstPrompt = text;
         appendDirectTurn(chatTurns, {
@@ -622,7 +624,7 @@ function formatCodexToolCall(item) {
 function extractClaudeUserText(message) {
   if (!message) return "";
   if (typeof message.content === "string") {
-    const text = sanitizeDirectText(message.content);
+    const text = normalizeVisibleUserText(message.content);
     return shouldIncludeDirectUserText(text) ? text : "";
   }
   if (!Array.isArray(message.content)) return "";
@@ -630,7 +632,7 @@ function extractClaudeUserText(message) {
   const collected = [];
   for (const part of message.content) {
     if (typeof part === "string") {
-      const text = sanitizeDirectText(part);
+      const text = normalizeVisibleUserText(part);
       if (shouldIncludeDirectUserText(text)) {
         collected.push(text);
       }
@@ -639,20 +641,20 @@ function extractClaudeUserText(message) {
     const partType = String(part?.type || "").trim().toLowerCase();
     if (partType && partType !== "text" && partType !== "input_text") continue;
     if (typeof part?.text === "string") {
-      const text = sanitizeDirectText(part.text);
+      const text = normalizeVisibleUserText(part.text);
       if (shouldIncludeDirectUserText(text)) {
         collected.push(text);
       }
     }
     if (typeof part?.content === "string" && part.content.trim()) {
-      const text = sanitizeDirectText(part.content);
+      const text = normalizeVisibleUserText(part.content);
       if (shouldIncludeDirectUserText(text)) {
         collected.push(text);
       }
     }
   }
 
-  return collected.join("\n\n").trim();
+  return dedupeCollectedText(collected).join("\n\n").trim();
 }
 
 function extractClaudeAssistantText(message) {
@@ -869,6 +871,37 @@ function sanitizeDirectText(value) {
     .trim();
 }
 
+function normalizeVisibleUserText(value) {
+  const text = sanitizeDirectText(value);
+  if (!text) return "";
+
+  return text
+    .replace(new RegExp(`(?:\\n\\s*)*${escapeRegExp(INTERNAL_PLAN_MODE_SUFFIX)}\\s*$`, "i"), "")
+    .trim();
+}
+
+function dedupeCollectedText(values) {
+  const deduped = [];
+  const seen = new Set();
+
+  for (const value of values) {
+    const text = String(value || "").trim();
+    if (!text) continue;
+
+    const normalized = normalizeComparableText(text);
+    if (!normalized || seen.has(normalized)) continue;
+
+    seen.add(normalized);
+    deduped.push(text);
+  }
+
+  return deduped;
+}
+
+function escapeRegExp(value) {
+  return String(value || "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
 function getRecentJsonlFiles(rootDir, limit) {
   const now = Date.now();
   const cached = recentFilesCache.get(rootDir);

package/bridge/server.mjs

@@ -1333,11 +1333,7 @@ function normalizeCommandList(input, agentType, prompt) {
 }
 
 function buildPlanPrompt(prompt) {
-  const base = safeTrimmedText(prompt, 1500);
-  if (!base) return "";
-  const suffix =
-    "\n\nYou are in PLAN MODE. Do not implement changes yet. Return only a concrete plan, then end with a single explicit approval question asking whether to proceed with implementation.";
-  return safeTrimmedText(`${base}${suffix}`, 1900);
+  return safeTrimmedText(prompt, 1500);
 }
 
 function createLauncherRun(input) {
@@ -2527,13 +2523,19 @@ function mergeDirectSnapshot(snapshot) {
       .map((item) => item?.id)
       .filter((id) => typeof id === "string")
   );
+  const incomingDirectTurnSessionIds = new Set(
+    (Array.isArray(snapshot.chatTurns) ? snapshot.chatTurns : [])
+      .map((item) => safeTrimmedText(item?.sessionId, 160))
+      .filter(Boolean)
+  );
   state.chatTurns = (Array.isArray(state.chatTurns) ? state.chatTurns : []).filter((item) => {
     const sessionId = String(item?.sessionId || "");
-    const isDirectSession = sessionId.startsWith("codex:") || sessionId.startsWith("claude:");
     const isDirectTurn = safeTrimmedText(item?.source, 48).toUpperCase() === "DIRECT" || String(item?.id || "").startsWith("direct:");
-    if (!isDirectSession || !isDirectTurn) return true;
-    if (!incomingDirectSessionIds.has(sessionId)) return false;
-    return incomingDirectTurnIds.has(item.id);
+    if (!isDirectTurn) return true;
+    if (incomingDirectTurnIds.has(item.id)) return true;
+    if (incomingDirectTurnSessionIds.has(sessionId)) return false;
+    if (incomingDirectSessionIds.has(sessionId)) return false;
+    return true;
   });
 
   const existingTurns = new Map((Array.isArray(state.chatTurns) ? state.chatTurns : []).map((item) => [item.id, item]));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-companion",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "private": false,
   "type": "module",
   "description": "Phone-to-computer companion for Codex and Claude Code.",

package/relay/server.mjs

@@ -39,6 +39,7 @@ const MAX_PHONE_TOKENS = 2_000;
 const MAX_PREVIEW_RECORDS = 4_000;
 const PHONE_TOKEN_HEADER = "x-agent-companion-phone-token";
 const LAPTOP_TOKEN_HEADER = "x-agent-companion-laptop-token";
+const SEEDED_SAMPLE_SESSION_IDS = new Set(["s_codex_live_01", "s_claude_live_01", "s_codex_live_02"]);
 
 const STATE_FILE = path.resolve(PROJECT_ROOT, "relay", "state.json");
 const app = express();
@@ -86,6 +87,7 @@ app.get("/health", (_req, res) => {
 app.get("/api/admin/analytics", requireAdminToken, (_req, res) => {
   cleanupExpiredPairings();
   cleanupExpiredPreviews();
+  res.setHeader("Cache-Control", "no-store");
   res.json(buildAdminAnalytics());
 });
 
@@ -288,6 +290,16 @@ app.post("/api/pairings/claim", (req, res) => {
   mutateState(() => {
     pairing.claimedAt = now;
     pairing.phoneToken = phoneToken;
+    if (!isObject(state.revokedPhoneDevices)) {
+      state.revokedPhoneDevices = {};
+    }
+    delete state.revokedPhoneDevices[pairing.deviceId];
+    if (!isObject(state.analytics)) {
+      state.analytics = {
+        totalPairClaims: 0
+      };
+    }
+    state.analytics.totalPairClaims = toInt(state.analytics.totalPairClaims, 0) + 1;
 
     state.phones.push({
       phoneToken,
@@ -311,6 +323,37 @@ app.post("/api/pairings/claim", (req, res) => {
   });
 });
 
+app.delete("/api/devices/:id/pairing", requirePhoneToken, (req, res) => {
+  const deviceId = safeText(req.params.id, 200);
+  const phone = req.phoneSession;
+  if (!deviceId) {
+    return res.status(400).json({ ok: false, error: "device id is required" });
+  }
+  if (!phone || safeText(phone.deviceId, 200) !== deviceId) {
+    return res.status(403).json({ ok: false, error: "token cannot access this device" });
+  }
+
+  mutateState(() => {
+    if (!isObject(state.revokedPhoneDevices)) {
+      state.revokedPhoneDevices = {};
+    }
+    state.revokedPhoneDevices[deviceId] = Date.now();
+    state.phones = state.phones.filter((item) => safeText(item.deviceId, 200) !== deviceId);
+    state.pairings = state.pairings.filter((item) => safeText(item.deviceId, 200) !== deviceId);
+    for (const laptop of state.laptops) {
+      if (safeText(laptop.deviceId, 200) !== deviceId) continue;
+      laptop.pairedAt = null;
+      laptop.pairCode = null;
+      laptop.pairingExpiresAt = null;
+      laptop.pairingUrl = null;
+      laptop.pairingPayload = null;
+      laptop.updatedAt = Date.now();
+    }
+  });
+
+  return res.json({ ok: true, deviceId });
+});
+
 app.use("/api/devices/:id", requirePhoneToken, requireDeviceAccess);
 
 app.get("/api/devices/:id/status", (req, res) => {
@@ -1493,6 +1536,9 @@ function findPhoneByToken(token) {
 function resolvePhoneSession(token) {
   const exact = findPhoneByToken(token);
   if (exact) {
+    if (isPhoneDeviceRevoked(exact.deviceId)) {
+      return null;
+    }
     const refreshedToken = issuePhoneToken(exact.deviceId);
     return {
       phone: exact,
@@ -1505,6 +1551,7 @@ function resolvePhoneSession(token) {
 
   const deviceId = safeText(claims.deviceId, 200);
   if (!deviceId) return null;
+  if (isPhoneDeviceRevoked(deviceId)) return null;
 
   const restored = {
     phoneToken: token,
@@ -1862,6 +1909,10 @@ function loadState() {
     pairings: [],
     phones: [],
     previews: [],
+    revokedPhoneDevices: {},
+    analytics: {
+      totalPairClaims: 0
+    },
     updatedAt: Date.now()
   };
 
@@ -1924,20 +1975,29 @@ function buildAdminAnalytics() {
   );
   const claimedPairings = state.pairings.filter((item) => item.claimedAt);
   const activePreviews = state.previews.filter((item) => item.expiresAt > now);
-  const snapshotRollup = collectSnapshotAnalytics(state.laptops, onlineLaptopIds, now);
-  const uniquePairedDeviceIds = new Set(
-    state.laptops.map((item) => safeText(item.deviceId, 200)).filter(Boolean)
+  const uniqueCurrentPairedDeviceIds = new Set(state.phones.map((item) => safeText(item.deviceId, 200)).filter(Boolean));
+  const uniqueKnownDeviceIds = new Set([
+    ...uniqueCurrentPairedDeviceIds,
+    ...claimedPairings.map((item) => safeText(item.deviceId, 200)).filter(Boolean)
+  ]);
+  const totalPairs = Math.max(
+    toInt(state.analytics?.totalPairClaims, 0),
+    uniqueCurrentPairedDeviceIds.size,
+    claimedPairings.length
   );
+  const analyticsLaptops = listCurrentPairedLaptops(uniqueCurrentPairedDeviceIds);
+  const snapshotRollup = collectSnapshotAnalytics(analyticsLaptops, onlineLaptopIds, now);
 
   return {
     ok: true,
     generatedAt: now,
     summary: {
-      totalUsers: uniquePairedDeviceIds.size,
-      totalPairs: claimedPairings.length,
+      totalUsers: uniqueKnownDeviceIds.size,
+      currentPairs: uniqueCurrentPairedDeviceIds.size,
+      totalPairs,
       newUsers24h: countUniqueRecentPairings(claimedPairings, now, 24 * 60 * 60 * 1000),
       newUsers7d: countUniqueRecentPairings(claimedPairings, now, 7 * 24 * 60 * 60 * 1000),
-      onlineDevices: onlineLaptopIds.size,
+      onlineDevices: analyticsLaptops.filter((item) => onlineLaptopIds.has(item.laptopId)).length,
       activeSessions: snapshotRollup.summary.activeSessions,
       appSessionsTotal: snapshotRollup.summary.appSessionsTotal,
       appRunsTotal: snapshotRollup.summary.appRunsTotal,
@@ -1955,6 +2015,40 @@ function buildAdminAnalytics() {
   };
 }
 
+function listCurrentPairedLaptops(currentPairDeviceIds) {
+  const byDeviceId = new Map();
+
+  for (const laptop of state.laptops) {
+    const deviceId = safeText(laptop.deviceId, 200);
+    if (!deviceId || !currentPairDeviceIds.has(deviceId)) continue;
+
+    const previous = byDeviceId.get(deviceId) || null;
+    if (!previous) {
+      byDeviceId.set(deviceId, laptop);
+      continue;
+    }
+
+    const previousScore = Math.max(
+      toInt(previous.lastConnectedAt, 0),
+      toInt(previous.lastSnapshotAt, 0),
+      toInt(previous.updatedAt, 0),
+      toInt(previous.createdAt, 0)
+    );
+    const nextScore = Math.max(
+      toInt(laptop.lastConnectedAt, 0),
+      toInt(laptop.lastSnapshotAt, 0),
+      toInt(laptop.updatedAt, 0),
+      toInt(laptop.createdAt, 0)
+    );
+
+    if (nextScore >= previousScore) {
+      byDeviceId.set(deviceId, laptop);
+    }
+  }
+
+  return [...byDeviceId.values()];
+}
+
 function collectSnapshotAnalytics(laptops, onlineLaptopIds, now) {
   const sessionStates = {
     RUNNING: 0,
@@ -1983,10 +2077,26 @@ function collectSnapshotAnalytics(laptops, onlineLaptopIds, now) {
       const snapshot = isObject(laptop.latestSnapshot) ? laptop.latestSnapshot : {};
       const runs = Array.isArray(snapshot.runs) ? snapshot.runs.filter((item) => isObject(item)) : [];
       const sessionSummaries = Array.isArray(snapshot.sessionSummaries)
-        ? snapshot.sessionSummaries.filter((item) => isObject(item))
+        ? snapshot.sessionSummaries.filter((item) => {
+            if (!isObject(item)) return false;
+            const sessionId = safeText(item.id || item?.session?.id, 200);
+            return !SEEDED_SAMPLE_SESSION_IDS.has(sessionId);
+          })
+        : [];
+      const sessions = Array.isArray(snapshot.sessions)
+        ? snapshot.sessions.filter((item) => {
+            if (!isObject(item)) return false;
+            const sessionId = safeText(item.id || item?.session?.id, 200);
+            return !SEEDED_SAMPLE_SESSION_IDS.has(sessionId);
+          })
+        : [];
+      const chatTurns = Array.isArray(snapshot.chatTurns)
+        ? snapshot.chatTurns.filter((item) => {
+            if (!isObject(item)) return false;
+            const sessionId = safeText(item.sessionId, 200);
+            return sessionId && !SEEDED_SAMPLE_SESSION_IDS.has(sessionId);
+          })
         : [];
-      const sessions = Array.isArray(snapshot.sessions) ? snapshot.sessions.filter((item) => isObject(item)) : [];
-      const chatTurns = Array.isArray(snapshot.chatTurns) ? snapshot.chatTurns.filter((item) => isObject(item)) : [];
       const sessionList = sessionSummaries.length > 0 ? sessionSummaries : sessions;
       const sessionLookup = new Map();
       for (const session of sessionList) {
@@ -2008,7 +2118,7 @@ function collectSnapshotAnalytics(laptops, onlineLaptopIds, now) {
         if (agentType === "CLAUDE") agentUsage.claudeRuns += 1;
 
         const sessionId = safeText(run.sessionId, 200);
-        if (sessionId) appSessionIds.add(sessionId);
+        if (sessionId && !SEEDED_SAMPLE_SESSION_IDS.has(sessionId)) appSessionIds.add(sessionId);
 
         const createdAt = toInt(run.createdAt, 0);
         if (createdAt) {
@@ -2020,13 +2130,19 @@ function collectSnapshotAnalytics(laptops, onlineLaptopIds, now) {
         const sessionId = safeText(turn.sessionId, 200);
         const role = safeText(turn.role, 20).toUpperCase();
         const source = safeText(turn.source, 40).toUpperCase();
+        const text = safeText(turn.text || turn.content, 20_000);
         if (!sessionId || role !== "USER") continue;
-        if (source === "MESSAGE_API" || source === "LAUNCH") {
+        if (source === "MESSAGE_API" && text && !SEEDED_SAMPLE_SESSION_IDS.has(sessionId)) {
           appSessionIds.add(sessionId);
         }
       }
 
-      for (const sessionId of appSessionIds) {
+      const activeAppSessionIds = [...appSessionIds].filter((sessionId) => {
+        if (sessionLookup.has(sessionId)) return true;
+        return runs.some((run) => safeText(run.sessionId, 200) === sessionId);
+      });
+
+      for (const sessionId of activeAppSessionIds) {
         const session = sessionLookup.get(sessionId);
         if (!session) continue;
 
@@ -2061,8 +2177,8 @@ function collectSnapshotAnalytics(laptops, onlineLaptopIds, now) {
         createdAt: laptop.createdAt,
         pairedAt: laptop.pairedAt || null,
         lastSeenAt,
-        sessionCount: appSessionIds.size,
-        activeSessionCount: [...appSessionIds]
+        sessionCount: activeAppSessionIds.length,
+        activeSessionCount: activeAppSessionIds
           .map((sessionId) => sessionLookup.get(sessionId))
           .filter(Boolean)
           .filter((session) => {
@@ -2178,6 +2294,10 @@ function sanitizeState(raw) {
     pairings: [],
     phones: [],
     previews: [],
+    revokedPhoneDevices: {},
+    analytics: {
+      totalPairClaims: 0
+    },
     updatedAt: Date.now()
   };
 
@@ -2259,11 +2379,30 @@ function sanitizeState(raw) {
         .filter((item) => item.previewId && item.accessToken && item.laptopId && item.deviceId && item.target)
     : [];
 
+  const revokedPhoneDevices = isObject(raw.revokedPhoneDevices)
+    ? Object.fromEntries(
+        Object.entries(raw.revokedPhoneDevices)
+          .map(([deviceId, revokedAt]) => [safeText(deviceId, 200), toInt(revokedAt, 0)])
+          .filter(([deviceId, revokedAt]) => deviceId && revokedAt > 0)
+      )
+    : {};
+
+  const totalPairClaims = Math.max(
+    toInt(raw?.analytics?.totalPairClaims, 0),
+    phones.length,
+    new Set(laptops.filter((item) => item.pairedAt).map((item) => item.deviceId).filter(Boolean)).size,
+    pairings.filter((item) => item.claimedAt).length
+  );
+
   return {
     laptops,
     pairings,
     phones,
     previews,
+    revokedPhoneDevices,
+    analytics: {
+      totalPairClaims
+    },
     updatedAt: toInt(raw.updatedAt, Date.now())
   };
 }
@@ -2291,6 +2430,11 @@ function trimStateCollections() {
   }
 }
 
+function isPhoneDeviceRevoked(deviceId) {
+  if (!deviceId || !isObject(state.revokedPhoneDevices)) return false;
+  return toInt(state.revokedPhoneDevices[deviceId], 0) > 0;
+}
+
 function gracefulShutdown(signal) {
   if (shuttingDown) return;
   shuttingDown = true;