parawatch 0.3.14 → 0.3.16

package/README.md

@@ -46,6 +46,8 @@ parawatch sync setup ~/agent-sync/parawatch --device pc  --adapter syncthing
 
 Cards, answers and the list of running sessions then show on every machine, each marked with where it came from. Agent logs stay on the machine that wrote them. The details are in [More than one machine](docs/sync.md).
 
+Or run a [relay](docs/relay.md) of your own, a small server that carries the folder sealed end to end, so the server cannot read your cards or sessions: `parawatch relay setup <url> <folder>` on the first machine, `parawatch relay join <code> <folder>` on the others.
+
 ## How an answer gets back
 
 <picture>
@@ -133,6 +135,8 @@ This writes a short block that tells the agents in that project to say what they
 | [Pull requests](docs/pull-requests.md) | What is read from GitHub, and its settings |
 | [Observed agents](docs/observed-agents.md) | Which logs are read, run states, adding a runtime |
 | [More than one machine](docs/sync.md) | Cards and answers across machines through a synced folder |
+| [The relay](docs/relay.md) | Your own server that carries the shared folder, sealed end to end |
+| [The shared folder](docs/protocol.md) | The files machines exchange, for anyone writing a client |
 | [Storage](docs/storage.md) | Where everything is kept, notifications |
 | [Installing, updating, removing](docs/install.md) | The three parts in detail, updates, `parawatch doctor`, uninstalling |
 | [Building on it](docs/integrations.md) | `status --json`, `watch`, the panel package |

package/dist/bin/cli.js

@@ -7,10 +7,12 @@ import { githubConfig, readCache, resolvePrRef, syncGithub, prViews } from "../c
 import { recordPrompt } from "../core/prompts.js";
 import { callingSubagent } from "../adapters/claudeCode.js";
 import { digest, digestText, localDate } from "../core/digest.js";
-import { everywhere, readEvents } from "../core/store.js";
+import { everywhere, readConfig, readEvents, sharedDir, writeConfig } from "../core/store.js";
 import { followEvents } from "../core/follow.js";
 import { adapterNames, setRoot, setupSync, syncAdapter, syncStatus, touchDevice } from "../core/sync.js";
 import { syncText } from "../core/format.js";
+import { RelayClient, RelayMirror, joinCode, newKey, readJoinCode, relayConfig, takeMirrorLock } from "../core/relay.js";
+import { createRelayServer } from "../relay/server.js";
 import { collectRuns, shareRunsDue } from "../core/runs.js";
 import { askRows, cardDetail, cardLine, cardRows, inboxLine, prRows, runsTree, view } from "../core/format.js";
 import { hookContext, notify, removeInstructions, writeInstructions } from "../core/integrate.js";
@@ -148,7 +150,8 @@ program
     .option("--copy", "also put a line about the card on the clipboard, to paste into that session")
     .option("--print", "print the link instead of opening it")
     .action((target, o) => {
-    const g = resolveGoto(target, readState());
+    const state = readState();
+    const g = resolveGoto(target, state, collectRuns(state, { sinceHours: 24, includeEnded: true }));
     if (o.copy && g.card) {
         const line = cardContextLine(g.card);
         try {
@@ -158,13 +161,19 @@ program
             process.stderr.write(`parawatch: could not copy to the clipboard; the line is: ${line}\n`);
         }
     }
+    if (!g.url && g.device)
+        throw new UserError(`${g.name} runs on ${g.device}. Open it there, or turn on Remote Control for it in the Claude app to open it from here.`);
     if (!g.url)
         throw new UserError(`${g.name} is not a Claude desktop session. In a terminal: claude --resume ${g.session}`);
     if (o.print) {
         process.stdout.write(g.url + "\n");
         return;
     }
-    execFileSync("open", [g.url]);
+    // cmd start would cut the link at its &
+    if (process.platform === "win32")
+        execFileSync("rundll32", ["url.dll,FileProtocolHandler", g.url]);
+    else
+        execFileSync(process.platform === "darwin" ? "open" : "xdg-open", [g.url]);
     process.stdout.write(`Opened ${g.name}${g.desktop?.archived ? " (archived)" : ""}\n`);
 });
 program
