tailii-host 0.10.1 → 0.11.0

package/dist/hub/sessionHub.js

@@ -9,7 +9,7 @@ import { decodeHubClientLine, encodeHubMessage, } from "./hubProtocol.js";
 import { HISTORY_DONE_STREAM_ID, findTrailingTurnEndMarkerMs, findTrailingUserPromptText, } from "../chat/transcriptTailer.js";
 import { sameUsageLimitWait } from "../shared/usageLimitWait.js";
 import { PROTOCOL_V1, PROTOCOL_V2 } from "../protocol.js";
-import { ChatInjectionRejectedError, LoginCodeError } from "../backend/tmux.js";
+import { ChatInjectionRejectedError, LoginCodeError, SEND_NOW_BLOCKED_BY_DIALOG, SEND_NOW_EXPIRED_IN_QUEUE, } from "../backend/tmux.js";
 import { CodexAppServerManager } from "../codex/codexAppServer.js";
 import { CodexNativeTurnController, chatContentKey, } from "../codex/codexNativeTurnController.js";
 import { COLLABORATION_MODE_STREAM_ID as CODEX_COLLABORATION_MODE_STREAM_ID, CONTEXT_STREAM_ID as CODEX_CONTEXT_STREAM_ID, CONTEXT_WINDOW_STREAM_ID as CODEX_CONTEXT_WINDOW_STREAM_ID, MODEL_STREAM_ID as CODEX_MODEL_STREAM_ID, } from "../codex/codexRolloutTailer.js";
@@ -23,6 +23,12 @@ import { claudeTranscriptPathFor } from "../sessions/transcriptPath.js";
 const BACKFILL_STALL_TIMEOUT_MS = 15_000;
 const DELIVERED_RECEIPT_TTL_MS = 30 * 24 * 60 * 60 * 1_000;
 const MAX_DELIVERED_RECEIPTS_PER_SESSION = 10_000;
