@linkshell/host 0.1.0 → 0.1.2

package/dist/host/src/drivers/claude/driver.js

@@ -1,15 +1,60 @@
 import { execFile } from "node:child_process";
-import { accessSync, constants, statSync } from "node:fs";
+import { accessSync, constants, existsSync, mkdirSync, renameSync, rmSync, statSync } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { createRequire } from "node:module";
 import { delimiter, isAbsolute, join } from "node:path";
 import { promisify } from "node:util";
 import { RpcError } from "@linkshell/wire";
-import { AcpDriver } from "../acp/driver.js";
+import { AcpDriver, inOrder } from "../acp/driver.js";
 import { AcpItemTracker, toConfigOptions, toHistory } from "../acp/mapper.js";
 import { parseClaudeAuthStatus, runStatusCommand } from "../auth.js";
-import { claudeConfigDir, findTranscript, readTranscript, transcriptLine, transcriptTimes, TranscriptTail } from "./transcript.js";
+import { descendsFrom, sessionHolders } from "./holders.js";
+import { claudeConfigDir, encodeProjectDir, findTranscript, turnEndUuid, mergeSettings, readTail, readTranscript, settingsOf, transcriptLine, transcriptTimes, TranscriptTail, } from "./transcript.js";
 const execFileAsync = promisify(execFile);
