clauderipple 0.12.3 → 0.12.5

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## 0.12.5 — 2026-10-22
+
+### Changed
+
+- **The install script adds the menu-bar app on macOS and Windows.** It carries the repair
+  screen that opens while the router is down, which someone who does not use a terminal needs.
+  Electron is about 270MB and fetched once; `CLAUDERIPPLE_NO_TRAY=1` skips it, and a failed
+  fetch leaves the router installed with a hint to add the app later. Linux keeps it opt-in.
+
+### Fixed
+
+- **Updating restarts the phone host too.** An update replaced the files but left the running
+  host on the old code until the machine restarted, so a fix like 0.12.4's Windows sending did
+  not arrive. `install` (which every update ends with) now restarts a phone host this
+  installation registered, unless a turn is in progress; then it says to run
+  `clauderipple remote install` afterwards. A host run from a source checkout is left alone.
+- **Windows with a non-ASCII account name no longer re-registers the router on every install.**
+  The scheduled task was read back in the console's code page, so it never matched (#74, #75 by
+  @115dkk). Tests that assumed "/" paths or POSIX permission bits now run only where those hold
+  (#76).
+
+## 0.12.4 — 2026-10-22
+
+### Added
+
+- **On Windows, the phone can send to a session open in the Claude app.** Before, such a session
+  could be read but not written to. It needs Remote Control turned on in the Claude app, the same
+  as on macOS; with only the Claude app in use, the login ClaudeRipple saw the app use carries it.
+  Handing a phone session over to the Claude app is still macOS only.
+
 ## 0.12.3 — 2026-10-22
 
 ### Added

package/README.es.md

@@ -432,15 +432,17 @@ clauderipple ui
 
 **Proveedores** → añade ChatGPT o pega una clave de API → **Asignación de modelos**.
 
-**La app de la barra de menús / bandeja** es opcional. Muestra el estado del router y abre
-el panel con un clic:
+**La app de la barra de menús / bandeja** muestra el estado del router, abre el panel con un
+clic y ofrece una pantalla de reparación que funciona aunque el router esté caído:
 
 ```sh
 clauderipple tray
 ```
 
-Funciona con Electron, que ocupa unos 270 MB y por eso no se instala por defecto.
-`clauderipple tray --install` lo descarga una sola vez; todo lo demás funciona sin él.
+En macOS y Windows el script de instalación la añade por defecto. Funciona con Electron, unos
+270 MB que se descargan una sola vez; define `CLAUDERIPPLE_NO_TRAY=1` antes del comando de
+instalación para omitirla. En Linux, o tras instalar solo con npm, `clauderipple tray --install`
+la añade. Todo lo demás funciona sin ella.
 
 **Actualización.** La bandeja ofrece la nueva versión cuando la hay (**Buscar actualizaciones…**), o bien:
 

package/README.ja.md

@@ -258,13 +258,13 @@ clauderipple ui
 
 **プロバイダー** → ChatGPTを追加するかAPIキーを貼り付け → **モデルマッピング**。
 
-**メニューバー / トレイアプリ**は任意です。ルーターの状態を表示し、ワンクリックでダッシュボードを開けます。
+**メニューバー / トレイアプリ**はルーターの状態を表示し、ワンクリックでダッシュボードを開き、ルーターが止まっていても開ける修復画面を備えています。
 
 ```sh
 clauderipple tray
 ```
 
-Electronで動作し、約270MBあるため、デフォルトではインストールされません。`clauderipple tray --install`で一度だけ取得します。それ以外の機能はすべてElectronなしで動きます。
+macOSとWindowsではインストールスクリプトが標準で追加します。Electronで動作し約270MBで、取得は一度だけです。不要ならインストールコマンドの前に`CLAUDERIPPLE_NO_TRAY=1`を付けてください。Linux、またはnpmだけでインストールした場合は`clauderipple tray --install`で追加します。それ以外の機能はすべてアプリなしで動きます。
 
 **アップデート**。新しいバージョンがあればトレイから案内されます（**アップデートを確認…**）。または次のコマンドを実行します。
 

package/README.ko.md

@@ -350,14 +350,15 @@ clauderipple ui
 
 **프로바이더** → ChatGPT 추가 또는 API 키 붙여 넣기 → **모델 매핑**.
 
-**메뉴 막대·트레이 앱은 선택 사항입니다.** 라우터 상태를 보여주고 한 번에 대시보드를 엽니다.
+**메뉴 막대·트레이 앱**은 라우터 상태를 보여주고, 한 번에 대시보드를 열고, 라우터가 죽어도 열리는 복구 화면을 갖고 있습니다.
 
 ```sh
 clauderipple tray
 ```
 
-Electron으로 도는데 용량이 270MB라 기본 설치에는 넣지 않았습니다. `clauderipple tray --install`이 한 번만
-받아 옵니다. 나머지 기능은 Electron 없이도 다 돕니다.
+macOS와 Windows에서는 설치 스크립트가 기본으로 함께 설치합니다. Electron으로 돌아 약 270MB이고 한 번만 받습니다.
+빼고 싶으면 설치 명령 앞에 `CLAUDERIPPLE_NO_TRAY=1`을 붙이세요. Linux나 npm으로만 설치했다면
+`clauderipple tray --install`로 추가합니다. 나머지 기능은 앱 없이도 다 돕니다.
 
 **업데이트.** 새 버전이 나오면 트레이가 알려 줍니다(**업데이트 확인…**). 터미널에서는:
 

package/README.md

@@ -413,15 +413,16 @@ clauderipple ui
 
 **Providers** → add ChatGPT or paste an API key → **Model mapping**.
 
-**The menu-bar / tray app** is optional. It shows the router's state and opens the
-dashboard in a click:
+**The menu-bar / tray app** shows the router's state, opens the dashboard in a click, and
+keeps a repair screen that works while the router is down:
 
 ```sh
 clauderipple tray
 ```
 
-It runs on Electron, which is about 270MB and is therefore not installed by default.
-`clauderipple tray --install` fetches it once; everything else works without it.
+On macOS and Windows the install script adds it by default. It runs on Electron, about 270MB,
+fetched once; set `CLAUDERIPPLE_NO_TRAY=1` before the install command to skip it. On Linux, or
+after an npm-only install, `clauderipple tray --install` adds it. Everything else works without it.
 
 **Updating.** The tray offers a new version when there is one (**Check for Updates…**), or:
 

package/README.pt-BR.md

@@ -424,15 +424,17 @@ clauderipple ui
 
 **Provedores** → adicione o ChatGPT ou cole uma chave de API → **Mapeamento de modelos**.
 
-**O app da barra de menus / bandeja** é opcional. Ele mostra o estado do roteador e abre o
-painel com um clique:
+**O app da barra de menus / bandeja** mostra o estado do roteador, abre o painel com um
+clique e traz uma tela de reparo que funciona mesmo com o roteador fora do ar:
 
 ```sh
 clauderipple tray
 ```
 
-Ele roda em Electron, que tem cerca de 270 MB e, por isso, não é instalado por padrão.
-`clauderipple tray --install` baixa o Electron uma única vez; todo o resto funciona sem ele.
+No macOS e no Windows o script de instalação o adiciona por padrão. Ele roda em Electron, cerca
+de 270 MB baixados uma única vez; defina `CLAUDERIPPLE_NO_TRAY=1` antes do comando de instalação
+para pular. No Linux, ou depois de instalar só pelo npm, `clauderipple tray --install` o adiciona.
+Todo o resto funciona sem ele.
 
 **Atualização.** A bandeja oferece a nova versão quando houver uma (**Verificar atualizações…**), ou:
 

package/README.zh-CN.md

@@ -257,13 +257,13 @@ clauderipple ui
 
 **供应商** → 添加 ChatGPT 或粘贴 API 密钥 → **模型映射**。
 
-**菜单栏 / 托盘应用**是可选的。它显示路由服务的状态，点一下就能打开控制面板：
+**菜单栏 / 托盘应用**显示路由服务的状态，点一下就能打开控制面板，并带有路由服务停止时也能打开的修复界面：
 
 ```sh
 clauderipple tray
 ```
 
-它基于 Electron，体积约 270MB，因此默认不安装。`clauderipple tray --install` 会下载一次；除此之外的一切不需要它也能正常工作。
+在 macOS 和 Windows 上，安装脚本默认会一并安装它。它基于 Electron，约 270MB，只下载一次；如不需要，在安装命令前加上 `CLAUDERIPPLE_NO_TRAY=1` 即可跳过。在 Linux 上或仅通过 npm 安装时，用 `clauderipple tray --install` 添加。除此之外的一切不需要它也能正常工作。
 
 **更新。** 有新版本时，托盘应用会提示（**检查更新…**），也可以运行：
 

package/dist/app/package.json

@@ -1,5 +1,5 @@
 {
   "private": true,
-  "version": "0.12.3",
+  "version": "0.12.5",
   "type": "commonjs"
 }

package/dist/cli/src/index.js

@@ -255,6 +255,14 @@ async function install() {
     catch (e) {
         console.log(`  menu-bar app launcher not written: ${e.message}`);
     }
+    // The phone host has the same problem as the router above: new files, old process. The host
+    // decides whether it is ours and idle (remote host-service refreshPlan). Never fatal.
+    try {
+        execFileSync(installedRuntime.node, [installedRuntime.cli, "remote", "refresh"], { env: { ...process.env, ...installedRuntime.env }, stdio: "inherit" });
+    }
+    catch {
+        console.log("  the phone host was not restarted; if you use it, run: clauderipple remote install");
+    }
     console.log("\nDone. New Claude Desktop Code sessions go through ClaudeRipple. Existing sessions pick up settings.json env changes on their next request.");
 }
 async function uninstall() {

package/dist/cli/src/schtasks.js

@@ -25,9 +25,15 @@ export function taskName() {
 function ps(value) {
     return `'${value.replace(/'/g, "''")}'`;
 }
+/**
+ * Windows PowerShell writes to a pipe in the console's code page, which we would read as UTF-8: on
+ * a Korean Windows an account named in Hangul came back garbled, so the registered task never
+ * matched and every install tried to register it again (measured 2026-10-13). The script sets
+ * UTF-8 first.
+ */
 function run(script) {
     try {
-        const out = execFileSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], {
+        const out = execFileSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", `[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; ${script}`], {
             env: windowsPowerShellEnv(),
             stdio: ["ignore", "pipe", "pipe"],
             windowsHide: true,

package/dist/remote/src/bridge-client.js

@@ -53,13 +53,42 @@ export function loadObservedAuth(now = Date.now(), home = process.env.CLAUDERIPP
         return null;
     }
 }
-export function loadBridgeAuth() {
-    if (process.platform !== "darwin")
+/** The Claude Code CLI's own login on macOS: the keychain item the CLI writes. */
+function keychainCredentials() {
+    try {
+        const credentials = object(JSON.parse(execFileSync("security", ["find-generic-password", "-a", process.env.USER ?? os.userInfo().username, "-s", "Claude Code-credentials", "-w"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] })));
+        const oauth = object(credentials?.claudeAiOauth);
+        if (typeof oauth?.accessToken === "string" && oauth.accessToken && typeof oauth.expiresAt === "number")
+            return { accessToken: oauth.accessToken, expiresAt: oauth.expiresAt };
+    }
+    catch { /* the observed login may still serve */ }
+    return null;
+}
+/**
+ * The Claude Code CLI's own login on Windows: `%USERPROFILE%\.claude\.credentials.json`. There is
+ * no keychain there, and the Claude app on its own keeps no credentials file of its own: it
+ * injects the login into the CLI it starts (issue #70).
+ */
+function windowsCredentials(read, userHome) {
+    try {
+        const credentials = object(JSON.parse(read(path.join(userHome, ".claude", ".credentials.json"))));
+        const oauth = object(credentials?.claudeAiOauth);
+        if (typeof oauth?.accessToken === "string" && oauth.accessToken && typeof oauth.expiresAt === "number")
+            return { accessToken: oauth.accessToken, expiresAt: oauth.expiresAt };
+    }
+    catch { /* the observed login may still serve */ }
+    return null;
+}
+export function loadBridgeAuth(options = {}) {
+    const platform = options.platform ?? process.platform;
+    if (platform !== "darwin" && platform !== "win32")
         throw new Error(DESKTOP_BLOCKED);
-    const now = Date.now();
+    const now = options.now ?? Date.now();
+    const userHome = options.userHome ?? os.homedir();
+    const read = options.readFile ?? ((file) => fs.readFileSync(file, "utf8"));
     let organizationUuid;
     try {
-        const account = object(object(JSON.parse(fs.readFileSync(path.join(os.homedir(), ".claude.json"), "utf8")))?.oauthAccount);
+        const account = object(object(JSON.parse(read(path.join(userHome, ".claude.json"))))?.oauthAccount);
         if (typeof account?.organizationUuid !== "string")
             throw new Error();
         organizationUuid = account.organizationUuid;
@@ -67,23 +96,17 @@ export function loadBridgeAuth() {
     catch {
         throw new BridgeAuthError("이 컴퓨터의 Claude 로그인 정보를 읽을 수 없습니다.");
     }
-    let keychain = null;
-    try {
-        const credentials = object(JSON.parse(execFileSync("security", ["find-generic-password", "-a", process.env.USER ?? os.userInfo().username, "-s", "Claude Code-credentials", "-w"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] })));
-        const oauth = object(credentials?.claudeAiOauth);
-        if (typeof oauth?.accessToken === "string" && oauth.accessToken && typeof oauth.expiresAt === "number")
-            keychain = { accessToken: oauth.accessToken, expiresAt: oauth.expiresAt };
-    }
-    catch { /* the observed login may still serve */ }
+    // The CLI's own login: the macOS keychain item, or the credentials file Windows keeps.
+    const cli = options.cli ? options.cli() : platform === "darwin" ? keychainCredentials() : windowsCredentials(read, userHome);
     // The CLI's login while it is good; else the one the Claude app is working with; else the
     // CLI's expired one, so the phone is told it expired.
-    if (keychain && keychain.expiresAt - now > 5 * 60_000)
-        return { ...keychain, organizationUuid };
-    const observed = loadObservedAuth(now);
+    if (cli && cli.expiresAt - now > 5 * 60_000)
+        return { ...cli, organizationUuid };
+    const observed = options.observed ? options.observed(now) : loadObservedAuth(now);
     if (observed)
         return { ...observed, organizationUuid };
-    if (keychain)
-        return { ...keychain, organizationUuid };
+    if (cli)
+        return { ...cli, organizationUuid };
     throw new BridgeAuthError(LOGIN_EXPIRED);
 }
 /** `slash_commands` minus `terminal_slash_commands`, which phone UIs should hide (SDK init docs). */

package/dist/remote/src/desktop.js

@@ -5,7 +5,7 @@ import { execFileSync } from "node:child_process";
 import os from "node:os";
 import path from "node:path";
 import { EventLog } from "./eventlog.js";
-import { processCommands } from "./processes.js";
+import { creationDateToFileTime, parseFileTime, processCommands, processSnapshot, sameFileTime } from "./processes.js";
 import { messageContent, sendUserFileImages } from "./images.js";
 import { PERMISSION_MODES } from "./protocol.js";
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -18,15 +18,64 @@ const RECENT_MS = 14 * 24 * 60 * 60 * 1000;
  */
 const verifiedStarts = new Map();
 let snapshot = null;
-/** Registry identity is authoritative; ps flags remain a legacy fallback only. Cached for 1 s. */
-export function liveDesktopProcesses(dir, maxAgeMs = 1000, platform = process.platform) {
-    if (platform !== "darwin")
+/**
+ * Is this pid the process the registry recorded? On macOS the start time comes from `ps`.
+ */
+function darwinAlive() {
+    return (pid, procStart) => {
+        try {
+            process.kill(pid, 0);
+            if (typeof procStart === "string" && verifiedStarts.get(pid) !== procStart) {
+                const started = execFileSync("ps", ["-o", "lstart=", "-p", String(pid)], { encoding: "utf8", env: { ...process.env, LC_ALL: "C", TZ: "UTC" }, stdio: ["ignore", "pipe", "ignore"] }).trim();
+                if (started !== procStart)
+                    return false;
+                verifiedStarts.set(pid, started);
+            }
+            return true;
+        }
+        catch {
+            return false;
+        } // Dead or recycled process, not a live desktop writer.
+    };
+}
+/**
+ * Is this pid the process the registry recorded? Windows has no `ps -o lstart=`: the registry's
+ * procStart is a FILETIME (100 ns ticks since 1601) and the OS reports the same instant as a
+ * CreationDate. A pid alone proves nothing there — Windows recycles pids — so the start times
+ * are compared (issue #70).
+ */
+function windowsAlive(processes) {
+    const running = new Set();
+    const starts = new Map();
+    for (const p of processes.current()) {
+        running.add(p.pid);
+        const start = typeof p.started === "string" ? creationDateToFileTime(p.started) : null;
+        if (start !== null)
+            starts.set(p.pid, start);
+    }
+    return (pid, procStart) => {
+        if (!running.has(pid))
+            return false;
+        const started = starts.get(pid);
+        const recorded = parseFileTime(procStart);
+        if (started === undefined || recorded === null)
+            return true; // Nothing to compare: the pid runs.
+        return sameFileTime(started, recorded);
+    };
+}
+/**
+ * Registry identity is authoritative; ps flags remain a legacy fallback only. Cached for 1 s.
+ * The Windows snapshot behind it is read in the background, so this never waits for PowerShell
+ * more than once (see ProcessSnapshot).
+ */
+export function liveDesktopProcesses(dir, maxAgeMs = 1000, platform = process.platform, processes = processSnapshot) {
+    if (platform !== "darwin" && platform !== "win32")
         return new Map();
     const now = Date.now();
-    if (snapshot && snapshot.dir === dir && now - snapshot.at < maxAgeMs)
+    if (snapshot && snapshot.dir === dir && snapshot.platform === platform && now - snapshot.at < maxAgeMs)
         return snapshot.result;
     const result = new Map();
-    snapshot = { dir, at: now, result };
+    snapshot = { dir, platform, at: now, result };
     let entries;
     try {
         entries = fs.readdirSync(dir, { withFileTypes: true });
@@ -36,6 +85,7 @@ export function liveDesktopProcesses(dir, maxAgeMs = 1000, platform = process.pl
             return result;
         throw error;
     }
+    const candidates = [];
     for (const entry of entries) {
         if (!entry.isFile() || !/^\d+\.json$/.test(entry.name))
             continue;
@@ -53,20 +103,16 @@ export function liveDesktopProcesses(dir, maxAgeMs = 1000, platform = process.pl
             continue;
         if (!["busy", "shell", "idle", "waiting"].includes(str(value.status)))
             continue;
-        try {
-            process.kill(pid, 0);
-            if (typeof value.procStart === "string" && verifiedStarts.get(pid) !== value.procStart) {
-                const started = execFileSync("ps", ["-o", "lstart=", "-p", String(pid)], { encoding: "utf8", env: { ...process.env, LC_ALL: "C", TZ: "UTC" }, stdio: ["ignore", "pipe", "ignore"] }).trim();
-                if (started !== value.procStart)
-                    continue;
-                verifiedStarts.set(pid, started);
-            }
-        }
-        catch {
-            continue;
-        } // Dead or recycled process, not a live desktop writer.
         const status = value.status;
-        result.set(value.sessionId, { sessionId: value.sessionId, pid, status, ...(typeof value.bridgeSessionId === "string" ? { bridgeSessionId: value.bridgeSessionId } : {}) });
+        candidates.push({ pid, procStart: value.procStart, entry: { sessionId: value.sessionId, pid, status, ...(typeof value.bridgeSessionId === "string" ? { bridgeSessionId: value.bridgeSessionId } : {}) } });
+    }
+    if (!candidates.length)
+        return result;
+    const alive = platform === "win32" ? windowsAlive(processes) : darwinAlive();
+    for (const candidate of candidates) {
+        if (!alive(candidate.pid, candidate.procStart))
+            continue;
+        result.set(candidate.entry.sessionId, candidate.entry);
     }
     return result;
 }

package/dist/remote/src/host-service.js

@@ -104,6 +104,32 @@ async function waitForHost(dir = remoteHome()) {
     }
     throw new Error("host service was registered but did not answer its authenticated status; check its logs");
 }
+export function refreshPlan(o) {
+    if (!o.installed || o.definition === null)
+        return "absent";
+    const xml = o.script.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    if (![o.script, xml, o.script.replace(/'/g, "''")].some(form => o.definition.includes(form)))
+        return "foreign";
+    // An older host does not report it; its update came while the router sat idle, so most likely idle too.
+    return o.busy ? "busy" : "restart";
+}
+/** The running host's own answer; undefined when it does not answer or predates the field. */
+export async function hostBusy(dir = remoteHome()) {
+    try {
+        const cfg = loadConfig(dir, false);
+        const secret = fs.readFileSync(path.join(dir, "local.secret"), "utf8").trim();
+        const response = await fetch(`http://127.0.0.1:${cfg.port}/local/status`, { headers: { "x-ripple-local": secret }, redirect: "error", signal: AbortSignal.timeout(2000) });
+        if (!response.ok) {
+            await response.body?.cancel();
+            return undefined;
+        }
+        const body = await response.json();
+        return typeof body.busy === "boolean" ? body.busy : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 export async function installService(spec) {
     const platform = process.platform;
     if (platform === "darwin")

package/dist/remote/src/local-control.js

@@ -66,6 +66,7 @@ export class LocalControl {
                     reachableFromPhone: !!cfg.relay || this.where.reachableFromPhone, pushReady: !!cfg.relay,
                     phones: this.opts.phones(), settings: { bind: saved.bind, ...(saved.relay ? { relay: saved.relay } : {}) }, defaultRelay: DEFAULT_RELAY,
                     restartRequired: saved.bind !== cfg.bind || saved.relay !== cfg.relay,
+                    busy: this.opts.busy?.() ?? false,
                 });
                 return;
             }

package/dist/remote/src/main.js

@@ -30,7 +30,7 @@ import { RouterClient } from "./router.js";
 import { HostServer } from "./server.js";
 import { LocalControl } from "./local-control.js";
 import { findClaude, specFor, cliLoginWarning } from "./service.js";
-import { installService, uninstallService, serviceStatus, servicePaths, renderService, supervisorName, controlShutdown } from "./host-service.js";
+import { installService, uninstallService, serviceStatus, servicePaths, renderService, supervisorName, controlShutdown, refreshPlan, hostBusy } from "./host-service.js";
 import { Sessions } from "./sessions.js";
 import { desktopHandoff } from "./handoff.js";
 import { claudeBinary, claudeCodeLogin } from "../../cli/src/claude-auth.js";
@@ -179,6 +179,7 @@ async function runHost() {
             phones: () => server?.phones() ?? [],
             rotate: token => { server?.rotateToken(token); },
             shutdown: () => stop(),
+            busy: () => live.busy(),
         }),
     });
     server = host;
@@ -234,7 +235,7 @@ async function installCmd() {
     const cfg = process.argv.includes("--print") ? loadConfig(dir, false) : configFromArgs(dir);
     // The CLI the host will start; also what a person is told to run when it has no login.
     const claudePath = findClaude(cfg.claudePath);
-    const spec = specFor({ script: fileURLToPath(import.meta.url), claudePath, ...(process.env.RIPPLE_REMOTE_HOME ? { remoteHome: process.env.RIPPLE_REMOTE_HOME } : {}) });
+    const spec = hostSpec(claudePath);
     if (process.argv.includes("--print")) {
         out(renderService(spec));
         return;
@@ -249,11 +250,38 @@ async function installCmd() {
     if (warning)
         out(`⚠ ${warning}\n`);
 }
+function hostSpec(claudePath) {
+    return specFor({ script: fileURLToPath(import.meta.url), claudePath, ...(process.env.RIPPLE_REMOTE_HOME ? { remoteHome: process.env.RIPPLE_REMOTE_HOME } : {}) });
+}
+/** Run by `clauderipple update` from the new files: restarts a host this installation registered (refreshPlan). */
+async function refreshCmd() {
+    const p = servicePaths();
+    let definition = null;
+    try {
+        definition = fs.readFileSync(p.definition, "utf8");
+    }
+    catch { /* not registered */ }
+    const plan = refreshPlan({ installed: serviceStatus().installed, definition, script: fileURLToPath(import.meta.url), busy: definition === null ? undefined : await hostBusy() });
+    if (plan === "absent")
+        return;
+    if (plan === "foreign") {
+        out(`phone host: runs from other files (${p.definition}); left as it is\n`);
+        return;
+    }
+    if (plan === "busy") {
+        out("phone host: a turn is in progress, so it keeps the old code; restart it afterwards with: clauderipple remote install\n");
+        return;
+    }
+    const spec = hostSpec(findClaude(loadConfig(remoteHome(), false).claudePath));
+    for (const line of await installService(spec))
+        out(`phone host: ${line}\n`);
+}
 async function main() {
     const sub = process.argv[2] && !process.argv[2].startsWith("--") ? process.argv[2] : null;
     switch (sub) {
         case null: return runHost();
         case "install": return installCmd();
+        case "refresh": return refreshCmd();
         case "uninstall":
             for (const line of await uninstallService())
                 out(`${line}\n`);

package/dist/remote/src/processes.js

@@ -1,11 +1,26 @@
-// One OS process snapshot for transcript liveness. Desktop registry identity remains macOS-only.
-import { execFileSync } from "node:child_process";
+// One OS process snapshot for transcript liveness. The desktop registry reads macOS and Windows.
+import { execFile, execFileSync } from "node:child_process";
 import { windowsPowerShellEnv } from "../../cli/src/windows-powershell.js";
-export function listProcesses(platform = process.platform, exec = (file, args) => execFileSync(file, args, {
+/** 100 ns ticks from 1601-01-01 to 1970-01-01: a Windows FILETIME counts from 1601, Unix time from 1970. */
+const FILETIME_UNIX_TICKS = 116444736000000000n;
+/** A millisecond: the registry's own start time and the OS's CreationDate may differ by a hair. */
+const FILETIME_TOLERANCE = 10000n;
+const exec = (file, args) => execFileSync(file, args, {
     encoding: "utf8", maxBuffer: 16 * 1024 * 1024, timeout: 5000, windowsHide: true, env: windowsPowerShellEnv(), stdio: ["ignore", "pipe", "pipe"],
-})) {
+});
+const execAsync = (file, args) => new Promise((resolve, reject) => {
+    execFile(file, args, { encoding: "utf8", maxBuffer: 16 * 1024 * 1024, timeout: 5000, windowsHide: true, env: windowsPowerShellEnv() }, (error, stdout) => { if (error)
+        reject(error);
+    else
+        resolve(stdout); });
+});
+/** The PowerShell that reads the Windows process table: pid, command line and start time. */
+function windowsSnapshotArgs() {
+    return ["-NoProfile", "-NonInteractive", "-Command", "$ErrorActionPreference = 'Stop'; [Console]::OutputEncoding = [Text.UTF8Encoding]::new(); ConvertTo-Json -Compress -InputObject @(Get-CimInstance Win32_Process | Select-Object ProcessId,CommandLine,@{Name='CreationDate';Expression={if ($_.CreationDate) {$_.CreationDate.ToUniversalTime().ToString('o')}}})"];
+}
+export function listProcesses(platform = process.platform, run = exec) {
     if (platform === "win32") {
-        const raw = JSON.parse(exec("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", "$ErrorActionPreference = 'Stop'; [Console]::OutputEncoding = [Text.UTF8Encoding]::new(); ConvertTo-Json -Compress -InputObject @(Get-CimInstance Win32_Process | Select-Object ProcessId,CommandLine,@{Name='CreationDate';Expression={if ($_.CreationDate) {$_.CreationDate.ToUniversalTime().ToString('o')}}})"]));
+        const raw = JSON.parse(run("powershell.exe", windowsSnapshotArgs()));
         if (!Array.isArray(raw))
             throw new Error("invalid Windows process snapshot");
         return raw.flatMap((value) => {
@@ -16,9 +31,123 @@ export function listProcesses(platform = process.platform, exec = (file, args) =
                 ? [{ pid: p.ProcessId, command: p.CommandLine, ...(typeof p.CreationDate === "string" ? { started: p.CreationDate } : {}) }] : [];
         });
     }
-    return exec("ps", ["-axo", "pid,command"]).split(/\r?\n/).flatMap(line => {
+    return run("ps", ["-axo", "pid,command"]).split(/\r?\n/).flatMap(line => {
         const m = /^\s*(\d+)\s+(.+)$/.exec(line);
         return m ? [{ pid: Number(m[1]), command: m[2] }] : [];
     });
 }
-export function processCommands() { return listProcesses().map(p => `${p.pid} ${p.command}`).join("\n"); }
+/** The same snapshot, read without blocking: the Windows path spawns PowerShell in the background. */
+export function listProcessesAsync(platform = process.platform, run = execAsync) {
+    if (platform === "win32")
+        return run("powershell.exe", windowsSnapshotArgs()).then(output => listProcesses(platform, () => output));
+    return run("ps", ["-axo", "pid,command"]).then(output => listProcesses(platform, () => output));
+}
+/**
+ * A Windows process start as the FILETIME the Claude app writes into its desktop registry:
+ * 100 ns ticks since 1601-01-01 UTC. The OS reports the same instant as an ISO string, so it
+ * is converted here (issue #70).
+ */
+export function creationDateToFileTime(value) {
+    const m = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(Z|[+-]\d{2}:?\d{2})?$/.exec(value.trim());
+    if (!m)
+        return null;
+    const [, year, month, day, hour, minute, second, fraction, zone] = m;
+    const seconds = Date.UTC(Number(year), Number(month) - 1, Number(day), Number(hour), Number(minute), Number(second)) / 1000;
+    if (!Number.isFinite(seconds))
+        return null;
+    let offset = 0;
+    if (zone && zone !== "Z") {
+        const parts = zone.slice(1).replace(":", "").match(/\d{2}/g) ?? [];
+        offset = (zone[0] === "-" ? -1 : 1) * (Number(parts[0] ?? 0) * 60 + Number(parts[1] ?? 0)) * 60;
+    }
+    // The fraction is in seconds; its digits are the 100 ns ticks themselves.
+    const ticks = BigInt(Math.round(seconds - offset)) * 10000000n + BigInt((fraction ?? "").padEnd(7, "0").slice(0, 7) || "0");
+    return ticks + FILETIME_UNIX_TICKS;
+}
+/** The registry's own start time, in the same FILETIME. A JSON number has lost its last digits already. */
+export function parseFileTime(value) {
+    if (typeof value === "bigint")
+        return value;
+    if (typeof value === "number")
+        return Number.isFinite(value) && Number.isInteger(value) ? BigInt(value) : null;
+    if (typeof value === "string" && /^\d{1,20}$/.test(value.trim()))
+        return BigInt(value.trim());
+    return null;
+}
+/** The same process start: the same instant, or within a millisecond of it. */
+export function sameFileTime(a, b) {
+    const diff = a > b ? a - b : b - a;
+    return diff <= FILETIME_TOLERANCE;
+}
+/**
+ * The host's view of the running processes. On Windows PowerShell costs hundreds of
+ * milliseconds, so the snapshot is refreshed in the background and read from memory: the host's
+ * event loop never waits for it again (2026-10-12, one keychain read per request blocked the
+ * relay pings). Only the very first read waits, once, so the desktop registry is never empty
+ * when it is asked for (issue #70).
+ *
+ * The registry is read synchronously — Sessions.list, summary and isOpen all are — so the
+ * snapshot cannot be awaited everywhere without making the whole session list asynchronous.
+ * One bounded wait at startup is the price; every later read is a map lookup.
+ */
+export class ProcessSnapshot {
+    processes = [];
+    at = 0;
+    read = false;
+    pending = null;
+    failed = false;
+    platform;
+    ttlMs;
+    now;
+    run;
+    runAsync;
+    onError;
+    constructor(options = {}) {
+        this.platform = options.platform ?? process.platform;
+        this.ttlMs = options.ttlMs ?? 5000;
+        this.now = options.now ?? Date.now;
+        this.run = options.exec ?? exec;
+        this.runAsync = options.execAsync ?? execAsync;
+        this.onError = options.onError ?? (error => console.error("[process snapshot]", error instanceof Error ? error.message : String(error)));
+    }
+    /** The processes known now; on Windows this is what the last read found. */
+    current() {
+        if (this.platform !== "win32")
+            return listProcesses(this.platform, this.run);
+        if (!this.read) {
+            // The first read is the one the host cannot do without: it waits, once.
+            this.read = true;
+            try {
+                this.processes = listProcesses(this.platform, this.run);
+                this.at = this.now();
+                this.failed = false;
+            }
+            catch {
+                this.refresh();
+            }
+            return this.processes;
+        }
+        if (this.now() - this.at >= this.ttlMs)
+            this.refresh();
+        return this.processes;
+    }
+    /** Reads a new snapshot in the background; the current one is served until it lands. */
+    refresh() {
+        if (this.pending)
+            return;
+        this.pending = listProcessesAsync(this.platform, this.runAsync).then(processes => {
+            this.processes = processes;
+            this.at = this.now();
+            this.failed = false;
+        }).catch(error => {
+            // The snapshot stays as it was; a run of failures is reported once, not every read.
+            if (!this.failed) {
+                this.failed = true;
+                this.onError(error);
+            }
+        }).finally(() => { this.pending = null; });
+    }
+}
+/** The snapshot the host reads. One per process, so every reader sees the same processes. */
+export const processSnapshot = new ProcessSnapshot();
+export function processCommands() { return processSnapshot.current().map(p => `${p.pid} ${p.command}`).join("\n"); }

package/dist/router/src/version.js

@@ -5,4 +5,4 @@
 // from the manifests. Until 0.1.1 the router and the CLI each carried their own literal, and both
 // still said "0.1.0" in the 0.1.1 release: after an update nobody could tell which router was
 // running, and the tray app had nothing to compare (2026-09-15, reported from a Windows install).
-export const VERSION = "0.12.3";
+export const VERSION = "0.12.5";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clauderipple",
-  "version": "0.12.3",
+  "version": "0.12.5",
   "description": "Use GPT (any ChatGPT plan with Codex), DeepSeek and 400+ other models in the Claude Desktop Code tab and Claude Code while staying signed in to your Claude subscription — no third-party gateway mode. Several ChatGPT accounts that take over when one runs out, in Codex too.",
   "license": "GPL-3.0-only",
   "workspaces": [