@@ -641,6 +650,103 @@ sync
     const d = setRoot(name, folder, VERSION);
     process.stdout.write(Object.entries(d.roots ?? {}).map(([k, v]) => `${k}  ${v}`).join("\n") + (d.roots ? "\n" : "No named folders.\n"));
 });
+// ------------------------------------------------------------------ the relay
+const relay = program.command("relay").description("keep the shared folder in step through a parawatch relay server instead of a sync tool");
+/** Point this machine's shared folder at a relay, keeping what config.json already has. */
+function useRelay(folder, device, c) {
+    const r = setupSync({ dir: folder, device, adapter: "relay", version: VERSION });
+    const cfg = readConfig();
+    writeConfig({ ...cfg, sync: { ...(cfg.sync ?? {}), adapter: "relay", relay: c } });
+    return r;
+}
+relay
+    .command("setup <url> <folder>")
+    .description("make a space on a relay and share this machine's folder through it; prints the code for your other machines")
+    .option("-d, --device <name>", "this machine's name in the folder (a-z, 0-9, -); defaults to the host name")
+    .option("--invite <invite>", "the relay's invite (or set PARAWATCH_RELAY_INVITE)")
+    .action(async (url, folder, o) => {
+    const invite = o.invite ?? process.env.PARAWATCH_RELAY_INVITE;
+    if (!invite)
+        throw new UserError("the relay needs its invite to make a space: pass --invite or set PARAWATCH_RELAY_INVITE");
+    const base = url.replace(/\/+$/, "");
+    const made = await RelayClient.createSpace(base, invite);
+    const c = { url: base, space: made.space, token: made.token, key: newKey() };
+    const r = useRelay(folder, o.device, c);
+    process.stdout.write([
+        `This machine shares ${r.dir} as "${r.device}" through ${base}.`,
+        "On each of your other machines, run:",
+        "",
+        `  parawatch relay join <code> <folder> --device <its name>`,
+        "",
+        "with this code. It opens your space and its key: keep it to your own machines.",
+        "",
+        joinCode(c),
+        "",
+        "The folder is kept in step while the app runs, or while `parawatch relay run` does.",
+    ].join("\n") + "\n");
+});
+relay
+    .command("join <code> <folder>")
+    .description("share this machine's folder through the relay another machine set up")
+    .option("-d, --device <name>", "this machine's name in the folder (a-z, 0-9, -); defaults to the host name")
+    .action(async (code, folder, o) => {
+    const c = readJoinCode(code);
+    await new RelayClient(c).changes(0);
+    const r = useRelay(folder, o.device, c);
+    process.stdout.write(`This machine shares ${r.dir} as "${r.device}" through ${c.url}. The folder is kept in step while the app runs, or while \`parawatch relay run\` does.\n`);
+});
+relay
+    .command("code")
+    .description("print the code that lets another of your machines join (it holds the space key)")
+    .action(() => {
+    const c = relayConfig();
+    if (!c)
+        throw new UserError("this machine does not use a relay");
+    process.stdout.write(joinCode(c) + "\n");
+});
+relay
+    .command("run")
+    .description("keep the shared folder in step with the relay until stopped (the app does this while it runs)")
+    .option("--once", "bring it up to date once and stop")
+    .action(async (o) => {
+    const c = relayConfig();
+    const dir = sharedDir();
+    if (!c || !dir)
+        throw new UserError("this machine does not use a relay: run `parawatch relay setup` or `parawatch relay join` first");
+    const unlock = takeMirrorLock();
+    if (!unlock)
+        throw new UserError("another parawatch (the app, or another `relay run`) already keeps this folder in step");
+    const m = new RelayMirror({ dir, config: c, log: (l) => process.stderr.write(l + "\n") });
+    try {
+        if (o.once) {
+            const r = await m.once();
+            process.stdout.write(`brought down ${r.pulled}, sent up ${r.pushed}\n`);
+            return;
+        }
+        const stop = () => m.stop();
+        process.once("SIGINT", stop);
+        process.once("SIGTERM", stop);
+        process.stderr.write(`keeping ${dir} in step with ${c.url}; stop with Ctrl-C\n`);
+        await m.run();
+    }
+    finally {
+        unlock();
+    }
+});
+relay
+    .command("serve")
+    .description("run a relay server (for your own server; machines reach it over HTTPS through a proxy in front)")
+    .option("--port <n>", "port to listen on", "8787")
+    .option("--host <host>", "address to listen on", "127.0.0.1")
+    .option("--data <folder>", "where spaces are kept", "~/.parawatch-relay")
+    .action((o) => {
+    const invite = process.env.PARAWATCH_RELAY_INVITE;
+    const data = o.data.startsWith("~") ? o.data.replace(/^~/, process.env.HOME ?? process.env.USERPROFILE ?? "") : o.data;
+    const server = createRelayServer({ dataDir: data, invite, log: (l) => process.stdout.write(`${new Date().toISOString()} ${l}\n`) });
+    server.listen(Number(o.port), o.host, () => {
+        process.stdout.write(`relay on http://${o.host}:${o.port}, spaces in ${data}${invite ? "" : " (no PARAWATCH_RELAY_INVITE: no new spaces can be made)"}\n`);
+    });
+});
 program
     .command("hook <runtime>")
     .description("hook entry point; 'claude-code' reads the hook JSON on stdin")

