@unlinearity/cli-wechat-bridge 1.1.4 → 1.1.5

package/README.md

@@ -157,9 +157,7 @@ cd D:\work\your-project
 - 如果检测到可见端仍在运行但 worker 状态异常（如 `stopped` / `error`），会自动重启 bridge 再重新打开可见端；
 - 在其他目录执行会显式切换活动工作区。
 
-`wechat-codex-start`、`wechat-claude-start`、`wechat-opencode-start`、`wechat-pi-start` 暂时保留为过渡别名，功能与直接命令一致，但会输出弃用提示，并将在下一版本移除。
-
-### 6. 常驻 daemon 模式（支持多 CLI 切换）
+### 6. 常驻 daemon 模式（支持多 CLI 切换）
 
 如果你希望微信连接长期保持在线，并在 Codex / Claude Code / OpenCode / Pi 之间来回切换，可以在项目目录启动统一 daemon：
 
@@ -253,7 +251,7 @@ OpenCode 模式下，微信侧支持 `/new` 或 `/new-session` 创建新 session
 | OpenCode | `wechat-opencode` |
 | Pi | `wechat-pi` |
 
-`wechat-*-start` 暂时作为弃用别名保留一个版本。公开的 `wechat-bridge*` 命令和 Shell adapter 已移除；内部 bridge runtime 仍由直接命令和 daemon 自动管理。
+1.1.5 已移除完成弃用周期的 `wechat-*-start` 别名；请直接使用 `wechat-codex`、`wechat-claude`、`wechat-opencode` 或 `wechat-pi`。公开的 `wechat-bridge*` 命令和 Shell adapter 也已移除；内部 bridge runtime 仍由直接命令和 daemon 自动管理。
 
 ### Daemon CLI 参数
 
@@ -311,15 +309,24 @@ wechat-claude --model sonnet --dangerously-skip-permissions
 | `/codex [prompt]` / `/claude [prompt]` / `/opencode [prompt]` / `/pi [prompt]` | daemon 模式下切换活动 CLI；已有 CLI 会复用，没有则自动打开；可选 prompt 会在切换成功后立即转发 |
 | `/status` | 查看 bridge 当前状态 |
 | `/stop` | 中断当前任务 |
-| `/reset` | 重建当前本地会话 |
+| `/reset` | 重建当前本地会话 |
 | `/new` 或 `/new-session` | OpenCode 或 Pi 模式下新建 session |
-| `/confirm` / `/deny` | 处理 CLI 权限请求；需要一次性 code 的请求会在消息中提示具体确认格式 |
+| `/resume` / `/resume <编号或 ID 前缀>` | Codex、Claude Code、OpenCode 或 Pi 模式下列出并恢复当前工作目录的最近 thread/session；编号在列表显示后 5 分钟内有效 |
+| `/confirm` / `/deny` | 处理 CLI 权限请求；需要一次性 code 的请求会在消息中提示具体确认格式 |
 | `/daemon-stop` | daemon 模式下停止常驻进程 |
 | `/bindings` | 查看当前所有表情绑定 |
 | `/bind [表情] /命令` | 绑定表情到指定命令 |
 | `/unbind [表情]` | 解除指定表情的绑定 |
 
-说明：微信侧 `/resume` 目前暂时保持禁用；需要切换 Codex / Claude / OpenCode / Pi 会话时，优先在本地 companion 中使用 `/new` 或对应 CLI 的会话命令，微信会跟随本地活动会话。
+说明：微信侧 `/resume` 当前支持 Codex、Claude Code、OpenCode 和 Pi，并且只列出 daemon/bridge 启动目录内的最近 root thread/session。实际恢复会等待当前任务进入 idle；有任务、审批或待回答问题时请先处理，或使用 `/stop`。仍处于 active 状态的 Codex thread，以及仍在运行的 Claude background session，不允许从微信接管。
+
+OpenCode 和 Pi 的本地可见 TUI 会反向同步 session：在电脑端通过 picker、`/resume` 或新建会话切换后，微信自动跟随新的 session，并使之前显示的 `/resume` 编号列表失效。如果本地切换发生在微信任务仍在执行时，bridge 会中断旧任务、报告中断原因，再确认已经跟随新的本地 session，避免回复继续落入不可见的旧会话。
+
+Codex 通过 bridge 持有的持久 app-server 恢复 thread：`/resume` 使用 `thread/list` 获取同 cwd 的 CLI/VS Code 根 thread，选择后依次执行 `thread/read`、`thread/resume` 预检，再通过带随机 token 的 localhost supervisor 只替换可见 TUI 子进程。只有目标 `codex resume <thread-id> --remote ...` 客户端稳定启动后才提交 shared thread；失败时保持或恢复原可见 thread。电脑端 Codex picker 或 `/resume` 仍由 app-server 事件反向同步微信。
+
+Claude Code 使用官方 Hook 完成同样的双向确认：微信恢复会向当前 PTY提交精确 `/resume <UUID>`，并等待 `SessionEnd(reason=resume)` 与目标 `SessionStart(source=resume)`；电脑端 picker 或 `/resume` 产生相同 Hook 序列，bridge 会跟随新的 transcript。Claude 的本地输入和最终回答继续同步微信。
+
+Pi 的电脑端输入和最终回答都会同步到微信：微信先显示本地输入提示，再在 Pi `agent_settled` 后收到该 turn 的最终结果；微信发起的 Pi turn 仍只发送一次最终回复。
 
 ### 表情绑定
 

package/bin/_run-entry.mjs

@@ -57,15 +57,3 @@ export function runJsEntry(relativeEntryPath, extraArgs = []) {
     process.exit(code ?? 0);
   });
 }
-
-export function runDeprecatedJsEntry(
-  commandName,
-  replacementCommand,
-  relativeEntryPath,
-  extraArgs = [],
-) {
-  process.stderr.write(
-    `[cli-wechat-bridge] ${commandName} is deprecated; use ${replacementCommand}. This alias will be removed in the next release.\n`,
-  );
-  runJsEntry(relativeEntryPath, extraArgs);
-}

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) {
@@ -228,6 +551,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         return true;
     }
     async reset() {
+        this.rejectPendingResume(new Error("Claude was reset during session switching."));
         this.clearWechatWorkingNotice(true);
         this.pendingCliApprovalHints = null;
         this.runtimeSessionId = null;
@@ -295,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;
@@ -326,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 &&
@@ -385,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();
@@ -772,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);
@@ -836,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 &&
@@ -859,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;
@@ -879,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() : "";
@@ -1028,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;
@@ -1052,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));