cli-wechat-bridge 1.2.1 → 1.2.3

package/dist/bridge/adapter-control.js

@@ -1,3 +1,10 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (c) 2026 UNLINEARITY <unlinearity@gmail.com>
+// Source: https://github.com/UNLINEARITY/CLI-WeChat-Bridge
+// This file is part of CLI-WeChat-Bridge. Modifications and derivative works
+// must be released under AGPL-3.0-or-later with full source code; see
+// LICENSE.txt. Network services built on it must offer source to users.
+import { t } from "../i18n/index.js";
 const snapshots = new WeakMap();
 export const MODEL_SNAPSHOT_TTL_MS = 5 * 60_000;
 export function invalidateModelSnapshot(adapter) {
@@ -17,40 +24,40 @@ export async function handleAdapterControl(adapter, senderId, command) {
     try {
         if (command.type === "plan") {
             if (!adapter.setPlanMode)
-                throw new Error(`Plan mode is not available for ${name}.`);
+                throw new Error(t("control.plan.unavailable", { name }));
             const enabled = await adapter.setPlanMode(command.enabled);
             return enabled
-                ? `${name} plan mode enabled. Send /plan off to restore the previous mode.`
-                : `${name} plan mode disabled.`;
+                ? t("control.plan.enabled", { name })
+                : t("control.plan.disabled", { name });
         }
         if (!adapter.listModels || !adapter.selectModel)
-            throw new Error(`Model selection is not available for ${name}.`);
+            throw new Error(t("control.model.unavailable", { name }));
         const owner = snapshotOwner(adapter, senderId);
         if (!command.target) {
             snapshots.delete(adapter);
             const models = await adapter.listModels();
             if (snapshotOwner(adapter, senderId) !== owner)
-                throw new Error("The active session changed. Send /model again.");
+                throw new Error(t("control.model.sessionChanged"));
             if (!models.length)
-                return `${name} did not return any available models.`;
+                return t("control.model.empty", { name });
             snapshots.set(adapter, { owner, createdAtMs: Date.now(), models });
             return [
-                `Available ${name} models:`, "",
-                ...models.map((model, index) => `${index + 1}. ${model.displayName}${model.isCurrent ? "  (current)" : ""}`),
-                "", "Reply with /model <number> to switch. The list is valid for 5 minutes.",
+                t("control.model.header", { name }), "",
+                ...models.map((model, index) => `${index + 1}. ${model.displayName}${model.isCurrent ? t("control.model.current") : ""}`),
+                "", t("control.model.instructions"),
             ].join("\n");
         }
         const snapshot = snapshots.get(adapter);
         if (!snapshot || snapshot.owner !== owner || Date.now() - snapshot.createdAtMs > MODEL_SNAPSHOT_TTL_MS) {
-            throw new Error("The model list has expired or belongs to another session. Send /model again.");
+            throw new Error(t("control.model.expired"));
         }
         const index = Number(command.target);
         if (!/^\d+$/.test(command.target) || !Number.isSafeInteger(index) || index < 1 || index > snapshot.models.length) {
-            throw new Error("Model selection is outside the displayed range. Send /model again to refresh the list.");
+            throw new Error(t("control.model.range"));
         }
         const model = await adapter.selectModel(snapshot.models[index - 1].id);
         snapshots.delete(adapter);
-        return `${name} model switched to ${model.displayName}.`;
+        return t("control.model.changed", { name, model: model.displayName });
     }
     catch (error) {
         return error instanceof Error ? error.message : String(error);

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

@@ -14,7 +14,7 @@ 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";
-import { buildClaudeFailureMessage, buildClaudeHookScript, buildClaudeHookSettings, buildClaudePermissionDecisionHookOutput, buildClaudePermissionApprovalRequest, extractClaudeAssistantMessageText, extractClaudeResumeConversationId, extractClaudeTranscriptFinalReply, findInjectedClaudePromptIndex, getClaudePermissionAutoResponse, getClaudeWechatOutboundAttachmentDenyMessage, normalizeClaudeAssistantMessage, parseClaudeHookPayload, } from "./claude-hooks.js";
+import { buildClaudeFailureMessage, buildClaudeHookScript, buildClaudeHookSettings, buildClaudeUserInputRequest, buildClaudeUserInputHookOutput, buildClaudePermissionDecisionHookOutput, buildClaudePermissionApprovalRequest, extractClaudeAssistantMessageText, extractClaudeResumeConversationId, extractClaudeTranscriptFinalReply, findInjectedClaudePromptIndex, getClaudePermissionAutoResponse, getClaudeWechatOutboundAttachmentDenyMessage, normalizeClaudeAssistantMessage, parseClaudeHookPayload, } from "./claude-hooks.js";
 import { detectCliApproval, isThinkingForwardEnabled, } from "./bridge-utils.js";
 import { normalizeOutput, nowIso, truncatePreview } from "../core/text-utils.js";
 import { AbstractPtyAdapter } from "./bridge-adapters.core.js";
@@ -333,6 +333,9 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
     hookErrorLogPath = null;
     hookReceivedCount = 0;
     hookHealthCheckTimer = null;
+    resolvingHookApprovals = new Set();
+    pendingHookUserInputs = new Map();
+    resolvingHookUserInputs = new Set();
     pendingHookApprovals = new Map();
     recoveringInvalidResume = false;
     workingNoticeTimer = null;
@@ -341,7 +344,6 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
     lastCompactCompletionAtMs = 0;
     startupOutputBuffer = "";
     hasAutoConfirmedWorkspaceTrustPrompt = false;
-    lastAutoApprovedPayload = null;
     transcriptPollTimer = null;
     transcriptTailOffset = 0;
     polledTranscriptSessionId = null;
@@ -359,7 +361,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         isPromptEmpty: () => readClaudePermissionMode(this.terminalControl.text) !== null,
         assertReady: () => {
             if (!this.pty || this.state.status !== "idle" || this.pendingApproval || this.pendingResume) {
-                throw new Error("Claude must be idle with no pending approval before using remote controls.");
+                throw new Error(t("adapter.claude.controlsIdle"));
             }
         },
     });
@@ -369,6 +371,11 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
     async setPlanMode(enabled) { return this.nativeControls.setPlanMode(enabled); }
     constructor(options) {
         super(options);
+        this.state.supportsApprovalRequestIds = true;
+        this.state.supportsUserInputRequestIds = true;
+        this.state.pendingUserInput = null;
+        this.state.pendingApprovals = [];
+        this.state.pendingApproval = null;
         const shouldRestoreInitialSession = options.sessionStartMode !== "new";
         this.runtimeSessionId = shouldRestoreInitialSession
             ? options.initialSharedSessionId ?? options.initialSharedThreadId ?? null
@@ -431,26 +438,30 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
     }
     async sendInput(text) {
         if (this.terminalControl.active)
-            throw new Error("A Claude control operation is in progress.");
+            throw new Error(t("adapter.claude.controlActive"));
         if (!this.pty) {
-            throw new Error("claude adapter is not running.");
+            throw new Error(t("adapter.claude.notRunning"));
         }
         if (this.state.status === "busy") {
-            throw new Error("claude is still working. Wait for the current reply or use /stop.");
+            throw new Error(t("adapter.claude.busy"));
         }
         if (this.pendingApproval) {
-            throw new Error("A Claude approval request is pending. Reply with /confirm or /deny.");
+            throw new Error(t("adapter.claude.approvalPending"));
         }
+        if (this.state.status === "awaiting_input")
+            throw new Error(t("adapter.claude.inputPending"));
         await this.waitForInteractiveReadiness();
         if (!this.pty) {
-            throw new Error("claude adapter is not running.");
+            throw new Error(t("adapter.claude.notRunning"));
         }
         if (this.getState().status === "busy") {
-            throw new Error("claude is still working. Wait for the current reply or use /stop.");
+            throw new Error(t("adapter.claude.busy"));
         }
         if (this.pendingApproval) {
-            throw new Error("A Claude approval request is pending. Reply with /confirm or /deny.");
+            throw new Error(t("adapter.claude.approvalPending"));
         }
+        if (this.getState().status === "awaiting_input")
+            throw new Error(t("adapter.claude.inputPending"));
         const normalizedText = normalizeOutput(text).trim();
         this.clearRemoteSubmitRetry();
         this.pendingInjectedInputs.push({
@@ -477,18 +488,18 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
     }
     async resumeSession(sessionId) {
         if (this.terminalControl.active)
-            throw new Error("A CLI control operation is in progress. Wait for it to finish before switching sessions.");
+            throw new Error(t("adapter.claude.sessionControlActive"));
         if (!this.pty) {
-            throw new Error("Claude is not running yet.");
+            throw new Error(t("adapter.claude.notReady"));
         }
         if (this.pendingResume) {
-            throw new Error("Claude is already switching sessions.");
+            throw new Error(t("adapter.claude.switching"));
         }
         if (this.pendingApproval) {
-            throw new Error("A Claude approval request is pending. Reply with /confirm or /deny.");
+            throw new Error(t("adapter.claude.approvalPending"));
         }
         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.");
+            throw new Error(t("adapter.claude.switchBusy"));
         }
         if (this.state.status !== "idle") {
             throw new Error(`Claude cannot switch sessions while its status is ${this.state.status}.`);
@@ -606,7 +617,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
     }
     async reset() {
         if (this.terminalControl.active)
-            throw new Error("A CLI control operation is in progress. Wait for it to finish before switching sessions.");
+            throw new Error(t("adapter.claude.sessionControlActive"));
         this.rejectPendingResume(new Error("Claude was reset during session switching."));
         this.clearWechatWorkingNotice(true);
         this.pendingCliApprovalHints = null;
@@ -624,56 +635,42 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         await this.dispose();
         await this.start();
     }
-    async resolveApproval(action) {
-        if (!this.pendingApproval) {
-            return false;
-        }
-        if (this.pendingApproval.requestId) {
-            const handled = this.respondToClaudeHookApproval(this.pendingApproval.requestId, action);
+    async resolveApproval(action, requestId) {
+        const id = requestId ?? this.pendingApproval?.requestId;
+        if (id && this.pendingHookApprovals.has(id)) {
+            const handled = await this.respondToClaudeHookApproval(id, action);
             if (handled) {
                 this.clearWechatWorkingNotice();
-                this.pendingCliApprovalHints = null;
-                this.pendingApproval = null;
-                this.state.pendingApproval = null;
-                this.state.pendingApprovalOrigin = undefined;
-                this.setStatus("busy");
-                return true;
+                this.syncPendingHookApprovals();
             }
+            return handled;
         }
+        if (!this.pendingApproval || (requestId !== undefined && requestId !== this.pendingApproval.requestId))
+            return false;
+        // Hook requests never fall through to keystrokes after their socket expires.
+        if (this.pendingApproval.requestId)
+            return false;
         const input = action === "confirm" ? this.pendingApproval.confirmInput : this.pendingApproval.denyInput;
         if (!input) {
-            throw new Error("Remote approval is not safely available for this Claude prompt. Approve it in the local Claude terminal.");
+            throw new Error(t("adapter.claude.approvalLocal"));
         }
-        this.clearWechatWorkingNotice();
+        this.writeToPty(input);
         this.pendingCliApprovalHints = null;
         this.pendingApproval = null;
         this.state.pendingApproval = null;
         this.state.pendingApprovalOrigin = undefined;
         this.setStatus("busy");
-        this.writeToPty(input);
         return true;
     }
     async resolveAllApprovals(action) {
+        if (!this.pendingHookApprovals.size)
+            return await this.resolveApproval(action) ? 1 : 0;
         let count = 0;
-        for (const requestId of Array.from(this.pendingHookApprovals.keys())) {
-            const pending = this.pendingHookApprovals.get(requestId);
-            if (pending) {
-                this.pendingHookApprovals.delete(requestId);
-                this.respondToClaudeHook(pending.socket, requestId, buildClaudePermissionDecisionHookOutput(action));
+        for (const id of Array.from(this.pendingHookApprovals.keys())) {
+            if (await this.resolveApproval(action, id))
                 count++;
-            }
         }
-        if (count > 0) {
-            this.clearWechatWorkingNotice();
-            this.pendingCliApprovalHints = null;
-            this.pendingApproval = null;
-            this.state.pendingApproval = null;
-            this.state.pendingApprovalOrigin = undefined;
-            this.setStatus("busy");
-            return count;
-        }
-        const ok = await this.resolveApproval(action);
-        return ok ? 1 : 0;
+        return count;
     }
     async dispose() {
         this.terminalControl.cancel("Claude is shutting down.");
@@ -846,9 +843,12 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
                     }
                 });
                 const cleanupPendingRequestsForSocket = () => {
+                    for (const [requestId, pending] of this.pendingHookUserInputs.entries()) {
+                        if (pending.socket === socket)
+                            this.handleClosedClaudeHookUserInput(requestId);
+                    }
                     for (const [requestId, pending] of this.pendingHookApprovals.entries()) {
                         if (pending.socket === socket) {
-                            this.pendingHookApprovals.delete(requestId);
                             this.handleClosedClaudeHookApproval(requestId);
                         }
                     }
@@ -1271,35 +1271,42 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
                 this.handleClaudeUserPromptSubmit(payload);
                 this.respondToClaudeHook(params.socket, params.requestId);
                 return;
+            case "PreToolUse":
+                if (payload.tool_name === "AskUserQuestion") {
+                    this.handleClaudeUserInputRequest(params.requestId, payload, params.socket);
+                }
+                else {
+                    this.respondToClaudeHook(params.socket, params.requestId);
+                }
+                return;
+            case "PostToolUse":
+                if (payload.tool_name === "AskUserQuestion" && payload.tool_use_id) {
+                    let removed = false;
+                    for (const [id, pending] of this.pendingHookUserInputs) {
+                        if (pending.payload.tool_use_id === payload.tool_use_id) {
+                            this.pendingHookUserInputs.delete(id);
+                            removed = true;
+                            this.respondToClaudeHook(pending.socket, id);
+                        }
+                    }
+                    if (removed)
+                        this.syncPendingHookUserInputs();
+                }
+                this.respondToClaudeHook(params.socket, params.requestId);
+                return;
             case "PermissionRequest":
                 this.handleClaudePermissionRequest(params.requestId, payload, params.socket);
                 return;
             case "Notification":
                 if (payload.notification_type === "permission_prompt") {
-                    if (this.pendingApproval) {
+                    if (this.state.pendingUserInput) {
+                        this.setStatus("awaiting_input", "Claude is waiting for your answers.");
+                    }
+                    else if (this.pendingApproval) {
                         this.setStatus("awaiting_approval", "Claude approval is required.");
                     }
-                    else if (this.lastAutoApprovedPayload) {
-                        // Auto-approval response failed to reach Claude Code (socket closed before delivery).
-                        // Fall back to forwarding the approval request to WeChat.
-                        const fallbackPayload = this.lastAutoApprovedPayload;
-                        this.lastAutoApprovedPayload = null;
-                        const request = buildClaudePermissionApprovalRequest(fallbackPayload);
-                        this.pendingApproval = {
-                            ...request,
-                            requestId: undefined,
-                            confirmInput: this.pendingCliApprovalHints?.confirmInput,
-                            denyInput: this.pendingCliApprovalHints?.denyInput,
-                        };
-                        this.pendingCliApprovalHints = null;
-                        this.state.pendingApproval = this.pendingApproval;
-                        this.state.pendingApprovalOrigin = this.state.activeTurnOrigin;
-                        this.setStatus("awaiting_approval", "Claude auto-approval failed, forwarding to WeChat.");
-                        this.emit({
-                            type: "approval_required",
-                            request: this.pendingApproval,
-                            timestamp: nowIso(),
-                        });
+                    else {
+                        this.emitClaudeNotice("Claude is waiting for a local permission prompt that has no remote approval hook. Resolve it in the local terminal.", "warning");
                     }
                 }
                 this.respondToClaudeHook(params.socket, params.requestId);
@@ -1408,6 +1415,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         }
     }
     handleClaudeSessionEnd(payload) {
+        this.flushPendingClaudeHookApprovals();
         if (payload.reason !== "resume") {
             return;
         }
@@ -1506,65 +1514,59 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
     }
     handleClaudePermissionRequest(requestId, payload, socket) {
         this.clearWechatWorkingNotice();
-        this.lastAutoApprovedPayload = null;
+        if (payload.tool_name === "AskUserQuestion") {
+            this.handleClaudeUserInputRequest(requestId, { ...payload, hook_event_name: "PermissionRequest" }, socket);
+            return;
+        }
         const denyMessage = getClaudeWechatOutboundAttachmentDenyMessage(payload);
         if (denyMessage) {
-            this.pendingApproval = null;
-            this.state.pendingApproval = null;
-            this.state.pendingApprovalOrigin = undefined;
-            if (this.state.status === "awaiting_approval") {
-                this.setStatus("busy");
-            }
             this.respondToClaudeHook(socket, requestId, buildClaudePermissionDecisionHookOutput("deny", denyMessage));
             return;
         }
         const autoResponse = getClaudePermissionAutoResponse(payload);
         if (autoResponse) {
-            if (!this.pendingApproval && !this.state.pendingApproval) {
+            if (!this.pendingApproval && !this.state.pendingApproval && !this.state.pendingUserInput) {
                 this.setStatus("busy", `Claude approval auto-approved: ${truncatePreview(autoResponse.reason, 180)}`);
             }
-            this.lastAutoApprovedPayload = payload;
             this.respondToClaudeHook(socket, requestId, buildClaudePermissionDecisionHookOutput(autoResponse.action));
             return;
         }
-        this.flushPendingClaudeHookApprovals();
+        if (this.pendingHookApprovals.has(requestId))
+            return;
+        const request = {
+            ...buildClaudePermissionApprovalRequest(payload),
+            requestId,
+            confirmInput: this.pendingCliApprovalHints?.confirmInput,
+            denyInput: this.pendingCliApprovalHints?.denyInput,
+        };
         this.pendingHookApprovals.set(requestId, {
             requestId,
             socket,
+            request,
+            origin: this.state.activeTurnOrigin,
         });
-        const request = buildClaudePermissionApprovalRequest(payload);
-        this.pendingApproval = {
-            ...request,
-            requestId,
-            confirmInput: this.pendingApproval?.confirmInput ?? this.pendingCliApprovalHints?.confirmInput,
-            denyInput: this.pendingApproval?.denyInput ?? this.pendingCliApprovalHints?.denyInput,
-        };
         this.pendingCliApprovalHints = null;
+        this.syncPendingHookApprovals();
+    }
+    syncPendingHookApprovals() {
+        const previousId = this.pendingApproval?.requestId;
+        const entries = Array.from(this.pendingHookApprovals.values());
+        const requests = entries.map((pending) => pending.request);
+        this.pendingApproval = requests[0] ?? null;
         this.state.pendingApproval = this.pendingApproval;
-        this.state.pendingApprovalOrigin = this.state.activeTurnOrigin;
-        this.setStatus("awaiting_approval", "Claude approval is required.");
-        this.emit({
-            type: "approval_required",
-            request: this.pendingApproval,
-            timestamp: nowIso(),
-        });
+        this.state.pendingApprovals = requests;
+        this.state.pendingApprovalOrigin = entries[0]?.origin;
+        this.setStatus(requests.length ? "awaiting_approval" : this.state.pendingUserInput ? "awaiting_input" : "busy");
+        this.emit({ type: "approval_state_changed", requests, timestamp: nowIso() });
+        if (requests[0] && requests[0].requestId !== previousId) {
+            this.emit({ type: "approval_required", request: requests[0], timestamp: nowIso() });
+        }
     }
     handleClosedClaudeHookApproval(requestId) {
-        if (this.pendingApproval?.requestId !== requestId) {
+        if (!this.pendingHookApprovals.delete(requestId))
             return;
-        }
-        if (this.pendingApproval.confirmInput || this.pendingApproval.denyInput) {
-            this.pendingApproval = {
-                ...this.pendingApproval,
-                requestId: undefined,
-            };
-            this.state.pendingApproval = this.pendingApproval;
-            return;
-        }
-        this.pendingApproval = null;
-        this.state.pendingApproval = null;
-        this.state.pendingApprovalOrigin = undefined;
-        if (this.state.status === "awaiting_approval") {
+        this.syncPendingHookApprovals();
+        if (!this.pendingHookApprovals.size) {
             this.setStatus("awaiting_approval", "Claude approval must be resolved in the local terminal.");
         }
         this.emitClaudeNotice("Claude approval can no longer be resolved from WeChat. Approve it in the local Claude terminal.", "warning");
@@ -1600,7 +1602,6 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         this.clearRemoteSubmitRetry();
         this.clearWechatWorkingNotice(true);
         this.pendingCliApprovalHints = null;
-        this.lastAutoApprovedPayload = null;
         this.flushPendingClaudeHookApprovals();
         this.pendingApproval = null;
         this.state.pendingApproval = null;
@@ -1627,7 +1628,6 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
             payload.session_id !== this.runtimeSessionId) {
             return;
         }
-        this.lastAutoApprovedPayload = null;
         this.stopTranscriptThinkingWatch();
         this.failClaudeTurn(buildClaudeFailureMessage(payload));
     }
@@ -1727,14 +1727,102 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
             }
         }
     }
-    respondToClaudeHookApproval(requestId, action) {
+    async respondToClaudeHookApproval(requestId, action) {
         const pending = this.pendingHookApprovals.get(requestId);
         if (!pending) {
             return false;
         }
-        this.pendingHookApprovals.delete(requestId);
-        this.respondToClaudeHook(pending.socket, requestId, buildClaudePermissionDecisionHookOutput(action));
-        return true;
+        if (pending.socket.destroyed || pending.socket.writableEnded || this.resolvingHookApprovals.has(requestId))
+            return false;
+        this.resolvingHookApprovals.add(requestId);
+        try {
+            await this.writeClaudeHookResponse(pending.socket, requestId, buildClaudePermissionDecisionHookOutput(action));
+            this.pendingHookApprovals.delete(requestId);
+            return true;
+        }
+        catch {
+            return false;
+        }
+        finally {
+            this.resolvingHookApprovals.delete(requestId);
+        }
+    }
+    async writeClaudeHookResponse(socket, requestId, stdout) {
+        const response = `${JSON.stringify({ requestId, stdout })}\n`;
+        const candidate = socket;
+        if (!(candidate instanceof net.Socket)) {
+            socket.end(response);
+            return;
+        }
+        await new Promise((resolve, reject) => {
+            const cleanup = () => { socket.off("error", onError); socket.off("close", onClose); };
+            const onError = (error) => { cleanup(); reject(error); };
+            const onClose = () => { cleanup(); reject(new Error("Claude hook closed before its reply was written.")); };
+            socket.once("error", onError);
+            socket.once("close", onClose);
+            socket.end(response, () => { cleanup(); resolve(); });
+        });
+    }
+    handleClaudeUserInputRequest(requestId, payload, socket) {
+        const request = buildClaudeUserInputRequest(payload, requestId);
+        const existingAnswers = payload.tool_input?.answers;
+        if (!request || (existingAnswers && typeof existingAnswers === "object"
+            && request.questions.every((question) => {
+                const answer = existingAnswers[question.question];
+                return typeof answer === "string" && answer.trim();
+            }))) {
+            this.respondToClaudeHook(socket, requestId);
+            return;
+        }
+        if (this.pendingHookUserInputs.has(requestId))
+            return;
+        this.clearWechatWorkingNotice();
+        this.pendingHookUserInputs.set(requestId, { socket, payload, request, origin: this.state.activeTurnOrigin });
+        this.syncPendingHookUserInputs();
+    }
+    syncPendingHookUserInputs() {
+        const previousId = this.state.pendingUserInput?.requestId;
+        const head = this.pendingHookUserInputs.values().next().value;
+        this.state.pendingUserInput = head?.request ?? null;
+        this.state.pendingUserInputOrigin = head?.origin;
+        this.setStatus(head ? "awaiting_input" : this.pendingApproval ? "awaiting_approval" : "busy");
+        if (head && head.request.requestId !== previousId) {
+            this.emit({ type: "user_input_required", request: head.request, timestamp: nowIso() });
+        }
+    }
+    handleClosedClaudeHookUserInput(requestId) {
+        if (!this.pendingHookUserInputs.delete(requestId))
+            return;
+        this.syncPendingHookUserInputs();
+        if (!this.pendingHookUserInputs.size && !this.pendingApproval)
+            this.setStatus("awaiting_input");
+        this.emitClaudeNotice("Claude question hook expired or disconnected. Answer in the local Claude terminal, or use /stop.", "warning");
+    }
+    async submitUserInput(answers, requestId) {
+        const id = requestId ?? this.state.pendingUserInput?.requestId;
+        if (!id || id !== this.state.pendingUserInput?.requestId || this.resolvingHookUserInputs.has(id))
+            return false;
+        const pending = this.pendingHookUserInputs.get(id);
+        if (!pending || pending.socket.destroyed || pending.socket.writableEnded)
+            return false;
+        const stdout = buildClaudeUserInputHookOutput(pending.payload, pending.request, answers);
+        if (!stdout)
+            return false;
+        this.resolvingHookUserInputs.add(id);
+        try {
+            await this.writeClaudeHookResponse(pending.socket, id, stdout);
+            if (this.pendingHookUserInputs.get(id) !== pending)
+                return false;
+            this.pendingHookUserInputs.delete(id);
+            this.syncPendingHookUserInputs();
+            return true;
+        }
+        catch {
+            return false;
+        }
+        finally {
+            this.resolvingHookUserInputs.delete(id);
+        }
     }
     cancelPendingClaudeHookApproval(requestId) {
         const pending = this.pendingHookApprovals.get(requestId);
@@ -1745,8 +1833,24 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         this.pendingHookApprovals.delete(requestId);
     }
     flushPendingClaudeHookApprovals() {
+        const userInputs = Array.from(this.pendingHookUserInputs.entries());
+        this.pendingHookUserInputs.clear();
+        this.state.pendingUserInput = null;
+        this.state.pendingUserInputOrigin = undefined;
+        for (const [id, pending] of userInputs)
+            this.respondToClaudeHook(pending.socket, id);
+        const hadPending = this.pendingHookApprovals.size > 0;
+        if (userInputs.length && !hadPending)
+            this.setStatus(this.state.status);
         for (const requestId of Array.from(this.pendingHookApprovals.keys())) {
             this.cancelPendingClaudeHookApproval(requestId);
         }
+        this.state.pendingApprovals = [];
+        if (hadPending) {
+            this.pendingApproval = null;
+            this.state.pendingApproval = null;
+            this.state.pendingApprovalOrigin = undefined;
+            this.emit({ type: "approval_state_changed", requests: [], timestamp: nowIso() });
+        }
     }
 }