package/dist/core/chatTypes.js

@@ -0,0 +1,3 @@
+/** A Codex conversation as the app shows it. Types only, so the panel can share them. */
+export {};
+//# sourceMappingURL=chatTypes.js.map

package/dist/core/codexChat.js

@@ -0,0 +1,314 @@
+/**
+ * A Codex session as a conversation: read from its rollout log (what `codex exec` and the Codex
+ * app write under ~/.codex/sessions), and continued with `codex exec resume`, under the same
+ * sandbox and model the session last ran with.
+ */
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { isObj, readHeadLines, readTailLines, str } from "../adapters/jsonl.js";
+const OUTPUT_CHARS = 6000;
+const DIFF_CHARS = 12000;
+const MAX_ITEMS = 400;
+// a log with inline images can be hundreds of MB; the conversation is in its last part
+const TAIL_BYTES = 48 * 1024 * 1024;
+const HEAD_BYTES = 256 * 1024;
+const clip = (s, max) => (s.length > max ? `…${s.slice(s.length - max)}` : s);
+const clipHead = (s, max) => (s.length > max ? `${s.slice(0, max)}\n…` : s);
+const fileUrl = (p) => (p.startsWith("file://") ? decodeURIComponent(p.slice(7)) : p);
+function texts(content) {
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .filter(isObj)
+        .map((b) => str(b.text) ?? "")
+        .filter(Boolean)
+        .join("\n")
+        .trim();
+}
+function commandLine(cmd) {
+    if (typeof cmd === "string")
+        return cmd;
+    if (!Array.isArray(cmd))
+        return "";
+    const parts = cmd.map(String);
+    // ["/bin/zsh", "-lc", "<the command>"]: show the command
+    if (parts.length === 3 && /^-[a-z]*c$/.test(parts[1]))
+        return parts[2];
+    return parts.join(" ");
+}
+/** One item of the log's `item_completed` events, as the conversation shows it. */
+export function chatItem(it, at) {
+    const id = str(it.id) ?? `${str(it.type)}-${at}`;
+    switch (it.type) {
+        case "UserMessage": {
+            const content = Array.isArray(it.content) ? it.content.filter(isObj) : [];
+            const images = content.filter((b) => /image/i.test(str(b.type) ?? "")).length;
+            const text = texts(content);
+            if (!text && !images)
+                return undefined;
+            return { kind: "user", id, text, ...(images ? { images } : {}), at };
+        }
+        case "AgentMessage": {
+            const text = texts(it.content);
+            if (!text)
+                return undefined;
+            return { kind: "agent", id, text, ...(it.phase === "commentary" ? { commentary: true } : {}), at };
+        }
+        case "CommandExecution": {
+            const output = str(it.aggregated_output) ?? [str(it.stdout), str(it.stderr)].filter(Boolean).join("\n");
+            const d = isObj(it.duration) ? Number(it.duration.secs ?? 0) + Number(it.duration.nanos ?? 0) / 1e9 : undefined;
+            return {
+                kind: "command",
+                id,
+                command: commandLine(it.command),
+                ...(output ? { output: clip(output.trimEnd(), OUTPUT_CHARS) } : {}),
+                ...(typeof it.exit_code === "number" ? { exit: it.exit_code } : {}),
+                status: str(it.status),
+                ...(d !== undefined && Number.isFinite(d) ? { seconds: Math.round(d * 10) / 10 } : {}),
+                at,
+            };
+        }
+        case "FileChange": {
+            const changes = isObj(it.changes) ? it.changes : {};
+            const files = Object.entries(changes).map(([p, c]) => {
+                const ch = isObj(c) ? c : {};
+                const diff = str(ch.unified_diff);
+                return { path: p, change: str(ch.type) ?? "update", ...(diff ? { diff: clipHead(diff, DIFF_CHARS) } : {}) };
+            });
+            return files.length ? { kind: "files", id, files, at } : undefined;
+        }
+        case "McpToolCall": {
+            const name = [str(it.appName) ?? str(it.server), str(it.actionName) ?? str(it.tool)].filter(Boolean).join(" ");
+            let detail;
+            try {
+                detail = it.arguments === undefined ? undefined : JSON.stringify(it.arguments);
+            }
+            catch {
+                detail = undefined;
+            }
+            return { kind: "tool", id, name: name || "tool", ...(detail ? { detail: clipHead(detail, 400) } : {}), status: str(it.status), at };
+        }
+        case "ImageView": {
+            const p = str(it.path);
+            return p ? { kind: "image", id, path: fileUrl(p), at } : undefined;
+        }
+        case "ContextCompaction":
+            return { kind: "note", id, text: "Earlier conversation compacted", tone: "info", at };
+        case "Reasoning":
+        case "Extension":
+            return undefined;
+        default:
+            return typeof it.type === "string" ? { kind: "tool", id, name: it.type, at } : undefined;
+    }
+}
+function sandboxOf(tc, cwd) {
+    const sp = isObj(tc.sandbox_policy) ? tc.sandbox_policy : undefined;
+    const sandbox = typeof tc.sandbox_policy === "string" ? tc.sandbox_policy : str(sp?.type);
+    const network = typeof sp?.network_access === "boolean" ? sp.network_access : undefined;
+    const roots = new Set();
+    for (const r of Array.isArray(sp?.writable_roots) ? sp.writable_roots : [])
+        if (typeof r === "string")
+            roots.add(r);
+    const fsp = isObj(tc.file_system_sandbox_policy) ? tc.file_system_sandbox_policy : undefined;
+    for (const e of Array.isArray(fsp?.entries) ? fsp.entries.filter(isObj) : []) {
+        const p = isObj(e.path) && e.path.type === "path" ? str(e.path.path) : undefined;
+        if (p && e.access === "write")
+            roots.add(p);
+    }
+    if (cwd)
+        roots.delete(cwd);
+    return { sandbox, ...(network !== undefined ? { network } : {}), roots: [...roots] };
+}
+/** The conversation in a rollout log's lines. */
+export function readChatLines(head, tail, file = "") {
+    const meta = head.find((r) => isObj(r) && r.type === "session_meta");
+    const m = isObj(meta?.payload) ? meta.payload : {};
+    const id = str(m.id) ?? str(m.session_id) ?? path.basename(file);
+    const source = str(m.source);
+    const origin = str(m.originator) === "codex_exec" || source === "exec" ? "exec" : source === "vscode" ? "app" : source;
+    const settings = { cwd: str(m.cwd), roots: [] };
+    const items = new Map();
+    let started = -1;
+    let ended = -1;
+    let turnAt;
+    let structured = false;
+    const fallback = [];
+    tail.forEach((r, i) => {
+        if (!isObj(r) || !isObj(r.payload))
+            return;
+        const p = r.payload;
+        const at = str(r.timestamp);
+        if (r.type === "turn_context") {
+            settings.cwd = str(p.cwd) ?? settings.cwd;
+            settings.model = str(p.model) ?? settings.model;
+            settings.effort = str(p.effort) ?? (isObj(p.collaboration_mode) && isObj(p.collaboration_mode.settings) ? str(p.collaboration_mode.settings.reasoning_effort) : undefined) ?? settings.effort;
+            settings.approval = str(p.approval_policy) ?? settings.approval;
+            Object.assign(settings, sandboxOf(p, settings.cwd));
+            return;
+        }
+        if (r.type === "event_msg") {
+            if (p.type === "task_started") {
+                started = i;
+                turnAt = at;
+            }
+            else if (p.type === "task_complete")
+                ended = i;
+            else if (p.type === "turn_aborted") {
+                ended = i;
+                items.set(`aborted-${i}`, { kind: "note", id: `aborted-${i}`, text: "Stopped", tone: "info", at });
+            }
+            else if (p.type === "error") {
+                items.set(`error-${i}`, { kind: "note", id: `error-${i}`, text: str(p.message) ?? "Codex reported an error", tone: "error", at });
+            }
+            else if (p.type === "item_completed" && isObj(p.item)) {
+                structured = true;
+                const item = chatItem(p.item, at);
+                if (item) {
+                    items.delete(item.id); // a repeat moves to where it was seen last
+                    items.set(item.id, item);
+                }
+            }
+            return;
+        }
+        // logs from versions without item events: messages only
+        if (r.type === "response_item" && p.type === "message" && (p.role === "user" || p.role === "assistant")) {
+            const text = texts(p.content);
+            if (!text || (p.role === "user" && (text.startsWith("<") || text.startsWith("# AGENTS.md"))))
+                return;
+            fallback.push(p.role === "user" ? { kind: "user", id: `m${i}`, text, at } : { kind: "agent", id: `m${i}`, text, at });
+        }
+    });
+    const all = structured ? [...items.values()] : [...fallback, ...[...items.values()].filter((x) => x.kind === "note")];
+    const firstUser = all.find((x) => x.kind === "user");
+    return {
+        id,
+        file,
+        ...(origin ? { origin } : {}),
+        ...(firstUser ? { title: firstUser.text.split("\n")[0].slice(0, 80) } : {}),
+        settings,
+        working: started > ended,
+        ...(started > ended && turnAt ? { turnStarted: turnAt } : {}),
+        items: all.slice(-MAX_ITEMS),
+        earlier: Math.max(0, all.length - MAX_ITEMS),
+    };
+}
+export function readChat(file) {
+    return readChatLines(readHeadLines(file, HEAD_BYTES), readTailLines(file, TAIL_BYTES), file);
+}
+const toml = (s) => JSON.stringify(s);
+/**
+ * The arguments for `codex` to send one message to the session, read from stdin, with the
+ * sandbox, folders and model it last ran with. `codex exec resume` takes no sandbox flags and
+ * would otherwise fall back to the user's config, which may allow more than the session had.
+ */
+export function resumeArgs(id, s) {
+    const sandbox = s.sandbox;
+    if (sandbox !== "read-only" && sandbox !== "workspace-write" && sandbox !== "danger-full-access") {
+        throw new Error(`this session ran with a sandbox parawatch does not know (${sandbox ?? "none recorded"}); continue it in Codex`);
+    }
+    const args = ["exec", "resume", "--json", "--skip-git-repo-check"];
+    args.push("-c", `sandbox_mode=${toml(sandbox)}`);
+    // a message sent from here has no one to ask, so it never waits for an approval
+    args.push("-c", `approval_policy="never"`);
+    if (sandbox === "workspace-write") {
+        if (s.network !== undefined)
+            args.push("-c", `sandbox_workspace_write.network_access=${s.network}`);
+        if (s.roots.length)
+            args.push("-c", `sandbox_workspace_write.writable_roots=[${s.roots.map(toml).join(",")}]`);
+    }
+    if (s.model)
+        args.push("-m", s.model);
+    if (s.effort)
+        args.push("-c", `model_reasoning_effort=${toml(s.effort)}`);
+    args.push(id, "-");
+    return args;
+}
+/** Where the codex command is. An app started from the Dock does not get the shell's PATH. */
+export function findCodex(env = process.env, platform = process.platform) {
+    if (env.PARAWATCH_CODEX_BIN)
+        return env.PARAWATCH_CODEX_BIN;
+    const names = platform === "win32" ? ["codex.cmd", "codex.exe", "codex"] : ["codex"];
+    const home = os.homedir();
+    const dirs = [
+        ...(env.PATH ?? "").split(path.delimiter),
+        ...(platform === "win32"
+            ? [env.APPDATA && path.join(env.APPDATA, "npm"), env.LOCALAPPDATA && path.join(env.LOCALAPPDATA, "Programs", "OpenAI", "Codex", "bin"), env.LOCALAPPDATA && path.join(env.LOCALAPPDATA, "Programs", "codex")]
+            : ["/opt/homebrew/bin", "/usr/local/bin", path.join(home, ".local", "bin"), path.join(home, ".npm-global", "bin"), path.join(home, ".volta", "bin"), path.join(home, ".bun", "bin")]),
+    ].filter((d) => !!d);
+    for (const d of dirs) {
+        for (const n of names) {
+            const p = path.join(d, n);
+            try {
+                if (fs.statSync(p).isFile())
+                    return p;
+            }
+            catch {
+                // not here
+            }
+        }
+    }
+    if (platform === "win32")
+        return undefined;
+    try {
+        const shell = env.SHELL || "/bin/zsh";
+        const out = execFileSync(shell, ["-lc", "command -v codex"], { encoding: "utf8", timeout: 5000 }).trim().split("\n").pop();
+        return out && path.isAbsolute(out) ? out : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Processes that have the log open: a Codex app or terminal that has the session loaded. Unknown on Windows. */
+export function logOpenBy(file, platform = process.platform) {
+    if (platform === "win32")
+        return undefined;
+    try {
+        const out = execFileSync("lsof", ["-t", "--", file], { encoding: "utf8", timeout: 3000, stdio: ["ignore", "pipe", "ignore"] });
+        return out
+            .split("\n")
+            .map((l) => Number(l.trim()))
+            .filter((n) => n > 0);
+    }
+    catch (err) {
+        // lsof exits 1 when no process has it open
+        return err.status === 1 ? [] : undefined;
+    }
+}
+/** Why a message cannot be sent now, or undefined when it can. */
+export function cannotSend(view, openBy, mine = []) {
+    if (view.working)
+        return "Codex is working on this session. Wait until it finishes.";
+    if (openBy?.some((p) => !mine.includes(p)))
+        return "This session is open in Codex (the app or a terminal). Continue it there, or close it there first.";
+    const s = view.settings.sandbox;
+    if (s !== "read-only" && s !== "workspace-write" && s !== "danger-full-access")
+        return `This session ran with a sandbox parawatch does not know (${s ?? "none recorded"}). Continue it in Codex.`;
+    return undefined;
+}
+/** A line of `codex exec --json` that says what Codex is doing now, if it is one. */
+export function liveLine(line) {
+    let e;
+    try {
+        e = JSON.parse(line);
+    }
+    catch {
+        return undefined;
+    }
+    if (!isObj(e) || e.type !== "item.started" || !isObj(e.item))
+        return undefined;
+    const it = e.item;
+    if (it.type === "command_execution")
+        return `Running ${commandLine(it.command)}`.slice(0, 200);
+    if (it.type === "file_change")
+        return "Editing files";
+    if (it.type === "mcp_tool_call")
+        return `Using ${[str(it.server), str(it.tool)].filter(Boolean).join(" ")}`;
+    if (it.type === "web_search")
+        return "Searching the web";
+    if (it.type === "reasoning")
+        return "Thinking";
+    return undefined;
+}
+//# sourceMappingURL=codexChat.js.map

package/dist/core/desktop.js

@@ -6,11 +6,33 @@ import { UserError } from "./errors.js";
 import { sessionTitle } from "./state.js";
 /**
  * Where the Claude desktop app keeps its Code sessions: one JSON file per session, named
- * `local_<id>.json`, holding the CLI session id the app runs (`cliSessionId`).
+ * `local_<id>.json`, holding the CLI session id the app runs (`cliSessionId`). On Windows the
+ * Store build keeps them under `%LOCALAPPDATA%\Claude-Data\claude_<package>`, the installer build
+ * under `%APPDATA%\Claude`.
  */
-export function desktopSessionsDir() {
-    return (process.env.PARAWATCH_CLAUDE_DESKTOP_DIR ||
-        path.join(os.homedir(), "Library", "Application Support", "Claude", "claude-code-sessions"));
+export function desktopSessionsDirs() {
+    const env = process.env.PARAWATCH_CLAUDE_DESKTOP_DIR;
+    if (env)
+        return [env];
+    const home = os.homedir();
+    if (process.platform === "win32") {
+        const roaming = process.env.APPDATA || path.join(home, "AppData", "Roaming");
+        const local = process.env.LOCALAPPDATA || path.join(home, "AppData", "Local");
+        const out = [path.join(roaming, "Claude", "claude-code-sessions")];
+        const data = path.join(local, "Claude-Data");
+        try {
+            for (const e of fs.readdirSync(data, { withFileTypes: true }))
+                if (e.isDirectory() && /^claude_/i.test(e.name))
+                    out.push(path.join(data, e.name, "claude-code-sessions"));
+        }
+        catch {
+            // no Store build here
+        }
+        return out;
+    }
+    if (process.platform === "darwin")
+        return [path.join(home, "Library", "Application Support", "Claude", "claude-code-sessions")];
+    return [path.join(process.env.XDG_CONFIG_HOME || path.join(home, ".config"), "Claude", "claude-code-sessions")];
 }
 function* sessionFiles(dir, depth = 0) {
     let entries;
@@ -31,9 +53,9 @@ function* sessionFiles(dir, depth = 0) {
 /** Session files read before, by path; a file is read again only when it changes. */
 const readCache = new Map();
 /** Every desktop app session in the folder, read once per change of its file. */
-function desktopSessions(dir) {
+function desktopSessions(dirs) {
     const out = [];
-    for (const file of sessionFiles(dir)) {
+    for (const file of [dirs].flat().flatMap((d) => [...sessionFiles(d)])) {
         let mtimeMs;
         try {
             mtimeMs = fs.statSync(file).mtimeMs;
@@ -70,10 +92,12 @@ function readSessionFile(file) {
         cwd: typeof d.cwd === "string" ? d.cwd : undefined,
         archived: d.isArchived === true,
         lastActivityAt: typeof d.lastActivityAt === "number" ? d.lastActivityAt : 0,
+        remote: Array.isArray(d.bridgeSessionIds) ? d.bridgeSessionIds.find((x) => typeof x === "string" && REMOTE_ID.test(x)) : undefined,
     };
 }
 /** The desktop app session running a CLI session (full id or a prefix of 6+ characters). */
-export function findDesktopSession(cliSession, dir = desktopSessionsDir()) {
+const REMOTE_ID = /^session_[A-Za-z0-9]+$/;
+export function findDesktopSession(cliSession, dir = desktopSessionsDirs()) {
     if (cliSession.length < 6)
         return undefined;
     let best;
@@ -91,7 +115,7 @@ export function findDesktopSession(cliSession, dir = desktopSessionsDir()) {
  * (full or a prefix of 6+ characters). Such a session never takes another turn, however its log
  * ends. A CLI session that a live desktop session also runs is not archived.
  */
-export function archivedSessions(dir = desktopSessionsDir()) {
+export function archivedSessions(dir = desktopSessionsDirs()) {
     const archived = new Set();
     const live = new Set();
     for (const s of desktopSessions(dir))
@@ -112,6 +136,27 @@ export function archivedSessions(dir = desktopSessionsDir()) {
 export function desktopSessionUrl(s) {
     return `claude://code/continue?session=${encodeURIComponent(s.id)}&source=parawatch`;
 }
+/** A Remote Control session on claude.ai, which opens from any machine signed in to the account. */
+export function remoteSessionUrl(id) {
+    return `https://claude.ai/code/${encodeURIComponent(id)}`;
+}
+/** Give each Claude Code session of this machine its Remote Control link, when it has one. */
+export function withRemote(runs, dir = desktopSessionsDirs()) {
+    const sessions = runs.filter((r) => r.runtime === "claude-code" && r.kind === "session" && !r.device);
+    if (!sessions.length)
+        return runs;
+    const remote = new Map();
+    for (const s of desktopSessions(dir))
+        if (s.remote && !s.archived)
+            for (const id of s.ids)
+                remote.set(id, s.remote);
+    for (const r of sessions) {
+        const id = remote.get(r.id);
+        if (id)
+            r.remote = remoteSessionUrl(id);
+    }
+    return runs;
+}
 /** The session that owns a pull request: by URL, `owner/repo#N`, or `#N` / `repo#N` when only one matches. */
 function prSession(target, state) {
     const ref = parsePrRef(target);
@@ -136,15 +181,23 @@ function prSession(target, state) {
     return hits[0].session;
 }
 /** Where `goto` leads for a card id, a pull request, or a session id (prefix). */
-export function resolveGoto(target, state) {
+export function resolveGoto(target, state, runs = []) {
     const card = state.cards.get(target);
-    const session = card ? card.session : (prSession(target, state) ?? target);
+    let session = card ? card.session : (prSession(target, state) ?? target);
     if (!session) {
         throw new UserError(`card ${target} does not say which session opened it (set one with: parawatch edit ${target} --session <id>)`);
     }
-    const desktop = findDesktopSession(session);
-    const name = sessionTitle(state.claims, session) ?? desktop?.title ?? session.slice(0, 8);
-    return { name, session, card, desktop, url: desktop ? desktopSessionUrl(desktop) : undefined };
+    // a subagent has no window of its own: open the session it works under
+    const byId = new Map(runs.map((r) => [r.id, r]));
+    let run = runs.find((r) => r.id === session || (session.length >= 6 && r.id.startsWith(session)));
+    for (let i = 0; run?.parent && byId.has(run.parent) && i < 8; i++)
+        run = byId.get(run.parent);
+    if (run)
+        session = run.id;
+    const desktop = run?.device ? undefined : findDesktopSession(session);
+    const name = sessionTitle(state.claims, session) ?? run?.title ?? desktop?.title ?? session.slice(0, 8);
+    const url = desktop ? desktopSessionUrl(desktop) : run?.remote;
+    return { name, session, card, desktop, device: run?.device, url };
 }
 /** A line to paste into the session so it knows which card the human means. */
 export function cardContextLine(card) {