tailii-host 0.5.0 → 0.7.0

package/dist/hub/sessionHub.js

@@ -6,11 +6,13 @@ import * as path from "node:path";
 import { bumpHeartbeat, listHeartbeatSessions, readHeartbeat, writeHeartbeat } from "../sessions/heartbeat.js";
 import { ensureDirectory0700 } from "../shared/paths.js";
 import { decodeHubClientLine, encodeHubMessage, } from "./hubProtocol.js";
-import { HISTORY_DONE_STREAM_ID } from "../chat/transcriptTailer.js";
+import { HISTORY_DONE_STREAM_ID, findTrailingTurnEndMarkerMs, findTrailingUserPromptText, } from "../chat/transcriptTailer.js";
 import { PROTOCOL_V1, PROTOCOL_V2 } from "../protocol.js";
+import { LoginCodeError } from "../backend/tmux.js";
 import { CodexAppServerManager } from "../codex/codexAppServer.js";
 import { CodexNativeTurnController, chatContentKey, } from "../codex/codexNativeTurnController.js";
 import { 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";
+import { claudeTranscriptPathFor } from "../sessions/transcriptPath.js";
 /**
  * backfilling 中の購読者は publishConversationEvent が丸ごと飛ばす。旗が立ちっぱなしになると
  * 「接続は健全なのに会話だけ永久に更新されない」実障害になるため、履歴が一定時間 1 行も進まな
@@ -20,6 +22,23 @@ import { CONTEXT_STREAM_ID as CODEX_CONTEXT_STREAM_ID, CONTEXT_WINDOW_STREAM_ID
 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;
+/** 中断マーカーで done にした後、継続 hook（Pre/PostToolUse）の遅着 active を残響として無視する窓（ms）。 */
+const LATE_HOOK_AFTER_INTERRUPT_MS = 3_000;
+/**
+ * 発火時刻付き hook を「既に終わったターンの遅着」とみなす古さの上限（ms）。hook は発火から
+ * 100〜300ms（高負荷でも数秒）で relay に届くので、終端マーカーよりそれ以上前に発火した hook が
+ * マーカーの後に届くことは無い。上限を切らないと、queued 発話の UserPromptSubmit が enqueue 時に
+ * 発火する版が現れた場合に、数秒後の dequeue で始まる生きたターンを idle に固定してしまう。
+ */
+const LATE_HOOK_MAX_AGE_MS = 3_000;
+/** ターンを始めない継続 hook か（新ターンの権威は UserPromptSubmit のみ）。 */
+function isContinuationHookEvent(event) {
+    return event === "PreToolUse" || event === "PostToolUse";
+}
+/** 既定の claude transcript 解決（sessions/transcriptPath.ts と同一規則）。 */
+function defaultTranscriptPathFor(meta) {
+    return claudeTranscriptPathFor(meta);
+}
 export class SessionHub {
     options;
     clients = new Map();
@@ -27,6 +46,7 @@ export class SessionHub {
     previewWatchers = new Set();
     actors = new Map();
     now;
+    nowMs;
     replayLimit;
     injectionsInFlight = 0;
     codexStartsInFlight = 0;
@@ -37,6 +57,7 @@ export class SessionHub {
     constructor(options) {
         this.options = options;
         this.now = options.now ?? (() => Math.floor(Date.now() / 1000));
+        this.nowMs = options.nowMs ?? (() => Date.now());
         this.replayLimit = options.replayLimit ?? 500;
     }
     get clientCount() { return this.clients.size; }
@@ -68,9 +89,68 @@ export class SessionHub {
             // (稼働中の hub は毎 tick bump しているので、直前まで生きていた heartbeat は必ず新しい)。
             if (this.now() - heartbeat.ts >= this.options.timeoutSeconds)
                 continue;
-            this.actor(session).processingSince = heartbeat.ts;
+            // 再起動前に利用者が中断して放置した会話は Stop hook が無く active のまま残る。engine の
+            // 再接続購読は newerThanMs 付きで履歴のマーカーを流さないため、tail 経由では二度と
+            // 観測できない。transcript 末尾を直接照合し、最後の発話が開始以降の中断マーカーなら
+            // 処理中に戻さず idle へ確定する。
+            const trailingInterruptMs = this.trailingInterruptMarkerMs(session);
+            if (trailingInterruptMs !== null && (heartbeat.sinceMs === undefined || trailingInterruptMs >= heartbeat.sinceMs)) {
+                // 再起動中に hook が新ターンの active を書いた直後なら上書きしない（読んだ内容と同じときだけ倒す）。
+                const latest = readHeartbeat(this.options.heartbeatDir, session);
+                const unchanged = latest !== null && latest.ts === heartbeat.ts && latest.state === heartbeat.state &&
+                    latest.event === heartbeat.event && latest.sinceMs === heartbeat.sinceMs;
+                if (!unchanged) {
+                    // 消えていた（kill 後の掃除）場合も再生成しない。
+                    this.options.log?.(`restore: heartbeat が更新されたため中断判定を見送る session=${session}`);
+                }
+                else {
+                    try {
+                        writeHeartbeat(this.options.heartbeatDir, session, { ts: this.now(), state: "idle", event: "restore-interrupted" });
+                    }
+                    catch (error) {
+                        this.options.log?.(`heartbeat 書込失敗: ${String(error)}`);
+                    }
+                    this.options.log?.(`restore: 中断済みのため処理中を復元しない session=${session}`);
+                    continue;
+                }
+            }
+            const actor = this.actor(session);
+            actor.processingSince = heartbeat.ts;
+            // 真の開始時刻は heartbeat の sinceMs（applyProcessing が書き、bump が保持する）。ts は
+            // 毎 tick bump されるので使えない。無ければ（hook 直書きの heartbeat・旧形式）復元時刻を
+            // 境界にする: 再起動前の中断は上の transcript 照合が担い、再起動後の中断は必ずこれより
+            // 新しい。null（全採用）にすると、開き直しの全履歴再生で流れる過去ターンのマーカーが
+            // 進行中ターンを落とす。
+            actor.processingSinceMs = heartbeat.sinceMs ?? this.nowMs();
         }
     }
+    /**
+     * 復元時の照合用: transcript 末尾のターン終端マーカー（中断確定 / API エラー終端）の timestamp
+     * （claude 会話のみ。不明は null）。
+     */
+    trailingInterruptMarkerMs(session) {
+        const meta = this.options.metadataStore.get(session);
+        if (meta === null || meta.agent === "codex")
+            return null;
+        const transcriptPath = (this.options.transcriptPathFor ?? defaultTranscriptPathFor)(meta);
+        if (transcriptPath === null)
+            return null;
+        return findTrailingTurnEndMarkerMs(transcriptPath);
+    }
+    /**
+     * chat 注入前の残存テキスト照合用: transcript 末尾に記録済みの直近の発話本文（claude 会話のみ。
+     * 不明は null）。中断で入力欄へ書き戻された配送済み発話を Enter で送り直さないための材料
+     * （restored-prompt-discard。詳細は `findTrailingUserPromptText`）。
+     */
+    trailingUserPromptText(session) {
+        const meta = this.options.metadataStore.get(session);
+        if (meta === null || meta.agent === "codex")
+            return null;
+        const transcriptPath = (this.options.transcriptPathFor ?? defaultTranscriptPathFor)(meta);
+        if (transcriptPath === null)
+            return null;
+        return findTrailingUserPromptText(transcriptPath);
+    }
     /** 永続化済み設問を復元する。App Server の request handle は再起動を越せないため TUI のみ対象。 */
     restorePendingQuestions() {
         const restored = this.readPendingQuestions();
@@ -207,8 +287,10 @@ export class SessionHub {
             if (message.event === "dismiss")
                 void this.drainChatQueue(message.session, actor);
         }
-        else if (message.type === "session_processing")
-            this.applyProcessing(message.session, message.state);
+        else if (message.type === "session_processing") {
+            if (!this.applyProcessing(message.session, message.state, message.event, message.atMs))
+                return;
+        }
         this.broadcast(message);
     }
     handleClientMessage(client, line) {
@@ -553,7 +635,8 @@ export class SessionHub {
                 actor.runtimeClaim = null;
             return;
         }
-        this.applyProcessing(message.session, message.state);
+        if (!this.applyProcessing(message.session, message.state, message.event, message.atMs))
+            return;
         this.broadcast(message);
     }
     async tick() {
@@ -662,11 +745,18 @@ export class SessionHub {
         actor.uncertainCodexMessages.clear();
         actor.deletedCodexMessageIds.clear();
         actor.pendingQuestion = null;
+        const retiredSubscribers = [...actor.subscribers.keys()];
         actor.focusedBy.clear();
         actor.subscribers.clear();
         this.actors.delete(session);
         this.persistPendingQuestions();
         this.persistChatReceipts();
+        // 購読者（engine）へ購読消滅を知らせる（背景購読の台帳同期。一覧向け liveness とは別経路）。
+        // actor を消した後に送る: 受け手が同期的に再購読（前面会話の張り直し）しても、消える直前の
+        // 古い actor に付いて一緒に捨てられないように（新しい actor が生成される）。
+        for (const subscriber of retiredSubscribers) {
+            this.sendTo(subscriber, { type: "conversation_retired", session });
+        }
     }
     subscribe(client, session, afterSeq, newerThanMs, preview) {
         const actor = this.actor(session);
@@ -699,6 +789,10 @@ export class SessionHub {
             else {
                 this.syncPreview(session, actor);
             }
+            // 会話を開き直したとき（pump は一覧 watch で稼働中）、静止した入力待ちダイアログの
+            // フレームは変化しないので再送しないと転写カードが出ない。
+            if (preview && !wasPreview)
+                actor.previewPump?.resendLastIfInteractive?.();
             // preview=false 中に engine が route できなかった image/subagent event を、同じ
             // subscriber の前面昇格時にも afterSeq から回収する。既存購読だからと no-op にしない。
             if (!existing.backfilling && afterSeq !== undefined) {
@@ -723,6 +817,8 @@ export class SessionHub {
         }
         // 初回 backfill が同期的に多数の行を生成する前に pane capture を開始する。
         this.syncPreview(session, actor);
+        if (preview)
+            actor.previewPump?.resendLastIfInteractive?.();
         if (first) {
             this.startSharedTail(session, actor, newerThanMs ?? null);
             // processing 完了で一度 unsubscribe された後も、actor の replay buffer が残る間は
@@ -798,13 +894,15 @@ export class SessionHub {
             return;
         const tail = this.options.tailFactory((payload) => {
             this.publishConversationEvent(session, actor, payload);
-        });
+        }, undefined, (event) => this.handleClaudeTurnLifecycle(session, actor, event));
         actor.tail = tail;
         tail.open(meta.cwd, meta.providerSessionId ?? meta.claudeSessionId ?? null, newerThanMs, meta.agent ?? "claude");
     }
     startCodexSharedStream(session, actor, cwd, threadId, newerThanMs) {
         const state = {
-            phase: "starting",
+            phase: "backfill",
+            snapshotReady: false,
+            historyDone: false,
             initialItemIds: new Set(),
             initialContentCounts: new Map(),
             buffered: [],
@@ -813,12 +911,21 @@ export class SessionHub {
             scanContentCounts: new Map(),
             fallbackBaselineCounts: new Map(),
             disconnected: false,
+            lastModel: null,
+            subscribedModel: null,
+            scanLastModel: null,
         };
         actor.codexLive = state;
+        // 履歴表示は rollout だけで完結する。App Server の購読（daemon 起動・接続・thread/resume・
+        // 履歴スナップショット。巨大 thread では items/list が 3 秒で timeout してから復旧接続へ進む）
+        // の完了を待ってから rollout を開くと、その間 iOS は「会話を読み込み中…」のまま止まって
+        // 見える。rollout の backfill を先に始め、購読は並行して確立する。境界照合（flushCodexBuffer）
+        // は history-done と snapshot の両方が揃った時点で行う（順序不定）。
+        this.openCodexRollout(session, actor, cwd, threadId, newerThanMs);
         const controller = this.ensureCodexTurnController();
         const subscribe = controller.subscribeSession;
         if (subscribe === undefined) {
-            this.startCodexFallback(session, actor, cwd, threadId, newerThanMs, false);
+            this.degradeCodexToFallback(session, actor, state, null);
             return;
         }
         void subscribe.call(controller, { session, threadId, cwd }).then((snapshot) => {
@@ -826,20 +933,61 @@ export class SessionHub {
                 return;
             state.initialItemIds = snapshot.itemIds;
             state.initialContentCounts = snapshot.contentCounts;
+            // 会話を開いていない間の /model や設定変更は thread/settings/updated が誰にも届かない。
+            // resume 応答の現在モデルを backfill 完了後に配信し、開き直しで表示を実体へ揃える。
+            state.subscribedModel = snapshot.model ?? null;
             if (!snapshot.liveSubscribed) {
-                this.options.log?.("Codex App Server は未materialize threadをlive購読できないため、rollout fallbackへ移行");
-                this.startCodexFallback(session, actor, cwd, threadId, newerThanMs, false);
+                this.options.log?.(`Codex App Server の履歴スナップショットが読めない（turn 前の未materialize か履歴読み取り失敗）ため、rollout fallbackへ移行 session=${session} thread=${threadId}` +
+                    (snapshot.liveSubscriptionError ? `（理由: ${snapshot.liveSubscriptionError}）` : ""));
+                this.degradeCodexToFallback(session, actor, state, null);
                 return;
             }
-            state.phase = "backfill";
-            this.openCodexRollout(session, actor, cwd, threadId, newerThanMs);
+            state.snapshotReady = true;
+            if (state.historyDone)
+                this.finishCodexBackfill(session, actor, state);
         }, (error) => {
             if (actor.codexLive !== state || actor.subscribers.size === 0)
                 return;
-            this.options.log?.(`Codex App Server 購読失敗、rollout fallback へ移行: ${String(error)}`);
-            this.startCodexFallback(session, actor, cwd, threadId, newerThanMs, false);
+            this.degradeCodexToFallback(session, actor, state, `Codex App Server 購読失敗、rollout fallback へ移行: ${String(error)}`);
         });
     }
+    /**
+     * 購読が成立しない（未materialize・履歴読み取り失敗・購読エラー）と分かった時点で、既に開いて
+     * いる rollout tail をそのまま一次ソースに降格する。tail を開き直すと履歴を頭から二重再生する
+     * ため再利用する（接続断と同じ扱い: history-done で fallback-live へ、到達済みなら即座に）。
+     */
+    degradeCodexToFallback(session, actor, state, logMessage) {
+        if (logMessage !== null)
+            this.options.log?.(logMessage);
+        state.disconnected = true;
+        state.buffered.length = 0;
+        if (state.phase === "backfill" && state.historyDone)
+            this.finishCodexBackfill(session, actor, state);
+    }
+    /** backfill 完了（history-done）と購読の確定（snapshot または fallback）が揃った時点の切り替え。 */
+    finishCodexBackfill(session, actor, state) {
+        // 履歴末尾の turn_context より新しい設定変更（turn 未実行）は rollout に無い。
+        // 購読時の thread モデルで上書きする（同値なら畳む）。fallback でも resume が
+        // 成立していれば同じ。
+        const subscribedModel = state.subscribedModel;
+        state.subscribedModel = null;
+        if (state.disconnected) {
+            // fallback 確定前に届いた App Server item は、この継続 rollout と同じ内容を
+            // 別 streamId で持ち得る。rollout を唯一の一次ソースにした時点で破棄し、
+            // history 完了時に flush して会話全体を二重表示しない。
+            state.buffered.length = 0;
+            state.phase = "fallback-live"; // この tail は既に同じ EOF 境界にいるので継続利用する。
+        }
+        else {
+            this.flushCodexBuffer(session, actor, state);
+            state.phase = "live";
+            // 本文は以後 App Server のみを採用するが、rollout tail 自体は lifecycle の
+            // 副監視として残す。ここで止めると、後続 turn の App Server `turn/completed`
+            // 欠落時に terminal event（task_complete / turn_aborted）を観測できず、
+            // 処理中状態を自己修復できない。
+        }
+        this.publishCodexModelMarker(session, actor, state, subscribedModel);
+    }
     openCodexRollout(session, actor, cwd, threadId, newerThanMs) {
         if (this.options.tailFactory === undefined)
             return;
@@ -852,11 +1000,27 @@ export class SessionHub {
                 return;
             const isHistoryDone = payload.type === "chat_output" && payload.streamId === HISTORY_DONE_STREAM_ID;
             const contentKey = chatContentKey(payload);
+            const isModelMarker = payload.type === "chat_output" && payload.streamId === CODEX_MODEL_STREAM_ID;
+            // rollout の turn_context は「その turn で実際に使ったモデル」の唯一の記録。live 中も
+            // fallback 中も本文とは独立に通し、App Server 通知（onModel）と同値なら畳む。
+            // token 系 marker は App Server の tokenUsage と意味が異なるため従来どおり混ぜない。
+            if (isModelMarker && state.phase !== "backfill") {
+                if (state.phase === "fallback-scan") {
+                    // 再走査は履歴を頭から読み直す。旧 turn のモデルを一度配って戻すのではなく、
+                    // 走査完了時に最後の値だけを配る。
+                    state.scanLastModel = payload.text;
+                    return;
+                }
+                this.publishCodexModelMarker(session, actor, state, payload.text);
+                return;
+            }
             if (state.phase === "live")
                 return; // 正常時の live 本文は App Server のみ。
             if (state.phase === "fallback-scan") {
                 if (isHistoryDone) {
                     state.phase = "fallback-live";
+                    this.publishCodexModelMarker(session, actor, state, state.scanLastModel);
+                    state.scanLastModel = null;
                     return; // 通常 backfill の pc:history-done を再送しない。
                 }
                 if (contentKey === null)
@@ -873,30 +1037,22 @@ export class SessionHub {
                     this.publishCodexContent(session, actor, state, payload);
                 return;
             }
-            // App Server 購読を先に確立して通知を buffer し、その後 rollout を EOF まで読む。
+            // rollout を EOF まで読みつつ、App Server 購読は並行して確立し通知を buffer する。
             // resume 応答の item ID / content occurrence を境界スナップショットとして使い、
-            // EOF 後は rollout にまだ無い buffered item だけを flush する。event_msg 自体には
-            // item ID が無いため、同文は Set ではなく occurrence count で照合する。
+            // 両方が揃った時点で rollout にまだ無い buffered item だけを flush する。event_msg
+            // 自体には item ID が無いため、同文は Set ではなく occurrence count で照合する。
+            // snapshot がまだなら backfill のまま留まり、EOF 以降に rollout へ追記された行も
+            // この経路で配信する（snapshot 側の occurrence と後で照合されるので重複しない）。
             this.publishConversationEvent(session, actor, payload);
             if (contentKey !== null)
                 incrementCount(state.publishedContentCounts, contentKey);
+            if (isModelMarker)
+                state.lastModel = payload.text;
             if (!isHistoryDone)
                 return;
-            if (state.disconnected) {
-                // fallback 確定前に届いた App Server item は、この継続 rollout と同じ内容を
-                // 別 streamId で持ち得る。rollout を唯一の一次ソースにした時点で破棄し、
-                // history 完了時に flush して会話全体を二重表示しない。
-                state.buffered.length = 0;
-                state.phase = "fallback-live"; // この tail は既に同じ EOF 境界にいるので継続利用する。
-            }
-            else {
-                this.flushCodexBuffer(session, actor, state);
-                state.phase = "live";
-                // 本文は以後 App Server のみを採用するが、rollout tail 自体は lifecycle の
-                // 副監視として残す。ここで止めると、後続 turn の App Server `turn/completed`
-                // 欠落時に terminal event（task_complete / turn_aborted）を観測できず、
-                // 処理中状態を自己修復できない。
-            }
+            state.historyDone = true;
+            if (state.snapshotReady || state.disconnected)
+                this.finishCodexBackfill(session, actor, state);
         }, (event) => {
             if (actor.codexLive !== state || event.state !== "done")
                 return;
@@ -920,7 +1076,7 @@ export class SessionHub {
         // 一次ソースにし、運良く届いた App Server item を backfill buffer へ混ぜて重複させない。
         if (state.disconnected)
             return;
-        if (state.phase === "starting" || state.phase === "backfill") {
+        if (state.phase === "backfill") {
             // tool_activity は buffer せず捨てる。履歴は rollout（backfill）側が同じカードを
             // 供給するのが正で、live 由来と rollout 由来のカードは id が一致しないため
             // snapshot occurrence 照合に混ぜると開くたびに重複しうる。backfill 中に完了した
@@ -984,26 +1140,32 @@ export class SessionHub {
         const state = actor?.codexLive;
         if (actor === undefined || state == null || actor.subscribers.size === 0)
             return;
-        this.options.log?.(`Codex App Server 接続断、rollout fallback へ移行: ${String(error)}`);
-        state.disconnected = true;
-        if (state.phase === "starting" || state.phase === "backfill")
+        const logMessage = `Codex App Server 接続断、rollout fallback へ移行: ${String(error)}`;
+        if (state.phase === "backfill") {
+            // backfill 中（snapshot 待ちを含む）の切断は、開いている rollout tail をそのまま一次ソースにする。
+            this.degradeCodexToFallback(session, actor, state, logMessage);
             return;
+        }
+        this.options.log?.(logMessage);
+        state.disconnected = true;
         if (state.phase !== "live")
             return;
         const meta = this.options.metadataStore.get(session);
         if (meta === null)
             return;
-        this.startCodexFallback(session, actor, meta.cwd, meta.providerSessionId ?? meta.claudeSessionId ?? null, null, true);
+        this.startCodexFallbackRescan(session, actor, meta.cwd, meta.providerSessionId ?? meta.claudeSessionId ?? null, null);
     }
-    startCodexFallback(session, actor, cwd, threadId, newerThanMs, rescan) {
+    /** live 移行後の接続断: rollout を頭から再走査し、配信済み本文を occurrence 照合で除外して継続する。 */
+    startCodexFallbackRescan(session, actor, cwd, threadId, newerThanMs) {
         const state = actor.codexLive;
         if (state === null)
             return;
         actor.tail?.stop();
-        state.phase = rescan ? "fallback-scan" : "backfill";
+        state.phase = "fallback-scan";
         state.disconnected = true;
         state.buffered.length = 0;
         state.scanContentCounts.clear();
+        state.scanLastModel = null;
         state.fallbackBaselineCounts = new Map(state.publishedContentCounts);
         this.openCodexRollout(session, actor, cwd, threadId, newerThanMs);
     }
@@ -1012,6 +1174,16 @@ export class SessionHub {
         if (key !== null)
             incrementCount(state.publishedContentCounts, key);
         this.publishConversationEvent(session, actor, payload);
+        if (payload.type === "chat_output" && payload.role === "user" && this.options.imageService !== undefined) {
+            // 本文配信は止めず、完成したサムネを同じ streamId へ後着させる。
+            void this.options.imageService.makeAttachmentsAvailable(payload.text, payload.streamId).then((images) => {
+                // サムネ生成中の離脱/再購読/actor 破棄で、古い会話へ届かせない。
+                if (this.actors.get(session) !== actor || actor.codexLive !== state || actor.subscribers.size === 0)
+                    return;
+                for (const image of images)
+                    this.publishConversationEvent(session, actor, image);
+            }, (error) => this.options.log?.(`Codex 添付サムネ生成失敗 session=${session}: ${String(error)}`));
+        }
     }
     publishConversationEvent(session, actor, payload) {
         const event = { serverSeq: actor.nextServerSeq++, payload };
@@ -1068,6 +1240,13 @@ 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 },
+                    });
+                }
             }
             if (actor.codexLive !== null) {
                 // codex は rollout(履歴) と app-server(live) が同じ発話を二重に表すため、履歴側が
@@ -1101,6 +1280,14 @@ export class SessionHub {
                     this.sendTo(client, { type: "conversation_event", session, ...event });
                 }
             }
+            // 後から加わった client の履歴には、turn を伴わない設定変更（境界前に配信済みの
+            // thread/settings/updated）が含まれない。会話の現在モデルを最後に 1 回添えて揃える。
+            const currentModel = actor.codexLive?.lastModel ?? null;
+            if (currentModel !== null) {
+                this.sendTo(client, {
+                    type: "conversation_event", session, serverSeq: 0, payload: codexModelMarker(currentModel),
+                });
+            }
         };
         // 進捗は「最後に 1 行流れた時刻」で測る。履歴行ごとに setTimeout を張り替えると
         // 巨大な transcript でタイマー生成が支配的になるため、タイマーは 1 本のまま残時間を見る。
@@ -1220,7 +1407,9 @@ export class SessionHub {
     actor(session) {
         let actor = this.actors.get(session);
         if (actor === undefined) {
-            actor = { pendingQuestion: null, processingSince: null, focusedBy: new Set(), subscribers: new Map(),
+            actor = { pendingQuestion: null, processingSince: null, processingSinceMs: null, lastInterruptDoneMs: null,
+                lastTurnEndMs: null, turnStartFiredAtMs: null, lastTurnStartMs: null,
+                focusedBy: new Set(), subscribers: new Map(),
                 nextServerSeq: 1, replayBuffer: [], tail: null, tailRetryTimer: null,
                 previewPump: null, backfillTails: new Map(),
                 seenClientMessageIds: new Set(), deliveredChatMessageIds: new Map(),
@@ -1402,7 +1591,9 @@ export class SessionHub {
                         }
                         continue;
                     }
-                    await (this.options.chatInjector?.(message.text, session) ?? Promise.resolve());
+                    await (this.options.chatInjector?.(message.text, session, {
+                        recordedPromptText: () => this.trailingUserPromptText(session),
+                    }) ?? Promise.resolve());
                     // 明示 kill / reaper kill が注入 await 中に actor を廃棄した場合、同名の新 actorへ
                     // 古い receipt を復活させない。waiter は retireSession が既に失敗で解放している。
                     if (this.actors.get(session) !== actor)
@@ -1428,14 +1619,25 @@ export class SessionHub {
                         continue;
                     actor.injectingChatMessageIds.delete(message.clientMessageId);
                     actor.pendingChatMessages.delete(message.clientMessageId);
-                    actor.uncertainChatMessages.set(message.clientMessageId, message);
+                    // `/login` 中の門番（LoginCodeError）は 1 キーも送る前の確定拒否 = 非配達が確定している。
+                    // uncertain（配送不明）に積むと削除不能・後続ブロックのゾンビになるので、失敗として
+                    // そのまま片付ける。それ以外の注入失敗は従来どおり配送不明として明示再送に倒す。
+                    const rejectedBeforeSend = error instanceof LoginCodeError;
+                    if (rejectedBeforeSend) {
+                        removeOrderedID(actor.chatOrder, message.clientMessageId);
+                    }
+                    else {
+                        actor.uncertainChatMessages.set(message.clientMessageId, message);
+                    }
                     this.persistChatReceipts();
+                    // 利用者向け文言だけを出す（`String(error)` は `LoginCodeError: …` と型名が前置される）。
+                    const userText = rejectedBeforeSend && error instanceof Error ? error.message : String(error);
                     for (const waiter of entry.waiters) {
                         this.sendTo(waiter.client, {
-                            type: "chat_send_result", id: waiter.id, status: "failed", error: String(error),
+                            type: "chat_send_result", id: waiter.id, status: "failed", error: userText,
                         });
                     }
-                    this.publishCodexMarker(session, `chat-send-error-${message.id}`, `⚠️ メッセージ送信失敗: ${String(error)}`);
+                    this.publishCodexMarker(session, `chat-send-error-${message.id}`, `⚠️ メッセージ送信失敗: ${userText}`);
                     this.options.log?.(`chat 注入失敗 session=${session}: ${String(error)}`);
                 }
                 finally {
@@ -1454,11 +1656,13 @@ export class SessionHub {
     ensureCodexTurnController() {
         if (this.codexTurnController !== null)
             return this.codexTurnController;
-        const appServer = (this.options.codexAppServerFactory ?? (() => new CodexAppServerManager()))();
+        const appServer = (this.options.codexAppServerFactory ??
+            (() => new CodexAppServerManager({ ...(this.options.log ? { log: this.options.log } : {}) })))();
         const create = this.options.codexTurnControllerFactory ??
             ((options) => new CodexNativeTurnController(options));
         this.codexTurnController = create({
             appServer,
+            log: (message) => this.options.log?.(message),
             onProcessing: (session, state) => {
                 if (state === "active")
                     this.activeCodexTurns.add(session);
@@ -1596,18 +1800,171 @@ export class SessionHub {
     }
     publishCodexMarker(session, streamId, text) {
         const actor = this.actor(session);
+        if (streamId === CODEX_MODEL_STREAM_ID && actor.codexLive !== null) {
+            this.publishCodexModelMarker(session, actor, actor.codexLive, text);
+            return;
+        }
         this.publishConversationEvent(session, actor, {
             type: "chat_output", v: PROTOCOL_V1, streamId, role: "system", text, eof: true,
         });
     }
-    applyProcessing(session, state) {
+    /**
+     * 利用中モデルの marker を、直前に配信した値と異なるときだけ配信する。App Server 通知
+     * （thread/settings/updated / model/rerouted）・rollout の turn_context・購読時の
+     * thread モデルは同じ値を別経路で運ぶため、ここで 1 本に畳む。
+     */
+    publishCodexModelMarker(session, actor, state, model) {
+        if (model === null || model.length === 0 || state.lastModel === model)
+            return;
+        state.lastModel = model;
+        this.publishConversationEvent(session, actor, codexModelMarker(model));
+    }
+    /**
+     * transcript の中断確定マーカーで処理完了を補完する。Claude Code の Stop hook は利用者の中断
+     * （Esc / Ctrl-C）では発火しないため、hook だけでは処理中状態がターン終了後も残り、iOS は
+     * 会話を開き直す・再接続するたびに停止ボタン/処理中表示を張り直してしまう（実機 09-02）。
+     * 共有 tail は購読の張り直しで履歴から再生されるため、マーカーの timestamp が現ターンの
+     * 処理開始時刻以降のものだけを採用する（過去ターンのマーカーで進行中ターンを落とさない）。
+     *
+     * 時刻の比較根拠: `processingSinceMs` は UserPromptSubmit hook を hub が受信した時刻（ターン
+     * 開始。継続 hook では進めない）。中断→即再送信（実測 10〜200ms 後）でも、新ターンの hook
+     * 受信は必ずマーカー書込より後（同一マシンの時計・因果順）なので、マーカーは新ターンの開始
+     * より古く見えて棄却される。tail がマーカーを hook より先に届けた場合は前ターンを done に
+     * し、直後の UserPromptSubmit で active に戻る。中断直後に遅着する Pre/PostToolUse の active
+     * は `applyProcessing` が残響として無視する。
+     *
+     * 副作用は hook の Stop と同じ `applyProcessing("done")` 一式（heartbeat idle。設問提示中なら
+     * その dismiss と chat queue の drain）。中断はターン終了なので Stop 後と同じ振る舞い。
+     */
+    handleClaudeTurnLifecycle(session, actor, event) {
+        // API エラー終端（使用量上限 429「You've hit your session limit」等）も中断と同じ扱い: Stop hook が
+        // 発火しないままターンが終わるため、hub の処理中状態がそのまま残る（実機 2026-09-07: 制限到達後の
+        // 会話が停止ボタン点灯のまま固まり、開き直しても履歴再生が走らず送信が queued で止まった）。
+        if (this.actors.get(session) !== actor)
+            return;
+        if (this.options.metadataStore.get(session)?.agent === "codex")
+            return;
+        if (event.kind === "turn_start") {
+            // 発話の観測（履歴再生も含めて最新値を保つ）。処理中状態は動かさない（権威は hook）。
+            actor.lastTurnStartMs = Math.max(actor.lastTurnStartMs ?? 0, event.atMs);
+            return;
+        }
+        if (event.kind !== "interrupted" && event.kind !== "api_error")
+            return;
+        if (actor.processingSince === null) {
+            // 処理中でなくても終端の時刻は覚える: 終端より前に発火した hook（別プロセス起動 + relay で遅着する
+            // UserPromptSubmit / Pre・PostToolUse）は既に終わったターンの残響として無視する
+            // （late-hook-before-turn-end）。連続 API エラー（実測 2026-09-06: エラー行の 69ms 後に queued 発話が
+            // 自動 dequeue され 1.15s 後に再びエラー）で 2 本目のマーカーが新ターンの hook より先に届いても、
+            // その hook の発火時刻はマーカーより古いので処理中へ戻さない。
+            actor.lastTurnEndMs = Math.max(actor.lastTurnEndMs ?? 0, event.atMs);
+            return;
+        }
+        if (actor.processingSinceMs !== null && event.atMs < actor.processingSinceMs)
+            return;
+        this.options.log?.(`${event.kind === "api_error" ? "api-error" : "interrupt"} marker で処理完了を補完 session=${session}`);
+        actor.lastTurnEndMs = Math.max(actor.lastTurnEndMs ?? 0, event.atMs);
+        // 3 秒の残響窓（発火時刻を持たない旧 hook 向けのフォールバック）は利用者の中断だけに武装する。
+        // API エラー後は queued 発話の自動 dequeue や task-notification の再開が数十 ms で始まり得る
+        // （実測 51〜69ms）ため、窓を張ると生きた新ターンの継続 hook を握り潰して idle へ書き戻す。
+        if (event.kind === "interrupted")
+            actor.lastInterruptDoneMs = this.nowMs();
+        this.applyProcessing(session, "done");
+        this.broadcast({ type: "session_processing", session, state: "done" });
+    }
+    /** 遅着 hook が直書きした active の heartbeat を idle へ戻す（その hook の書込のままのときだけ）。 */
+    revertLateHookHeartbeat(session, event, reason) {
+        // 別の書込（新ターンの UserPromptSubmit 等）に置き換わっていれば触らない（生きたターンの reaper
+        // 保護を剥がさない）。
+        try {
+            const latest = readHeartbeat(this.options.heartbeatDir, session);
+            if (latest !== null && latest.state === "active" && latest.event === event) {
+                writeHeartbeat(this.options.heartbeatDir, session, { ts: this.now(), state: "idle", event: reason });
+            }
+        }
+        catch (error) {
+            this.options.log?.(`heartbeat 書込失敗: ${String(error)}`);
+        }
+    }
+    /**
+     * 処理中状態を反映する。戻り値 false は「中断済みターンの残響として無視した」（呼び手は
+     * broadcast しない）。`event` は hook 名（relay 由来。codex controller / 旧 hook は undefined）。
+     */
+    applyProcessing(session, state, event, atMs) {
         const actor = this.actor(session);
-        actor.processingSince = state === "active" ? this.now() : null;
+        if (state === "active") {
+            // 発火時刻付きの hook（hook プロセスの開始時刻。node 起動遅延を含まない）が transcript の最新の
+            // ターン終端（中断確定 / API エラー）より前（かつ配送遅延として説明できる古さ）なら、既に終わった
+            // ターンの遅着 hook。UserPromptSubmit でも同じ（連続 API エラーで自動 dequeue されたターンの hook
+            // が、その終端マーカーより後に届く実測）。処理中（新ターン確定後）に届く古い hook は処理中を
+            // 続けるだけなので無視しない。
+            // UserPromptSubmit は、終端マーカーより後に新しい発話が transcript に現れていれば新ターン
+            // （queued 発話の dequeue）として採用する。発火時刻だけでは「終わったターンの遅着」と
+            // 「enqueue 時に発火して dequeue まで待った発話」を区別できないため、transcript を権威にする。
+            const newerTurnObserved = actor.lastTurnStartMs !== null && actor.lastTurnEndMs !== null &&
+                actor.lastTurnStartMs > actor.lastTurnEndMs;
+            if (actor.processingSince === null && atMs !== undefined && actor.lastTurnEndMs !== null &&
+                atMs < actor.lastTurnEndMs && actor.lastTurnEndMs - atMs <= LATE_HOOK_MAX_AGE_MS &&
+                !(event === "UserPromptSubmit" && newerTurnObserved)) {
+                this.options.log?.(`audit late-hook-before-turn-end ignored session=${session} event=${event} firedAtMs=${atMs} turnEndMs=${actor.lastTurnEndMs}`);
+                // hook が直書きした active の heartbeat も戻す（reaper の bump 代行で不死化させない）。
+                this.revertLateHookHeartbeat(session, event, "late-hook-before-turn-end");
+                return false;
+            }
+            // 中断直後に遅着する継続 hook（Pre/PostToolUse）は中断済みターンの残響。hook は別プロセス
+            // 起動+relay で 100〜300ms 遅れるため、マーカー書込より後に届き得る。採用すると Stop hook の
+            // 無いターンが永久に処理中へ戻る（停止ボタン再点灯）。新ターンの開始は UserPromptSubmit
+            // だけが権威（中断→即再送信は通常どおり active）。発火時刻の有無に関わらず 3 秒窓を保つ
+            // （Esc で abort されたツールの PostToolUse がマーカーの数百 ms 後に発火し得るため、発火時刻で
+            // 窓を狭めない。実機 09-02 の根治を退行させない）。
+            if (isContinuationHookEvent(event) && actor.processingSince === null && actor.lastInterruptDoneMs !== null &&
+                this.nowMs() - actor.lastInterruptDoneMs < LATE_HOOK_AFTER_INTERRUPT_MS) {
+                this.options.log?.(`audit late-hook-after-interrupt ignored session=${session} event=${event}`);
+                this.revertLateHookHeartbeat(session, event, "late-hook-after-interrupt");
+                return false;
+            }
+            actor.processingSince = this.now();
+            // ターン開始は UserPromptSubmit で確定し、継続 hook では進めない（未確定なら今）。
+            if (event === "UserPromptSubmit")
+                actor.turnStartFiredAtMs = atMs ?? null;
+            actor.processingSinceMs =
+                event === "UserPromptSubmit" || actor.processingSinceMs === null ? this.nowMs() : actor.processingSinceMs;
+        }
+        else {
+            // 前ターンの Stop が新ターンの UserPromptSubmit より後に届いた（queued 発話の自動 dequeue で
+            // 両 hook がほぼ同時に発火し、到着順が入れ替わる）場合、現ターンを落とさない
+            // （late-stop-before-turn-start）。発火時刻は現ターンの UserPromptSubmit の発火時刻と比べる
+            // （hub 到着時刻と比べると、短いターンの正規の Stop が UserPromptSubmit の到着前に発火して
+            // 誤って捨てられる）。
+            if (atMs !== undefined && actor.turnStartFiredAtMs !== null && atMs < actor.turnStartFiredAtMs) {
+                this.options.log?.(`audit late-stop-before-turn-start ignored session=${session} event=${event} firedAtMs=${atMs} turnStartMs=${actor.turnStartFiredAtMs}`);
+                // Stop hook は relay より先に heartbeat を idle で直書きする（sinceMs も落ちる）。無視した Stop の
+                // 書込のままなら現ターンの active（開始時刻付き）へ戻す（hub 再起動時の復元と reaper 保護を
+                // 失わないように）。別の書込に置き換わっていれば触らない。
+                try {
+                    const latest = readHeartbeat(this.options.heartbeatDir, session);
+                    if (latest !== null && latest.state === "idle" && latest.event === event) {
+                        writeHeartbeat(this.options.heartbeatDir, session, { ts: this.now(), state: "active",
+                            event: "hub-processing",
+                            ...(actor.processingSinceMs !== null ? { sinceMs: actor.processingSinceMs } : {}) });
+                    }
+                }
+                catch (error) {
+                    this.options.log?.(`heartbeat 書込失敗: ${String(error)}`);
+                }
+                return false;
+            }
+            actor.processingSince = null;
+            actor.processingSinceMs = null;
+            actor.turnStartFiredAtMs = null;
+        }
         // 一覧 watch 中は処理開始/完了で pump を起動/停止する（前面購読とは独立）。
         this.syncPreview(session, actor);
         try {
             writeHeartbeat(this.options.heartbeatDir, session, { ts: this.now(), state: state === "active" ? "active" : "idle",
-                event: state === "active" ? "hub-processing" : "hub-processing-done" });
+                event: state === "active" ? "hub-processing" : "hub-processing-done",
+                // 再起動後の中断マーカー照合用に開始時刻を残す（bump は保持する）。
+                ...(actor.processingSinceMs !== null ? { sinceMs: actor.processingSinceMs } : {}) });
         }
         catch (error) {
             this.options.log?.(`heartbeat 書込失敗: ${String(error)}`);
@@ -1618,6 +1975,7 @@ export class SessionHub {
             this.broadcast({ type: "question_event", session, event: "dismiss", id });
             void this.drainChatQueue(session, actor);
         }
+        return true;
     }
     bumpSafe(session, event, fallbackState = "idle") {
         try {
@@ -1928,6 +2286,13 @@ function sameCodexRetry(left, right) {
         left.sandbox === right.sandbox &&
         left.threadId === right.threadId && left.cwd === right.cwd;
 }
+/** 利用中モデル通知（`pc:model`）の conversation_event payload。 */
+function codexModelMarker(model) {
+    return {
+        type: "chat_output", v: PROTOCOL_V1, streamId: CODEX_MODEL_STREAM_ID,
+        role: "system", text: model, eof: true,
+    };
+}
 function incrementCount(counts, key) {
     counts.set(key, (counts.get(key) ?? 0) + 1);
 }