+/** How the adapter's Claude marks the transcript lines it writes. */
+const REMOTE_ENTRYPOINT = '"entrypoint":"sdk-ts"';
+/** A message in the transcript that some other Claude (the desktop app, a terminal) wrote. */
+function writtenByAnotherClaude(line) {
+    return line.includes('"entrypoint":"') && !line.includes(REMOTE_ENTRYPOINT) && /"type":"(user|assistant)"/.test(line);
+}
+/**
+ * Whether another Claude is in the middle of a turn, going by the transcript's
+ * last message: a prompt or a tool result with no final reply after it. A turn
+ * that has written nothing for `stalledMs` no longer counts (it waits on its
+ * own approval prompt, or that Claude is gone).
+ */
+function turnInProgress(path, stalledMs) {
+    const { size, mtimeMs } = statSync(path);
+    if (Date.now() - mtimeMs > stalledMs)
+        return false;
+    // Lines can be megabytes (a screenshot in a tool result): widen the look until one is whole.
+    for (const bytes of [512 * 1024, 8 * 1024 * 1024, size]) {
+        const tail = readTail(path, Math.min(size, bytes));
+        const lines = (bytes >= size ? tail : tail.slice(tail.indexOf("\n") + 1)).split("\n");
+        for (let i = lines.length - 1; i >= 0; i--) {
+            const line = lines[i];
+            if (!/"type":"(user|assistant)"/.test(line))
+                continue;
+            let entry;
+            try {
+                entry = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (entry.isSidechain || (entry.type !== "user" && entry.type !== "assistant"))
+                continue;
+            if (line.includes(REMOTE_ENTRYPOINT))
+                return false;
+            if (entry.type === "assistant")
+                return entry.message?.stop_reason == null || entry.message.stop_reason === "tool_use";
+            return !JSON.stringify(entry.message?.content ?? "").includes("[Request interrupted");
+        }
+        if (bytes >= size)
+            break;
+    }
+    return false;
+}
 /** Finds an executable on the given PATH (the adapter needs an absolute path). */
 export function resolveExecutable(name, env) {
     if (isAbsolute(name))
@@ -53,9 +98,26 @@ function driverOf(mode) {
 export class ClaudeDriver extends AcpDriver {
     modes = new Map();
     tails = new Map();
+    /**
+     * The settings Claude offers (model, effort, permission mode…), as the
+     * adapter reported them for any session: what a desktop-driven session
+     * shows before the phone has it open over ACP.
+     */
+    template;
+    templateLoading;
+    /** Desktop-driven sessions: the model of the latest reply, from the transcript. */
+    /** Per session: the settings its transcript shows it running with (what the Claude on the computer is set to). */
+    observed = new Map();
+    /** Per session: TodoWrite calls shown as the plan, whose results the tail skips. */
+    hiddenTools = new Map();
+    /** Per session: calls that started an agent in the background and haven't heard back (see transcriptLine). */
+    backgroundAgents = new Map();
+    /** Ids of the transcript lines read lately: Claude writes some again after compacting. */
+    seenLines = new Map();
     claudeCommand;
     configDir;
     busyWindowMs;
+    holderCheckMs;
     claudePath;
     constructor(options) {
         const env = options.env ?? process.env;
@@ -79,11 +141,16 @@ export class ClaudeDriver extends AcpDriver {
         this.claudeCommand = claudeCommand;
         this.claudePath = claudePath;
         this.configDir = claudeConfigDir(env);
-        this.busyWindowMs = options.busyWindowMs ?? 60_000;
+        this.busyWindowMs = options.busyWindowMs ?? 10 * 60_000;
+        this.holderCheckMs = options.holderCheckMs ?? 3000;
         this.adapterMissing = adapterMissing;
         this.capabilities = { ...this.capabilities, models: true, modes: true };
     }
     adapterMissing;
+    /** Sent from a device while another Claude was mid-turn in the session; goes out when that turn ends. */
+    waiting = new Map();
+    /** Checks that sessions driven from a device haven't been reopened on the computer. */
+    remoteWatch;
     async start(host) {
         if (!this.adapterMissing)
             return super.start(host);
@@ -96,6 +163,8 @@ export class ClaudeDriver extends AcpDriver {
         return this.current;
     }
     async stop() {
+        clearInterval(this.remoteWatch);
+        this.remoteWatch = undefined;
         for (const tail of this.tails.values())
             tail.stop();
         this.tails.clear();
@@ -109,8 +178,23 @@ export class ClaudeDriver extends AcpDriver {
         if (path) {
             const transcript = readTranscript(path);
             state.tracker = new AcpItemTracker();
-            history = toHistory(transcript.updates, state.tracker, (update) => transcriptTimes.get(update));
+            // What is under way on the computer isn't history yet: a turn's start and
+            // the tool calls still running, and agents working in the background
+            // (which outlive the turn that started them). They go out as what is
+            // happening now (after the history; the hub holds them until then), so
+            // the session shows as working and results have a card to land on.
+            const underway = [];
+            history = toHistory(transcript.updates, state.tracker, (update) => transcriptTimes.get(update), underway);
+            const working = turnInProgress(path, this.busyWindowMs);
+            for (const update of underway) {
+                const call = update.parentToolCallId ?? update.toolCallId;
+                if (working || (call && transcript.agents.has(call)))
+                    this.host?.update(this.id, nativeId, update, undefined, transcriptTimes.get(update));
+            }
             offset = transcript.size;
+            this.backgroundAgents.set(nativeId, transcript.agents);
+            this.seenLines.set(nativeId, transcript.seen);
+            this.observed.set(nativeId, transcript.settings);
             if (transcript.title)
                 this.host?.update(this.id, nativeId, { sessionUpdate: "session_info_update", title: transcript.title });
         }
@@ -119,10 +203,65 @@ export class ClaudeDriver extends AcpDriver {
         this.host?.update(this.id, nativeId, { sessionUpdate: "ls_driver", driver: driverOf(mode) });
         if (mode === "remote")
             this.emitConfig(nativeId, state);
+        else
+            void this.loadTemplate(context.cwd).then(() => this.emitDesktopConfig(nativeId));
         return history;
     }
+    /**
+     * Claude's settings list without a session to ask: a throwaway session that
+     * never gets a message (Claude writes no transcript for it), closed at once.
+     */
+    loadTemplate(cwd) {
+        if (this.template)
+            return Promise.resolve(this.template);
+        this.templateLoading ??= (async () => {
+            try {
+                const response = await this.rpc("session/new", { cwd, mcpServers: [] });
+                const options = toConfigOptions(response);
+                if (options.length > 0)
+                    this.template ??= options;
+                if (typeof response.sessionId === "string" && this.connection?.capabilities.sessionCapabilities?.close) {
+                    void this.rpc("session/close", { sessionId: response.sessionId }).catch(() => { });
+                }
+                return this.template;
+            }
+            catch (error) {
+                this.host?.log(`[claude] couldn't read Claude's settings: ${error instanceof Error ? error.message : String(error)}`);
+                return undefined;
+            }
+            finally {
+                this.templateLoading = undefined;
+            }
+        })();
+        return this.templateLoading;
+    }
+    pendingConfig(nativeId) {
+        try {
+            return JSON.parse(this.host?.state(this.id, nativeId).get("pendingConfig") ?? "{}");
+        }
+        catch {
+            return {};
+        }
+    }
+    /** A desktop-driven session's settings: the template, its model, and choices waiting for the phone. */
+    emitDesktopConfig(nativeId) {
+        if (!this.template || this.modes.get(nativeId) === "remote")
+            return;
+        const pending = this.pendingConfig(nativeId);
+        const observed = this.observed.get(nativeId) ?? {};
+        const options = this.template.map(({ source: _source, ...option }) => {
+            const current = pending[option.id] ?? observedValue(option, observed);
+            return { ...option, current: current !== undefined && option.values.some((value) => value.value === current) ? current : option.current };
+        });
+        this.host?.update(this.id, nativeId, { sessionUpdate: "ls_config", options });
+    }
     async createSession(options) {
         const created = await super.createSession(options);
+        // A new session's settings are Claude's defaults: the freshest template.
+        // (Not a resumed or changed one's: those are that session's own.)
+        const config = this.sessions.get(created.nativeId)?.config;
+        if (config?.length)
+            this.template = config;
         // Born on a device: this host is the writer from the start.
         this.modes.set(created.nativeId, "remote");
         this.setWriter(created.nativeId, "remote");
@@ -138,20 +277,195 @@ export class ClaudeDriver extends AcpDriver {
         this.tails.delete(nativeId);
         await super.detach(nativeId);
     }
+    /**
+     * A copy of the session's transcript under a new id (the SDK's fork), all of
+     * it or through a turn. A fork that works somewhere else (a worktree) has
+     * its transcript moved to that directory's project folder, where Claude
+     * looks for the sessions of a directory.
+     */
+    async fork(nativeId, options) {
+        const source = findTranscript(this.configDir, nativeId, options.sourceCwd);
+        if (!source)
+            throw RpcError.app("not_ready", "这个 Claude 会话还没有任何消息，没有可分叉的内容");
+        const upToMessageId = options.upTo ? turnEndUuid(source, options.upTo.itemId, options.upTo.turn) : undefined;
+        if (options.upTo && !upToMessageId)
+            throw RpcError.app("not_found", "找不到要分叉的那一轮");
+        const { forkSession } = await import("@anthropic-ai/claude-agent-sdk");
+        const previous = process.env.CLAUDE_CONFIG_DIR;
+        process.env.CLAUDE_CONFIG_DIR = this.configDir;
+        let forked;
+        try {
+            forked = (await forkSession(nativeId, { dir: options.sourceCwd, upToMessageId })).sessionId;
+        }
+        finally {
+            if (previous === undefined)
+                delete process.env.CLAUDE_CONFIG_DIR;
+            else
+                process.env.CLAUDE_CONFIG_DIR = previous;
+        }
+        if (options.cwd !== options.sourceCwd) {
+            const made = findTranscript(this.configDir, forked, options.sourceCwd);
+            if (!made)
+                throw RpcError.app("not_found", "分叉出的会话没有写出来");
+            const folder = join(this.configDir, "projects", encodeProjectDir(options.cwd));
+            mkdirSync(folder, { recursive: true });
+            renameSync(made, join(folder, `${forked}.jsonl`));
+        }
+        const now = Date.now();
+        return { nativeId: forked, cwd: options.cwd, createdAt: now, updatedAt: now };
+    }
+    /** Claude's own title record (what /rename writes), so `claude --resume` shows it too. */
+    async rename(nativeId, title) {
+        const { renameSession } = await import("@anthropic-ai/claude-agent-sdk");
+        const previous = process.env.CLAUDE_CONFIG_DIR;
+        // The SDK finds transcripts through CLAUDE_CONFIG_DIR, as Claude does.
+        process.env.CLAUDE_CONFIG_DIR = this.configDir;
+        try {
+            await renameSession(nativeId, title);
+        }
+        finally {
+            if (previous === undefined)
+                delete process.env.CLAUDE_CONFIG_DIR;
+            else
+                process.env.CLAUDE_CONFIG_DIR = previous;
+        }
+    }
+    async delete(nativeId) {
+        const transcript = findTranscript(this.configDir, nativeId);
+        // No transcript (never messaged): Claude has nothing to delete.
+        if (transcript)
+            await super.delete(nativeId);
+        else
+            this.sessions.delete(nativeId);
+        this.modes.delete(nativeId);
+        this.hiddenTools.delete(nativeId);
+        this.backgroundAgents.delete(nativeId);
+        if (transcript)
+            sweepTranscript(transcript);
+    }
     async prompt(nativeId, content, clientMessageId) {
+        // Another Claude is in the middle of a turn here: the message waits for it to finish.
+        if (this.waiting.get(nativeId)?.length || (await this.elsewhere(nativeId))?.working) {
+            const waiting = this.waiting.get(nativeId) ?? [];
+            waiting.push({ content, clientMessageId });
+            this.waiting.set(nativeId, waiting);
+            this.reportWaiting(nativeId);
+            this.startWatch();
+            return "queued";
+        }
         // Sending from a device is taking the session over.
         await this.ensureRemote(nativeId);
         return super.prompt(nativeId, content, clientMessageId);
     }
+    unqueue(nativeId, clientMessageId) {
+        const waiting = this.waiting.get(nativeId);
+        const index = waiting?.findIndex((entry) => entry.clientMessageId === clientMessageId) ?? -1;
+        if (!waiting || index < 0)
+            return super.unqueue(nativeId, clientMessageId);
+        waiting.splice(index, 1);
+        if (waiting.length === 0)
+            this.waiting.delete(nativeId);
+        this.reportWaiting(nativeId);
+        return true;
+    }
+    reorderQueue(nativeId, clientMessageIds) {
+        const waiting = this.waiting.get(nativeId);
+        if (!waiting)
+            return super.reorderQueue(nativeId, clientMessageIds);
+        this.waiting.set(nativeId, inOrder(waiting, clientMessageIds));
+        this.reportWaiting(nativeId);
+    }
+    reportWaiting(nativeId) {
+        this.host?.queue(this.id, nativeId, (this.waiting.get(nativeId) ?? []).map((entry) => ({
+            clientMessageId: entry.clientMessageId,
+            text: entry.content.map((block) => (block.type === "text" ? block.text : "")).join("").trim(),
+            images: entry.content.filter((block) => block.type === "image").length,
+        })));
+    }
+    /** Sends what waited for another Claude's turn, now that it has ended. */
+    async sendWaiting(nativeId) {
+        const waiting = this.waiting.get(nativeId);
+        if (!waiting?.length || (await this.elsewhere(nativeId))?.working)
+            return;
+        this.waiting.delete(nativeId);
+        this.reportWaiting(nativeId);
+        try {
+            await this.ensureRemote(nativeId);
+            for (const entry of waiting)
+                await super.prompt(nativeId, entry.content, entry.clientMessageId);
+        }
+        catch (error) {
+            this.emit(nativeId, {
+                sessionUpdate: "ls_error",
+                code: error instanceof RpcError ? (error.appCode ?? "send_failed") : "send_failed",
+                message: `排队的消息没能发出：${error instanceof Error ? error.message : String(error)}`,
+            });
+        }
+    }
     async cancel(nativeId) {
-        if (this.modes.get(nativeId) !== "remote") {
-            throw RpcError.app("not_supported", "Claude 正在电脑上运行：先接管，再停止");
+        if (this.modes.get(nativeId) === "remote")
+            return super.cancel(nativeId);
+        // Stopping stops what's waiting too; the apps put queued text back in the composer.
+        if (this.waiting.delete(nativeId))
+            this.reportWaiting(nativeId);
+        // The turn runs in a Claude on the computer. A `linkshell claude` terminal
+        // steps aside (which ends its turn); any other Claude is interrupted.
+        if (this.host?.desktop(this.id, nativeId))
+            await this.ensureRemote(nativeId);
+        else
+            await this.interruptElsewhere(nativeId);
+    }
+    async sendQueuedNow(nativeId) {
+        if (!this.waiting.get(nativeId)?.length)
+            return super.sendQueuedNow(nativeId);
+        await this.interruptElsewhere(nativeId);
+        await this.sendWaiting(nativeId);
+    }
+    /**
+     * Stops the turn another Claude (the desktop app, a `claude` in a terminal)
+     * is running in this session, the way Ctrl-C would: asked to stop first,
+     * told to quit if it doesn't. Only ever the processes that have this session open.
+     */
+    async interruptElsewhere(nativeId) {
+        if (!(await this.elsewhere(nativeId))?.working)
+            return;
+        const recorded = (await this.foreignHolders(nativeId)).map((holder) => holder.pid);
+        const pids = recorded.length > 0 || this.hasHolderRecords() ? recorded : await this.commandLineHolders(nativeId);
+        const stopped = async (ms) => {
+            const deadline = Date.now() + ms;
+            while (Date.now() < deadline) {
+                if (!(await this.elsewhere(nativeId))?.working)
+                    return true;
+                await new Promise((resolve) => setTimeout(resolve, 150));
+            }
+            return false;
+        };
+        for (const signal of ["SIGINT", "SIGTERM"]) {
+            for (const pid of new Set(pids)) {
+                try {
+                    process.kill(pid, signal);
+                }
+                catch {
+                    // Already gone.
+                }
+            }
+            if (await stopped(signal === "SIGINT" ? 6000 : 4000))
+                return;
         }
-        await super.cancel(nativeId);
+        throw RpcError.app("busy", "没能停下电脑上的这一轮：请在电脑上按 Esc 停止它");
     }
     async setConfig(nativeId, optionId, value) {
-        await this.ensureRemote(nativeId);
-        await super.setConfig(nativeId, optionId, value);
+        if (this.modes.get(nativeId) === "remote" && this.sessions.get(nativeId)?.loaded) {
+            await super.setConfig(nativeId, optionId, value);
+            return;
+        }
+        // The desktop has it (or nobody): choosing a model mustn't take the session
+        // from the terminal. Remember it; it applies when the phone next drives.
+        const option = this.template?.find((entry) => entry.id === optionId);
+        if (!option || !option.values.some((entry) => entry.value === value))
+            throw RpcError.app("invalid_params", `unknown setting ${optionId}=${value}`);
+        this.host?.state(this.id, nativeId).set("pendingConfig", JSON.stringify({ ...this.pendingConfig(nativeId), [optionId]: value }));
+        this.emitDesktopConfig(nativeId);
     }
     async takeover(nativeId) {
         await this.ensureRemote(nativeId);
@@ -232,11 +546,26 @@ export class ClaudeDriver extends AcpDriver {
     }
     /** Desktop activity: what the TUI (or a plain `claude`) writes to the transcript. */
     onTranscriptLine(nativeId, line) {
-        const result = transcriptLine(line);
+        let hidden = this.hiddenTools.get(nativeId);
+        if (!hidden)
+            this.hiddenTools.set(nativeId, (hidden = new Set()));
+        let agents = this.backgroundAgents.get(nativeId);
+        if (!agents)
+            this.backgroundAgents.set(nativeId, (agents = new Set()));
+        let seen = this.seenLines.get(nativeId);
+        if (!seen)
+            this.seenLines.set(nativeId, (seen = new Set()));
+        const result = transcriptLine(line, { hidden, agents, seen });
         if (result.title)
             this.host?.update(this.id, nativeId, { sessionUpdate: "session_info_update", title: result.title });
         for (const update of result.updates)
             this.emit(nativeId, update);
+        // Changed on the computer (another model, effort, permission mode): the phone shows it.
+        const settings = mergeSettings(this.observed.get(nativeId) ?? {}, settingsOf(line));
+        if (settings) {
+            this.observed.set(nativeId, settings);
+            this.emitDesktopConfig(nativeId);
+        }
     }
     /** Makes this host the session's only writer, taking it from the desktop if needed. */
     async ensureRemote(nativeId) {
@@ -244,12 +573,22 @@ export class ClaudeDriver extends AcpDriver {
         if (this.modes.get(nativeId) === "remote" && state?.loaded)
             return;
         const cwd = state?.cwd ?? "";
+        // Claude writes nothing until the first message, and there is nothing to
+        // resume without it: say so before the terminal gives the session up.
+        if (!state?.loaded && !findTranscript(this.configDir, nativeId, cwd)) {
+            throw RpcError.app("not_ready", "这个 Claude 会话还没有任何消息：先在电脑上发一条");
+        }
         const desktop = this.host?.desktop(this.id, nativeId);
+        let alsoOpenIn;
         if (desktop) {
             await desktop.yield();
         }
         else if (this.modes.get(nativeId) !== "remote") {
-            await this.refuseIfTuiMayBeActive(nativeId, cwd);
+            const other = await this.elsewhere(nativeId);
+            // Two Claudes writing one turn at once would garble it; a message sent now waits instead (see prompt).
+            if (other?.working)
+                throw RpcError.app("busy", "电脑上的 Claude 正在跑这一轮。直接发消息即可：会排队，等它结束后发出。");
+            alsoOpenIn = other?.where;
         }
         // Take in the TUI's last lines, then stop following: ACP streams from here on.
         const tail = this.tails.get(nativeId);
@@ -265,9 +604,75 @@ export class ClaudeDriver extends AcpDriver {
             target.config = toConfigOptions(response);
             target.loaded = true;
         }
+        // The session keeps the settings it ran with on the computer, except where
+        // the phone chose otherwise while the desktop had it.
+        const observed = this.observed.get(nativeId) ?? {};
+        const kept = Object.fromEntries(target.config.flatMap((option) => [[option.id, observedValue(option, observed)]]).filter(([, value]) => value !== undefined));
+        const pending = this.pendingConfig(nativeId);
+        for (const [optionId, value] of Object.entries({ ...kept, ...pending })) {
+            const option = target.config.find((entry) => entry.id === optionId);
+            if (option && option.current !== value && option.values.some((entry) => entry.value === value)) {
+                await super.setConfig(nativeId, optionId, value).catch((error) => this.host?.log(`[claude] couldn't apply ${optionId}: ${String(error)}`));
+            }
+        }
+        if (Object.keys(pending).length)
+            this.host?.state(this.id, nativeId).set("pendingConfig", "{}");
         this.setWriter(nativeId, "remote");
         this.setMode(nativeId, "remote");
         this.emitConfig(nativeId, target);
+        if (alsoOpenIn) {
+            // That Claude keeps its own copy of the conversation and can't be told about this one.
+            this.emit(nativeId, alsoOpenIn === "app"
+                ? {
+                    sessionUpdate: "ls_notice",
+                    level: "info",
+                    title: "已在手机上接着做",
+                    detail: "这个会话在 Claude 桌面 App 里也开着：App 要重启后才会显示手机上的消息。",
+                }
+                : {
+                    sessionUpdate: "ls_notice",
+                    level: "info",
+                    title: "已在手机上接着做",
+                    detail: `这个会话在电脑终端里也开着：那边要重新打开才会显示手机上的消息（用 linkshell claude --resume ${nativeId} 打开，之后可以随时接力）。`,
+                });
+        }
+        this.startWatch();
+    }
+    startWatch() {
+        this.remoteWatch ??= setInterval(() => void this.watchRemoteSessions(), this.holderCheckMs);
+        this.remoteWatch.unref?.();
+    }
+    /**
+     * A session driven from a device that another Claude wrote to (the desktop
+     * app, or a `claude` in a terminal, continued it): that process has the
+     * conversation now, so stop writing to it and follow what it does instead.
+     */
+    async watchRemoteSessions() {
+        for (const nativeId of [...this.waiting.keys()])
+            await this.sendWaiting(nativeId).catch(() => { });
+        for (const [nativeId, mode] of this.modes) {
+            if (mode !== "remote" || this.host?.desktop(this.id, nativeId))
+                continue;
+            if (!this.tails.get(nativeId)?.writtenMeanwhile(writtenByAnotherClaude))
+                continue;
+            await this.leaveRemote(nativeId).catch(() => { });
+            this.emit(nativeId, {
+                sessionUpdate: "ls_notice",
+                level: "info",
+                title: "电脑上继续了这个会话",
+                detail: "这里转为实时显示电脑上的进展；再发消息会重新接管。",
+            });
+        }
+    }
+    /** Running Claude processes on this session that this host didn't start. */
+    async foreignHolders(nativeId) {
+        const foreign = [];
+        for (const holder of sessionHolders(this.configDir, nativeId)) {
+            // The adapter's own Claude process is a child of this host.
+            if (!(await descendsFrom(holder.pid, process.pid)))
+                foreign.push(holder);
+        }
+        return foreign;
     }
     /** Hands the session back: stop remote driving and resume following the transcript. */
     async leaveRemote(nativeId) {
@@ -282,33 +687,61 @@ export class ClaudeDriver extends AcpDriver {
         }
         await super.detach(nativeId);
         this.setMode(nativeId, "idle");
-        // Skip what the remote turns wrote; those were already streamed live.
-        this.tails.get(nativeId)?.resumeAtEnd();
+        // What the remote turns wrote was already streamed live; anything another
+        // Claude wrote in between (it was reopened on the computer) is new.
+        this.tails.get(nativeId)?.resumeSkipping((line) => line.includes(REMOTE_ENTRYPOINT));
     }
     /**
-     * With no `linkshell claude` terminal to ask, make sure no other `claude` is
-     * writing the session before becoming a second writer. If this host or a
-     * managed terminal wrote it last, only a live process counts; otherwise a
-     * transcript written moments ago does too (a plain `claude` may be mid-turn).
+     * With no `linkshell claude` terminal to ask: another Claude (the desktop
+     * app, a `claude` in some terminal) that has the session open, and whether
+     * it is in the middle of a turn. It can't be made to step aside, and it won't
+     * show what a device does until it is reopened; a device continues the
+     * session all the same, once that turn is over.
      */
-    async refuseIfTuiMayBeActive(nativeId, cwd) {
-        const path = findTranscript(this.configDir, nativeId, cwd);
+    async elsewhere(nativeId) {
+        if (this.modes.get(nativeId) === "remote" || this.host?.desktop(this.id, nativeId))
+            return undefined;
+        const path = findTranscript(this.configDir, nativeId, this.sessions.get(nativeId)?.cwd ?? "");
         if (!path)
-            return;
-        const known = this.writer(nativeId) !== undefined;
-        const recentlyWritten = !known && Date.now() - statSync(path).mtimeMs < this.busyWindowMs;
-        if (!recentlyWritten && !(await this.tuiProcessHolds(nativeId)))
-            return;
-        throw RpcError.app("busy", `这个会话正在电脑上用 claude 直接运行，无法安全接管。在电脑终端用 linkshell claude --resume ${nativeId} 打开后即可接力。`);
+            return undefined;
+        // Claude's own record of who has the session open.
+        const holders = await this.foreignHolders(nativeId);
+        if (holders.length > 0) {
+            const where = holders.some((holder) => holder.entrypoint !== "claude-desktop") ? "terminal" : "app";
+            return { where, working: turnInProgress(path, this.busyWindowMs) };
+        }
+        if (this.hasHolderRecords())
+            return undefined;
+        // An older Claude keeps no such record: its command line, or a transcript it wrote moments ago, is the sign.
+        if (await this.tuiProcessHolds(nativeId))
+            return { where: "terminal", working: turnInProgress(path, this.busyWindowMs) };
+        const justWritten = Date.now() - statSync(path).mtimeMs < Math.min(this.busyWindowMs, 60_000);
+        return justWritten && this.writer(nativeId) === undefined && turnInProgress(path, this.busyWindowMs) ? { where: "terminal", working: true } : undefined;
     }
     async tuiProcessHolds(nativeId) {
+        return (await this.commandLineHolders(nativeId)).length > 0;
+    }
+    /** Whether this Claude records who has which session open (see holders.ts). */
+    hasHolderRecords() {
+        return existsSync(join(this.configDir, "sessions"));
+    }
+    /** Processes with the session on their command line (`claude --resume <id>`): how an older Claude shows it. */
+    async commandLineHolders(nativeId) {
         try {
             // -ww: never truncate; the session id is at the end of long command lines.
-            const { stdout } = await execFileAsync("/bin/ps", ["-Aww", "-o", "command="], { timeout: 5000, maxBuffer: 16 * 1024 * 1024 });
-            return stdout.split("\n").some((command) => command.includes(nativeId) && !command.includes("claude-agent-acp"));
+            const { stdout } = await execFileAsync("/bin/ps", ["-Aww", "-o", "pid=,command="], { timeout: 5000, maxBuffer: 16 * 1024 * 1024 });
+            const pids = [];
+            for (const line of stdout.split("\n")) {
+                if (!line.includes(nativeId) || line.includes("claude-agent-acp"))
+                    continue;
+                const pid = Number(line.trim().split(/\s+/, 1)[0]);
+                if (Number.isInteger(pid) && pid !== process.pid)
+                    pids.push(pid);
+            }
+            return pids;
         }
         catch {
-            return false;
+            return [];
         }
     }
     /** Mirrors remote progress to the terminal that stepped aside. */
@@ -328,4 +761,52 @@ export class ClaudeDriver extends AcpDriver {
             desktop.activity("   (回合结束)");
     }
 }
+/**
+ * The option value for a model id from a transcript ("claude-opus-5-5"):
+ * "default" when that's what default resolves to, else the entry with that
+ * name ("Opus 5.5").
+ */
+/**
+ * A closing Claude process writes its exit record (last prompt, title, cost)
+ * after the adapter has deleted the transcript, bringing the file back. Removes
+ * it again for a while after a delete.
+ */
+function sweepTranscript(path, forMs = 15_000) {
+    const sessionDir = path.replace(/\.jsonl$/, "");
+    const until = Date.now() + forMs;
+    const sweep = () => {
+        for (const target of [path, sessionDir]) {
+            if (existsSync(target))
+                rmSync(target, { recursive: true, force: true });
+        }
+        if (Date.now() < until)
+            setTimeout(sweep, 250).unref();
+    };
+    sweep();
+}
+/** The value of a setting that matches what the session was seen running with, if it says. */
+function observedValue(option, observed) {
+    if (option.category === "model")
+        return observed.model ? matchModel(option, observed.model) : undefined;
+    if (option.category === "mode")
+        return observed.mode;
+    if (option.id === "effort" || option.category === "effort")
+        return observed.effort;
+    if (option.id === "fast")
+        return observed.fast === undefined ? undefined : observed.fast ? "on" : "off";
+    return undefined;
+}
+export function matchModel(option, modelId) {
+    if (option.values.some((value) => value.value === modelId))
+        return modelId;
+    const parts = modelId.replace(/^claude-/, "").replace(/-\d{8}$/, "").split("-");
+    const family = parts.shift();
+    if (!family || parts.length === 0)
+        return undefined;
+    const name = `${family[0].toUpperCase()}${family.slice(1)} ${parts.join(".")}`;
+    const byDefault = option.values.find((value) => value.value === "default" && value.description === name);
+    if (byDefault)
+        return byDefault.value;
+    return option.values.find((value) => value.name === name)?.value;
+}
 //# sourceMappingURL=driver.js.map