+/**
+ * 「今すぐ送信」が順番（先行する chat の注入）を待てる上限（ms）。engine は hub の応答を 30 秒で
+ * 諦める。それより後に chord を送ると、アプリに失敗と出した後で実行中のターンが打ち切られる。
+ * chord の後の確認（約 6 秒）と撮り直し（約 1.5 秒）を引いた残りより短くする。
+ */
+export const SEND_NOW_QUEUE_WAIT_LIMIT_MS = 20_000;
 /** 中断マーカーで done にした後、継続 hook（Pre/PostToolUse）の遅着 active を残響として無視する窓（ms）。 */
 const LATE_HOOK_AFTER_INTERRUPT_MS = 3_000;
 /**
@@ -376,6 +382,14 @@ export class SessionHub {
             else if (actor.pendingQuestion?.id !== message.questionId) {
                 this.sendTo(client, { type: "question_answer_result", id: message.id, status: "already_resolved" });
             }
+            else if (actor.cancellingQuestionId === message.questionId) {
+                // chat の注入がこの設問を Esc で閉じている最中（chat-cancel-choice）。いま回答キーを流すと、
+                // 閉じた後の入力欄へ落ちる。「回答済み」とは返さない: 閉じるのを諦めた場合、設問は未回答の
+                // まま残るのに、アプリは回答を捨ててしまう（設問シートも再表示ピルも無く、答える手段が消える）。
+                // 再試行できる失敗で返す（`unknown` → engine が `question_answer_failed` → アプリが 1s / 3s で
+                // 自動再送）。再送が届く頃には決着している: 閉じていれば `already_resolved`、諦めていれば受理。
+                this.sendTo(client, { type: "question_answer_result", id: message.id, status: "unknown" });
+            }
             else {
                 // first-wins の判定と clear は await を挟まず同期的に行い、勝者だけが注入する。
                 const answerRoute = actor.pendingQuestion.answerRoute;
@@ -397,7 +411,18 @@ export class SessionHub {
                 }
                 else {
                     this.injectionsInFlight += 1;
-                    void (this.options.questionInjector?.(message.answers, message.session) ?? Promise.resolve())
+                    // 回答キーの注入が終わるまで chat を注入しない（`chatDrainHeldByQuestion`）。
+                    actor.questionAnswerInjections += 1;
+                    // 同期 throw でも `.finally` を必ず通す（通らないと回答注入中の件数が戻らず、chat が
+                    // 永久に保留される）。
+                    let injection;
+                    try {
+                        injection = this.options.questionInjector?.(message.answers, message.session) ?? Promise.resolve();
+                    }
+                    catch (error) {
+                        injection = Promise.reject(error);
+                    }
+                    void injection
                         .catch((error) => {
                         this.options.log?.(`設問回答注入失敗: ${String(error)}`);
                         // 自己修復（question-answer-retry）: pendingQuestion を失ったまま TUI ダイアログが
@@ -425,6 +450,7 @@ export class SessionHub {
                     })
                         .finally(() => {
                         this.injectionsInFlight -= 1;
+                        actor.questionAnswerInjections -= 1;
                         void this.drainChatQueue(message.session, actor);
                     });
                 }
@@ -553,6 +579,13 @@ export class SessionHub {
         }
         if (message.type === "chat_send") {
             const actor = this.actor(message.session);
+            // 利用者が新しい発話で改めて「この設問に答えずに送る」を送った。閉じられなかった設問を
+            // もう一度だけ試す（失敗させた発話そのものの再送では試さない）。
+            if (message.cancelQuestionId !== undefined &&
+                actor.choiceCancelFailed?.questionId === message.cancelQuestionId &&
+                !actor.choiceCancelFailed.clientMessageIds.has(message.clientMessageId)) {
+                actor.choiceCancelFailed = null;
+            }
             if (hasDeliveredReceipt(actor.deletedChatMessageIds, message.clientMessageId)) {
                 this.sendTo(client, {
                     type: "chat_send_result", id: message.id, status: "failed",
@@ -639,6 +672,12 @@ export class SessionHub {
             void this.drainChatQueue(message.session, actor);
             return;
         }
+        if (message.type === "chat_send_now") {
+            const actor = this.actor(message.session);
+            actor.sendNowWaiters.push({ client, id: message.id, receivedAtMs: this.nowMs() });
+            void this.runSendNow(message.session, actor);
+            return;
+        }
         if (message.type === "pending_message_delete") {
             // 対象不在も成功だが、client 保存前 crash で同じ Outbox が復元されても実行しないよう
             // 削除 tombstone は durable に残す。actor 不在でもここだけは軽量 actor を作る。
@@ -783,6 +822,9 @@ export class SessionHub {
             }
             entry.waiters.length = 0;
         }
+        for (const waiter of actor.sendNowWaiters.splice(0)) {
+            this.sendTo(waiter.client, { type: "chat_send_now_result", id: waiter.id, status: "failed", error: reason });
+        }
         // drain が injector / App Server の await 中でも、復帰後に同じ actor 参照から次の旧入力へ
         // 進めないよう durable queue の実体も空にする。現在実行中の1件は復帰時のidentity検査で捨てる。
         actor.chatQueue.length = 0;
@@ -1316,13 +1358,12 @@ export class SessionHub {
             ownState.backfilling = false;
             if (reason !== "history-done") {
                 this.options.log?.(`audit backfill-force-finish session=${session} reason=${reason}`);
-                if (meta.agent === "codex") {
-                    this.sendTo(client, {
-                        type: "conversation_event", session, serverSeq: 0,
-                        payload: { type: "chat_output", v: PROTOCOL_V1,
-                            streamId: "pc:history-cancelled", role: "system", text: "", eof: true },
-                    });
-                }
+                // Claude も全履歴を begin/done で囲む。不完全な履歴を採用せず、iOS のバッファを解除する。
+                this.sendTo(client, {
+                    type: "conversation_event", session, serverSeq: 0,
+                    payload: { type: "chat_output", v: PROTOCOL_V1,
+                        streamId: "pc:history-cancelled", role: "system", text: "", eof: true },
+                });
             }
             if (actor.codexLive !== null) {
                 // codex は rollout(履歴) と app-server(live) が同じ発話を二重に表すため、履歴側が
@@ -1519,6 +1560,8 @@ export class SessionHub {
                 pendingCodexTurns: new Map(), startingCodexMessageIds: new Set(),
                 runtimeClaim: null, codexLive: null,
                 chatQueue: [], chatOrder: [], chatDrainRunning: false, chatDrainBlocked: false,
+                questionAnswerInjections: 0, cancellingQuestionId: null, choiceCancelFailed: null,
+                sendNowRunning: false, sendNowWaiters: [],
                 codexQueue: [], codexOrder: [], codexDrainRunning: false, codexDrainBlocked: false };
             this.actors.set(session, actor);
         }
@@ -1660,12 +1703,97 @@ export class SessionHub {
         actor.codexDrainBlocked = false;
         void this.drainCodexQueue(session, actor);
     }
+    /**
+     * 未回答の設問が chat の注入を止めているか。
+     *
+     * 設問ダイアログの表示中に本文を打つと選択肢へ落ちるので、原則は回答（または TUI 側での解消）まで
+     * durable queue に保留する。回答キーの注入中も同じ（受理の時点で `pendingQuestion` は clear
+     * 済みだが、pane にはまだ設問が出ている）。
+     *
+     * 例外は利用者が「この設問に答えずに送る」と決めた送信が queue にあるとき（chat-cancel-choice）:
+     * 設問を Esc で閉じてから注入するので保留しない。**`cancelQuestionId` がいま未回答の設問の id と
+     * 一致するときだけ**解く。利用者が見ていない別の設問（queue に残っていた送信が、後から出た
+     * 設問に出会う等）は閉じない。queue のどこかに 1 件あれば先頭から順に流す（FIFO を崩して
+     * 後続だけを先に送らない。先に保留されていた発話も同じ利用者の発話で、設問を閉じれば届けられる）。
+     * Codex の設問（App Server の request）は pane のダイアログではなく Esc で閉じられないため対象外。
+     */
+    chatDrainHeldByQuestion(actor) {
+        if (actor.questionAnswerInjections > 0)
+            return true;
+        const pending = actor.pendingQuestion;
+        if (pending === null)
+            return false;
+        if (pending.answerRoute !== "tui")
+            return true;
+        // 一度閉じられなかった設問は、利用者が新しい発話で改めて送るまで保留に戻す。
+        if (actor.choiceCancelFailed?.questionId === pending.id)
+            return true;
+        return !actor.chatQueue.some((entry) => entry.message.cancelQuestionId === pending.id);
+    }
+    /**
+     * 「今すぐ送信」を pane へ送る（chat-send-now）。chat の注入と同じ pane を触るので直列化する:
+     * 注入の最中なら終わるのを待ち（`drainChatQueue` の終わりで呼び直される）、送っている間は
+     * 注入を始めさせない。設問の表示中・回答キーの注入中は 1 キーも送らずに断る（chord は
+     * ダイアログでは効かず、キーだけが選択肢へ落ちる）。
+     */
+    async runSendNow(session, actor) {
+        if (actor.sendNowRunning || actor.chatDrainRunning || actor.sendNowWaiters.length === 0)
+            return;
+        // 待ちすぎた要求には chord を送らない（1 キーも送らずに失敗で返す）。
+        const expired = actor.sendNowWaiters.filter((waiter) => this.nowMs() - waiter.receivedAtMs > SEND_NOW_QUEUE_WAIT_LIMIT_MS);
+        const waiters = actor.sendNowWaiters.filter((waiter) => !expired.includes(waiter));
+        actor.sendNowWaiters.length = 0;
+        const reply = (outcome, targets = waiters) => {
+            this.options.log?.(`audit chat-send-now session=${auditValue(session)} status=${outcome.status}`);
+            for (const waiter of targets) {
+                this.sendTo(waiter.client, {
+                    type: "chat_send_now_result", id: waiter.id, status: outcome.status,
+                    ...("reason" in outcome ? { error: outcome.reason } : {}),
+                });
+            }
+        };
+        if (expired.length > 0)
+            reply({ status: "failed", reason: SEND_NOW_EXPIRED_IN_QUEUE }, expired);
+        if (waiters.length === 0) {
+            void this.drainChatQueue(session, actor);
+            return;
+        }
+        // 設問を Esc で閉じている最中（`cancellingQuestionId`）は chat の注入の中なので、上の
+        // `chatDrainRunning` で待っている。ここへ来るのは注入が終わった後だけ。
+        if (actor.questionAnswerInjections > 0 || actor.pendingQuestion?.answerRoute === "tui") {
+            reply({ status: "blocked", reason: SEND_NOW_BLOCKED_BY_DIALOG });
+            // 注入の終わりから呼ばれた場合、残りの queue の再開はこちらの役目（門番は drain 側が持つ）。
+            void this.drainChatQueue(session, actor);
+            return;
+        }
+        actor.sendNowRunning = true;
+        this.injectionsInFlight += 1;
+        let outcome;
+        try {
+            outcome = await (this.options.sendNowInjector?.(session) ??
+                Promise.resolve({ status: "failed", reason: "send-now is unavailable" }));
+        }
+        catch (error) {
+            outcome = { status: "failed", reason: error instanceof Error ? error.message : String(error) };
+        }
+        finally {
+            this.injectionsInFlight -= 1;
+            actor.sendNowRunning = false;
+        }
+        reply(outcome);
+        // 明示 kill / reaper kill が await 中に actor を廃棄していたら、古い queue を動かさない。
+        if (this.actors.get(session) !== actor)
+            return;
+        void this.drainChatQueue(session, actor);
+        void this.runSendNow(session, actor);
+    }
     async drainChatQueue(session, actor) {
-        if (actor.chatDrainRunning || actor.chatDrainBlocked || actor.pendingQuestion !== null)
+        if (actor.chatDrainRunning || actor.chatDrainBlocked || actor.sendNowRunning ||
+            this.chatDrainHeldByQuestion(actor))
             return;
         actor.chatDrainRunning = true;
         try {
-            while (actor.pendingQuestion === null) {
+            while (!this.chatDrainHeldByQuestion(actor)) {
                 const entry = actor.chatQueue[0];
                 if (entry === undefined)
                     break;
@@ -1676,6 +1804,12 @@ export class SessionHub {
                     break;
                 actor.chatQueue.shift();
                 this.injectionsInFlight += 1;
+                // この注入が閉じることになる設問（ここまで来て未回答の設問が残っているのは、それを指す
+                // `cancelQuestionId` 付きの送信が queue にあって保留が解けたときだけ）。注入の前に控える:
+                // await の間に別の設問へ替わっていたら触らない。
+                const cancelledQuestion = actor.pendingQuestion;
+                if (cancelledQuestion !== null)
+                    actor.cancellingQuestionId = cancelledQuestion.id;
                 try {
                     actor.injectingChatMessageIds.add(message.clientMessageId);
                     if (!this.persistChatReceipts()) {
@@ -1690,13 +1824,27 @@ export class SessionHub {
                         }
                         continue;
                     }
+                    const resolveCancelledQuestion = () => {
+                        if (cancelledQuestion === null || this.actors.get(session) !== actor ||
+                            actor.pendingQuestion?.id !== cancelledQuestion.id)
+                            return;
+                        this.setPendingQuestion(session, actor, null);
+                        this.broadcast({ type: "question_event", session, event: "dismiss", id: cancelledQuestion.id });
+                        this.options.log?.(`audit chat-cancel-choice session=${auditValue(session)} question=${auditValue(cancelledQuestion.id)}`);
+                    };
                     await (this.options.chatInjector?.(message.text, session, {
                         recordedPromptText: () => this.trailingUserPromptText(session),
+                        cancelChoice: cancelledQuestion !== null,
+                        // 閉じた時点で片付ける（続く本文の注入が失敗しても、TUI に設問はもう無い）。
+                        onChoiceCancelled: resolveCancelledQuestion,
                     }) ?? Promise.resolve());
                     // 明示 kill / reaper kill が注入 await 中に actor を廃棄した場合、同名の新 actorへ
                     // 古い receipt を復活させない。waiter は retireSession が既に失敗で解放している。
                     if (this.actors.get(session) !== actor)
                         continue;
+                    // 本文が入力欄へ届いた = 設問はもう pane を塞いでいない（閉じたのを見届けた場合に加え、
+                    // TUI 側で先に解消されていて dismiss だけが届いていなかった場合もここで片付く）。
+                    resolveCancelledQuestion();
                     actor.injectingChatMessageIds.delete(message.clientMessageId);
                     actor.pendingChatMessages.delete(message.clientMessageId);
                     removeOrderedID(actor.chatOrder, message.clientMessageId);
@@ -1725,6 +1873,15 @@ export class SessionHub {
                     // **非配達が確定**している。uncertain は「二重送信が怖くて消せない」分類なので、
                     // ここへ積むと削除不能・後続ブロックのゾンビになる（下のコメント参照）。
                     const rejectedBeforeSend = error instanceof LoginCodeError || error instanceof ChatInjectionRejectedError;
+                    // 設問を閉じられなかった（設問はまだ未回答で残っている）。後続の保留分で Esc を
+                    // 撃ち直さない。
+                    if (cancelledQuestion !== null && actor.pendingQuestion?.id === cancelledQuestion.id) {
+                        const failed = actor.choiceCancelFailed?.questionId === cancelledQuestion.id
+                            ? actor.choiceCancelFailed
+                            : { questionId: cancelledQuestion.id, clientMessageIds: new Set() };
+                        failed.clientMessageIds.add(message.clientMessageId);
+                        actor.choiceCancelFailed = failed;
+                    }
                     if (rejectedBeforeSend) {
                         removeOrderedID(actor.chatOrder, message.clientMessageId);
                     }
@@ -1744,12 +1901,20 @@ export class SessionHub {
                 }
                 finally {
                     this.injectionsInFlight -= 1;
+                    // 閉じ終えた（設問は片付いた）か、諦めた（設問は残っている = また回答を受け付ける）。
+                    if (cancelledQuestion !== null && actor.cancellingQuestionId === cancelledQuestion.id) {
+                        actor.cancellingQuestionId = null;
+                    }
                 }
             }
         }
         finally {
             actor.chatDrainRunning = false;
-            if (!actor.chatDrainBlocked && actor.pendingQuestion === null && actor.chatQueue.length > 0 &&
+            if (actor.sendNowWaiters.length > 0) {
+                // 注入が終わるのを待っていた「今すぐ送信」を先に流す（残りの queue はその後で再開する）。
+                void this.runSendNow(session, actor);
+            }
+            else if (!actor.chatDrainBlocked && !this.chatDrainHeldByQuestion(actor) && actor.chatQueue.length > 0 &&
                 actor.chatOrder[0] === actor.chatQueue[0]?.message.clientMessageId) {
                 void this.drainChatQueue(session, actor);
             }