cli-wechat-bridge 1.1.3 → 1.1.5

package/dist/bridge/bridge-adapters.claude.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import net from "node:net";
 import os from "node:os";
 import path from "node:path";
+import { spawnSync } from "node:child_process";
 import { buildLocalCompanionToken } from "../companion/local-companion-link.js";
 import { t } from "../i18n/index.js";
 import { ensureWorkspaceChannelDir } from "../wechat/channel-config.js";
@@ -17,6 +18,10 @@ const CLAUDE_BRACKETED_PASTE_START = "\u001b[200~";
 const CLAUDE_BRACKETED_PASTE_END = "\u001b[201~";
 const CLAUDE_REMOTE_ENTER_DELAY_MS = 40;
 const CLAUDE_STARTUP_OUTPUT_BUFFER_LIMIT = 4_000;
+const CLAUDE_SESSION_METADATA_READ_BYTES = 64 * 1024;
+const CLAUDE_MAX_SANITIZED_PROJECT_PATH = 200;
+const CLAUDE_RESUME_TIMEOUT_MS = 30_000;
+const CLAUDE_SESSION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 function isClaudeWorkspaceTrustPrompt(text) {
     const compact = text.replace(/\s+/g, " ").trim();
     return (/Accessing workspace:/i.test(compact) &&
@@ -27,6 +32,229 @@ function isClaudeWorkspaceTrustPrompt(text) {
 function isRecord(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
+function expandHomePath(value) {
+    if (value === "~") {
+        return os.homedir();
+    }
+    if (value.startsWith("~/") || value.startsWith("~\\")) {
+        return path.join(os.homedir(), value.slice(2));
+    }
+    return value;
+}
+function normalizeComparablePath(value) {
+    const resolved = path.resolve(value);
+    return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function isSameClaudePath(left, right) {
+    return normalizeComparablePath(left) === normalizeComparablePath(right);
+}
+function getClaudeConfigDirectory(env) {
+    const custom = env.CLAUDE_CONFIG_DIR;
+    return custom
+        ? path.resolve(expandHomePath(custom))
+        : path.join(env.USERPROFILE || env.HOME || os.homedir(), ".claude");
+}
+function sanitizeClaudeProjectPath(cwd) {
+    return path.resolve(cwd).replace(/[^a-zA-Z0-9]/g, "-");
+}
+export function buildClaudeProjectSessionDirectory(cwd, env = process.env) {
+    return path.join(getClaudeConfigDirectory(env), "projects", sanitizeClaudeProjectPath(cwd));
+}
+function readClaudeSessionSegments(filePath) {
+    const stat = fs.statSync(filePath);
+    const fd = fs.openSync(filePath, "r");
+    try {
+        const headLength = Math.min(stat.size, CLAUDE_SESSION_METADATA_READ_BYTES);
+        const headBuffer = Buffer.alloc(headLength);
+        fs.readSync(fd, headBuffer, 0, headLength, 0);
+        const tailStart = Math.max(0, stat.size - CLAUDE_SESSION_METADATA_READ_BYTES);
+        const tailLength = stat.size - tailStart;
+        const tailBuffer = Buffer.alloc(tailLength);
+        fs.readSync(fd, tailBuffer, 0, tailLength, tailStart);
+        return [headBuffer.toString("utf8"), tailBuffer.toString("utf8")];
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function extractClaudeUserMessageText(value) {
+    if (typeof value === "string") {
+        return normalizeOutput(value).trim();
+    }
+    if (!Array.isArray(value)) {
+        return "";
+    }
+    return normalizeOutput(value
+        .filter((item) => isRecord(item))
+        .filter((item) => item.type === "text" && typeof item.text === "string")
+        .map((item) => item.text)
+        .join("\n")).trim();
+}
+function readClaudeSessionMetadata(filePath) {
+    const metadata = { lastTimestampMs: 0 };
+    const seenLines = new Set();
+    for (const segment of readClaudeSessionSegments(filePath)) {
+        for (const rawLine of segment.split(/\r?\n/)) {
+            const line = rawLine.trim();
+            if (!line || seenLines.has(line)) {
+                continue;
+            }
+            seenLines.add(line);
+            try {
+                const entry = JSON.parse(line);
+                if (!isRecord(entry)) {
+                    continue;
+                }
+                if (typeof entry.cwd === "string") {
+                    metadata.cwd = entry.cwd;
+                }
+                if (entry.isSidechain === false) {
+                    metadata.isSidechain = false;
+                }
+                else if (entry.isSidechain === true && metadata.isSidechain === undefined) {
+                    metadata.isSidechain = true;
+                }
+                if (entry.type === "custom-title" && typeof entry.customTitle === "string") {
+                    metadata.customTitle = normalizeOutput(entry.customTitle).trim();
+                }
+                else if (entry.type === "ai-title" && typeof entry.aiTitle === "string") {
+                    metadata.aiTitle = normalizeOutput(entry.aiTitle).trim();
+                }
+                else if (entry.type === "last-prompt" && typeof entry.lastPrompt === "string") {
+                    metadata.lastPrompt = normalizeOutput(entry.lastPrompt).trim();
+                }
+                else if (entry.type === "summary" && typeof entry.summary === "string") {
+                    metadata.summary = normalizeOutput(entry.summary).trim();
+                }
+                else if (!metadata.firstPrompt &&
+                    entry.type === "user" &&
+                    isRecord(entry.message)) {
+                    metadata.firstPrompt = extractClaudeUserMessageText(entry.message.content);
+                }
+                if (typeof entry.timestamp === "string") {
+                    const timestampMs = Date.parse(entry.timestamp);
+                    if (Number.isFinite(timestampMs)) {
+                        metadata.lastTimestampMs = Math.max(metadata.lastTimestampMs, timestampMs);
+                    }
+                }
+            }
+            catch {
+                // Head/tail segments can begin or end with a partial JSONL line.
+            }
+        }
+    }
+    return metadata;
+}
+function readClaudeSessionIndex(projectDir, cwd) {
+    const indexPath = path.join(projectDir, "sessions-index.json");
+    if (!fs.existsSync(indexPath)) {
+        return new Map();
+    }
+    try {
+        const parsed = JSON.parse(fs.readFileSync(indexPath, "utf8"));
+        if (!isRecord(parsed)) {
+            return new Map();
+        }
+        if (typeof parsed.originalPath === "string" && !isSameClaudePath(parsed.originalPath, cwd)) {
+            return new Map();
+        }
+        const entries = Array.isArray(parsed.entries) ? parsed.entries : [];
+        return new Map(entries
+            .filter((entry) => isRecord(entry))
+            .filter((entry) => typeof entry.sessionId === "string")
+            .map((entry) => [entry.sessionId, entry]));
+    }
+    catch {
+        return new Map();
+    }
+}
+function findClaudeProjectSessionDirectories(cwd, env) {
+    const projectsDir = path.join(getClaudeConfigDirectory(env), "projects");
+    const direct = buildClaudeProjectSessionDirectory(cwd, env);
+    const results = new Set();
+    if (fs.existsSync(direct)) {
+        results.add(direct);
+    }
+    const sanitized = sanitizeClaudeProjectPath(cwd);
+    if (sanitized.length <= CLAUDE_MAX_SANITIZED_PROJECT_PATH || !fs.existsSync(projectsDir)) {
+        return [...results];
+    }
+    const prefix = sanitized.slice(0, CLAUDE_MAX_SANITIZED_PROJECT_PATH);
+    for (const entry of fs.readdirSync(projectsDir, { withFileTypes: true })) {
+        if (entry.isDirectory() && entry.name.startsWith(`${prefix}-`)) {
+            results.add(path.join(projectsDir, entry.name));
+        }
+    }
+    return [...results];
+}
+function summarizeClaudeSessionFile(filePath, cwd, indexEntry) {
+    const sessionId = path.basename(filePath, ".jsonl");
+    if (!CLAUDE_SESSION_ID_RE.test(sessionId)) {
+        return null;
+    }
+    try {
+        const metadata = readClaudeSessionMetadata(filePath);
+        const belongsToCwd = (typeof indexEntry?.projectPath === "string" &&
+            isSameClaudePath(indexEntry.projectPath, cwd)) ||
+            (typeof metadata.cwd === "string" && isSameClaudePath(metadata.cwd, cwd));
+        if (!belongsToCwd || indexEntry?.isSidechain === true || metadata.isSidechain === true) {
+            return null;
+        }
+        const indexedModifiedMs = typeof indexEntry?.modified === "string" ? Date.parse(indexEntry.modified) : 0;
+        const updatedMs = metadata.lastTimestampMs ||
+            (Number.isFinite(indexedModifiedMs) ? indexedModifiedMs : 0) ||
+            fs.statSync(filePath).mtimeMs;
+        const title = metadata.customTitle ||
+            indexEntry?.customTitle ||
+            metadata.aiTitle ||
+            metadata.lastPrompt ||
+            indexEntry?.summary ||
+            metadata.summary ||
+            indexEntry?.firstPrompt ||
+            metadata.firstPrompt;
+        if (!title) {
+            return null;
+        }
+        return {
+            sessionId,
+            title: truncatePreview(title, 120),
+            lastUpdatedAt: new Date(updatedMs).toISOString(),
+            source: "claude",
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function listClaudeResumeSessions(cwd, limit = 10, env = process.env) {
+    const candidates = [];
+    for (const projectDir of findClaudeProjectSessionDirectories(cwd, env)) {
+        const index = readClaudeSessionIndex(projectDir, cwd);
+        for (const entry of fs.readdirSync(projectDir, { withFileTypes: true })) {
+            if (!entry.isFile() || !entry.name.toLowerCase().endsWith(".jsonl")) {
+                continue;
+            }
+            const sessionId = path.basename(entry.name, ".jsonl");
+            const candidate = summarizeClaudeSessionFile(path.join(projectDir, entry.name), cwd, index.get(sessionId));
+            if (candidate) {
+                candidates.push(candidate);
+            }
+        }
+    }
+    return candidates
+        .sort((left, right) => Date.parse(right.lastUpdatedAt) - Date.parse(left.lastUpdatedAt))
+        .slice(0, Math.max(1, limit));
+}
+function findClaudeResumeSessionFile(cwd, sessionId, env = process.env) {
+    for (const projectDir of findClaudeProjectSessionDirectories(cwd, env)) {
+        const filePath = path.join(projectDir, `${sessionId}.jsonl`);
+        if (fs.existsSync(filePath) &&
+            summarizeClaudeSessionFile(filePath, cwd, readClaudeSessionIndex(projectDir, cwd).get(sessionId))) {
+            return filePath;
+        }
+    }
+    return null;
+}
 export function normalizeClaudeProjectConfigKey(cwd) {
     return path.resolve(cwd).replace(/\\/g, "/");
 }
@@ -106,6 +334,8 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
     transcriptPollTimer = null;
     transcriptTailOffset = 0;
     polledTranscriptSessionId = null;
+    pendingResume = null;
+    localResumeSessionEndObserved = false;
     constructor(options) {
         super(options);
         const shouldRestoreInitialSession = options.sessionStartMode !== "new";
@@ -192,11 +422,104 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         this.writeToPty("\r");
         this.armWechatWorkingNotice();
     }
-    async listResumeSessions(_limit = 10) {
-        throw new Error('WeChat /resume is disabled in claude mode. Use /resume directly inside "wechat-claude"; WeChat will follow the active local session.');
+    async listResumeSessions(limit = 10) {
+        return listClaudeResumeSessions(this.options.cwd, limit);
+    }
+    async resumeSession(sessionId) {
+        if (!this.pty) {
+            throw new Error("Claude is not running yet.");
+        }
+        if (this.pendingResume) {
+            throw new Error("Claude is already switching sessions.");
+        }
+        if (this.pendingApproval) {
+            throw new Error("A Claude approval request is pending. Reply with /confirm or /deny.");
+        }
+        if (this.state.status === "busy" || this.state.status === "awaiting_approval") {
+            throw new Error("Claude is still working. Wait for the current reply or use /stop.");
+        }
+        if (this.state.status !== "idle") {
+            throw new Error(`Claude cannot switch sessions while its status is ${this.state.status}.`);
+        }
+        const targetConversationId = sessionId.trim();
+        if (!CLAUDE_SESSION_ID_RE.test(targetConversationId)) {
+            throw new Error(`Invalid Claude session ID: ${targetConversationId}`);
+        }
+        if (!this.resolveClaudeResumeSessionFile(targetConversationId)) {
+            throw new Error(`No Claude session ${targetConversationId} was found for ${this.options.cwd}.`);
+        }
+        if (this.isClaudeSessionActiveElsewhere(targetConversationId)) {
+            throw new Error(`Claude session ${targetConversationId} is active in another Claude process. Stop it before resuming from WeChat.`);
+        }
+        this.setStatus("starting", `Switching Claude to session ${targetConversationId.slice(0, 12)}...`);
+        const completion = new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                if (this.pendingResume?.targetConversationId !== targetConversationId) {
+                    return;
+                }
+                const phase = this.pendingResume.sessionEndObserved
+                    ? " after the previous session ended"
+                    : "";
+                this.pendingResume = null;
+                this.setStatus("idle");
+                reject(new Error(`Timed out waiting for Claude to resume session ${targetConversationId}${phase}.`));
+            }, CLAUDE_RESUME_TIMEOUT_MS);
+            this.pendingResume = {
+                targetConversationId,
+                resolve,
+                reject,
+                timer,
+                sessionEndObserved: false,
+            };
+        });
+        this.writeToPty(`/resume ${targetConversationId}`);
+        await delay(CLAUDE_REMOTE_ENTER_DELAY_MS);
+        this.writeToPty("\r");
+        await completion;
+    }
+    isClaudeSessionActiveElsewhere(sessionId) {
+        if (sessionId === this.resumeConversationId) {
+            return false;
+        }
+        try {
+            const env = shared.buildCliEnvironment("claude");
+            const target = shared.resolveSpawnTarget(this.options.command, "claude", { env });
+            const result = spawnSync(target.file, [...target.args, "agents", "--json", "--cwd", this.options.cwd], {
+                cwd: this.options.cwd,
+                env,
+                encoding: "utf8",
+                windowsHide: true,
+                timeout: 5_000,
+            });
+            if (result.status !== 0 || !result.stdout.trim()) {
+                return false;
+            }
+            const parsed = JSON.parse(result.stdout);
+            const sessions = Array.isArray(parsed)
+                ? parsed
+                : isRecord(parsed) && Array.isArray(parsed.sessions)
+                    ? parsed.sessions
+                    : [];
+            return sessions.some((session) => {
+                if (!isRecord(session)) {
+                    return false;
+                }
+                const candidateId = typeof session.id === "string"
+                    ? session.id
+                    : typeof session.sessionId === "string"
+                        ? session.sessionId
+                        : typeof session.session_id === "string"
+                            ? session.session_id
+                            : "";
+                return candidateId === sessionId;
+            });
+        }
+        catch {
+            return false;
+        }
     }
-    async resumeSession(_threadId) {
-        throw new Error('WeChat /resume is disabled in claude mode. Use /resume directly inside "wechat-claude"; WeChat will follow the active local session.');
+    resolveClaudeResumeSessionFile(sessionId) {
+        return findClaudeResumeSessionFile(this.options.cwd, sessionId);
     }
     async interrupt() {
         if (!this.pty) {
@@ -208,11 +531,27 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         this.clearWechatWorkingNotice(true);
         this.pendingCliApprovalHints = null;
         this.flushPendingClaudeHookApprovals();
+        if (this.pendingApproval) {
+            // The flush above answered the pending hook approval with an empty
+            // response, so the mirrored request is dead. Drop it — otherwise a
+            // later /confirm targets a deleted requestId and every new message is
+            // rejected by a stale "approval pending" state. Mirrors what the
+            // socket-close path does via handleClosedClaudeHookApproval.
+            this.pendingApproval = null;
+            this.state.pendingApproval = null;
+            this.state.pendingApprovalOrigin = undefined;
+        }
+        if (this.state.status === "awaiting_approval") {
+            // Return to busy so the interrupt settle path (guarded on busy) can
+            // complete the turn normally.
+            this.setStatus("busy");
+        }
         this.writeToPty("\u0003");
         this.scheduleTaskComplete(shared.INTERRUPT_SETTLE_DELAY_MS);
         return true;
     }
     async reset() {
+        this.rejectPendingResume(new Error("Claude was reset during session switching."));
         this.clearWechatWorkingNotice(true);
         this.pendingCliApprovalHints = null;
         this.runtimeSessionId = null;
@@ -280,6 +619,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         return ok ? 1 : 0;
     }
     async dispose() {
+        this.rejectPendingResume(new Error("Claude is shutting down during session switching."));
         this.detachLocalTerminal();
         this.clearWechatWorkingNotice(true);
         this.pendingCliApprovalHints = null;
@@ -311,6 +651,16 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         if (!text) {
             return;
         }
+        if (this.pendingResume &&
+            (isClaudeInvalidResumeError(text) ||
+                /Session .+ was not found|Found \d+ sessions matching|Failed to resume/i.test(text))) {
+            const failureLine = text
+                .split("\n")
+                .map((line) => line.trim())
+                .find((line) => /not found|matching|failed to resume/i.test(line));
+            this.rejectPendingResume(new Error(failureLine || "Claude could not resume the requested session."));
+            return;
+        }
         if (this.resumeConversationId &&
             !this.hasAcceptedInput &&
             !this.recoveringInvalidResume &&
@@ -370,6 +720,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         this.detachLocalTerminal();
         this.clearWechatWorkingNotice(true);
         this.pendingCliApprovalHints = null;
+        this.rejectPendingResume(new Error("Claude exited before the requested session switch completed."));
         void this.stopHookServer();
         if (this.recoveringInvalidResume && !this.shuttingDown) {
             this.clearCompletionTimer();
@@ -480,7 +831,12 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
             throw new Error("Claude hook server is not ready.");
         }
         const { workspaceDir } = ensureWorkspaceChannelDir(this.options.cwd);
-        const runtimeDir = path.join(workspaceDir, "claude-runtime");
+        // Scope the runtime directory to this adapter instance: two bridges in the
+        // same cwd would otherwise overwrite each other's hook script, settings,
+        // and error log, routing approvals and final replies to the wrong chat.
+        // The hook token is unique per hook server (per instance), and the same
+        // token regenerates the same directory across hook restarts.
+        const runtimeDir = path.join(workspaceDir, `claude-runtime-${this.hookToken.replace(/[^a-zA-Z0-9]/g, "").slice(0, 12)}`);
         fs.mkdirSync(runtimeDir, { recursive: true });
         const hookScriptPath = path.join(runtimeDir, process.platform === "win32" ? "hook.cmd" : "hook.sh");
         const settingsFilePath = path.join(runtimeDir, "settings.json");
@@ -752,6 +1108,10 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
                 this.handleClaudeSessionStart(payload);
                 this.respondToClaudeHook(params.socket, params.requestId);
                 return;
+            case "SessionEnd":
+                this.handleClaudeSessionEnd(payload);
+                this.respondToClaudeHook(params.socket, params.requestId);
+                return;
             case "UserPromptSubmit":
                 this.handleClaudeUserPromptSubmit(payload);
                 this.respondToClaudeHook(params.socket, params.requestId);
@@ -816,6 +1176,17 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
             ? payload.transcript_path.trim()
             : null;
         const nextResumeConversationId = extractClaudeResumeConversationId(nextTranscriptPath ?? undefined);
+        const resumedConversationId = nextResumeConversationId ?? payload.session_id;
+        const pendingResume = this.pendingResume;
+        const pendingResumeMatches = payload.source === "resume" &&
+            pendingResume !== null &&
+            pendingResume.targetConversationId === resumedConversationId;
+        const isInteractiveResume = payload.source === "resume" && Boolean(previousRuntimeSessionId);
+        if (isInteractiveResume &&
+            !pendingResumeMatches &&
+            !this.localResumeSessionEndObserved) {
+            this.failClaudeTurn("The active WeChat task was interrupted because the local Claude terminal switched sessions.");
+        }
         const compactedByTranscriptRotation = Boolean(this.transcriptPath) &&
             Boolean(nextTranscriptPath) &&
             this.transcriptPath !== nextTranscriptPath &&
@@ -839,16 +1210,33 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         this.transcriptPath = nextTranscriptPath;
         this.state.transcriptPath = nextTranscriptPath ?? undefined;
         this.startTranscriptThinkingWatch();
-        if (previousRuntimeSessionId === payload.session_id) {
-            return;
-        }
         const timestamp = nowIso();
-        const isRestore = !previousRuntimeSessionId &&
+        const isStartupRestore = !previousRuntimeSessionId &&
             (payload.source === "resume" ||
                 (nextResumeConversationId !== null &&
                     nextResumeConversationId === previousResumeConversationId));
-        const source = isRestore ? "restore" : "local";
-        const reason = isRestore ? "startup_restore" : "local_follow";
+        const source = pendingResumeMatches
+            ? "wechat"
+            : isStartupRestore
+                ? "restore"
+                : "local";
+        const reason = pendingResumeMatches
+            ? "wechat_resume"
+            : isStartupRestore
+                ? "startup_restore"
+                : "local_follow";
+        this.localResumeSessionEndObserved = false;
+        if (pendingResume &&
+            payload.source === "resume" &&
+            !pendingResumeMatches) {
+            this.rejectPendingResume(new Error(`Claude resumed unexpected session ${resumedConversationId}; expected ${pendingResume.targetConversationId}.`));
+        }
+        if (previousRuntimeSessionId === payload.session_id) {
+            if (pendingResumeMatches) {
+                this.resolvePendingResume();
+            }
+            return;
+        }
         this.state.lastSessionSwitchAt = timestamp;
         this.state.lastSessionSwitchSource = source;
         this.state.lastSessionSwitchReason = reason;
@@ -859,6 +1247,40 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
             reason,
             timestamp,
         });
+        if (pendingResumeMatches) {
+            this.resolvePendingResume();
+        }
+    }
+    handleClaudeSessionEnd(payload) {
+        if (payload.reason !== "resume") {
+            return;
+        }
+        if (this.pendingResume) {
+            this.pendingResume.sessionEndObserved = true;
+            return;
+        }
+        this.localResumeSessionEndObserved = true;
+        this.failClaudeTurn("The active WeChat task was interrupted because the local Claude terminal switched sessions.");
+    }
+    resolvePendingResume() {
+        const pending = this.pendingResume;
+        if (!pending) {
+            return;
+        }
+        this.pendingResume = null;
+        clearTimeout(pending.timer);
+        this.setStatus("idle");
+        pending.resolve();
+    }
+    rejectPendingResume(error) {
+        const pending = this.pendingResume;
+        if (!pending) {
+            return;
+        }
+        this.pendingResume = null;
+        clearTimeout(pending.timer);
+        this.setStatus("idle");
+        pending.reject(error);
     }
     handleClaudeUserPromptSubmit(payload) {
         const prompt = typeof payload.prompt === "string" ? normalizeOutput(payload.prompt).trim() : "";
@@ -1008,6 +1430,16 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
             normalizeClaudeAssistantMessage(payload));
     }
     handleClaudeStop(payload) {
+        if (payload.session_id &&
+            this.runtimeSessionId &&
+            payload.session_id !== this.runtimeSessionId) {
+            return;
+        }
+        if (!this.hasAcceptedInput &&
+            this.state.activeTurnOrigin === undefined &&
+            this.currentPreview === "(idle)") {
+            return;
+        }
         this.clearWechatWorkingNotice(true);
         this.pendingCliApprovalHints = null;
         this.lastAutoApprovedPayload = null;
@@ -1032,6 +1464,11 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         this.currentPreview = "(idle)";
     }
     handleClaudeStopFailure(payload) {
+        if (payload.session_id &&
+            this.runtimeSessionId &&
+            payload.session_id !== this.runtimeSessionId) {
+            return;
+        }
         this.lastAutoApprovedPayload = null;
         this.stopTranscriptThinkingWatch();
         this.failClaudeTurn(buildClaudeFailureMessage(payload));