tailii-host 0.6.0 → 0.7.1

package/dist/hub/sessionHub.js

@@ -2,17 +2,17 @@
 // tailii (TS host) — connection 非依存 Session Hub コア。
 import { reaperTick } from "./reaper.js";
 import * as fs from "node:fs";
-import * as os from "node:os";
 import * as path from "node:path";
 import { bumpHeartbeat, listHeartbeatSessions, readHeartbeat, writeHeartbeat } from "../sessions/heartbeat.js";
-import { claudeProjectSlug, ensureDirectory0700 } from "../shared/paths.js";
+import { ensureDirectory0700 } from "../shared/paths.js";
 import { decodeHubClientLine, encodeHubMessage, } from "./hubProtocol.js";
-import { HISTORY_DONE_STREAM_ID, findTrailingInterruptMarkerMs, } 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 行も進まな
@@ -24,17 +24,20 @@ 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 解決（`~/.claude/projects/<slug>/<sessionId>.jsonl`）。ID 未記録は null。 */
+/** 既定の claude transcript 解決（sessions/transcriptPath.ts と同一規則）。 */
 function defaultTranscriptPathFor(meta) {
-    // 他の tail open と同じ優先順（providerSessionId → claudeSessionId）。別会話を照合しない。
-    const sessionId = meta.providerSessionId ?? meta.claudeSessionId;
-    if (sessionId === undefined || sessionId.length === 0)
-        return null;
-    return path.join(os.homedir(), ".claude", "projects", claudeProjectSlug(meta.cwd), `${sessionId}.jsonl`);
+    return claudeTranscriptPathFor(meta);
 }
 export class SessionHub {
     options;
@@ -121,7 +124,10 @@ export class SessionHub {
             actor.processingSinceMs = heartbeat.sinceMs ?? this.nowMs();
         }
     }
-    /** 復元時の照合用: transcript 末尾の中断マーカー timestamp（claude 会話のみ。不明は null）。 */
+    /**
+     * 復元時の照合用: transcript 末尾のターン終端マーカー（中断確定 / API エラー終端）の timestamp
+     * （claude 会話のみ。不明は null）。
+     */
     trailingInterruptMarkerMs(session) {
         const meta = this.options.metadataStore.get(session);
         if (meta === null || meta.agent === "codex")
@@ -129,7 +135,21 @@ export class SessionHub {
         const transcriptPath = (this.options.transcriptPathFor ?? defaultTranscriptPathFor)(meta);
         if (transcriptPath === null)
             return null;
-        return findTrailingInterruptMarkerMs(transcriptPath);
+        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() {
@@ -268,7 +288,7 @@ export class SessionHub {
                 void this.drainChatQueue(message.session, actor);
         }
         else if (message.type === "session_processing") {
-            if (!this.applyProcessing(message.session, message.state, message.event))
+            if (!this.applyProcessing(message.session, message.state, message.event, message.atMs))
                 return;
         }
         this.broadcast(message);
@@ -615,7 +635,7 @@ export class SessionHub {
                 actor.runtimeClaim = null;
             return;
         }
-        if (!this.applyProcessing(message.session, message.state, message.event))
+        if (!this.applyProcessing(message.session, message.state, message.event, message.atMs))
             return;
         this.broadcast(message);
     }
@@ -725,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);
@@ -873,7 +900,9 @@ export class SessionHub {
     }
     startCodexSharedStream(session, actor, cwd, threadId, newerThanMs) {
         const state = {
-            phase: "starting",
+            phase: "backfill",
+            snapshotReady: false,
+            historyDone: false,
             initialItemIds: new Set(),
             initialContentCounts: new Map(),
             buffered: [],
@@ -882,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) => {
@@ -895,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;
@@ -921,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)
@@ -942,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;
@@ -989,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 中に完了した
@@ -1053,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);
     }
@@ -1081,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 };
@@ -1137,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) が同じ発話を二重に表すため、履歴側が
@@ -1170,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 本のまま残時間を見る。
@@ -1290,6 +1408,7 @@ export class SessionHub {
         let actor = this.actors.get(session);
         if (actor === undefined) {
             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(),
@@ -1472,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)
@@ -1535,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);
@@ -1677,10 +1800,25 @@ 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,
         });
     }
+    /**
+     * 利用中モデルの 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 は
@@ -1699,42 +1837,116 @@ export class SessionHub {
      * その dismiss と chat queue の drain）。中断はターン終了なので Stop 後と同じ振る舞い。
      */
     handleClaudeTurnLifecycle(session, actor, event) {
-        if (event.kind !== "interrupted")
-            return;
+        // API エラー終端（使用量上限 429「You've hit your session limit」等）も中断と同じ扱い: Stop hook が
+        // 発火しないままターンが終わるため、hub の処理中状態がそのまま残る（実機 2026-09-07: 制限到達後の
+        // 会話が停止ボタン点灯のまま固まり、開き直しても履歴再生が走らず送信が queued で止まった）。
         if (this.actors.get(session) !== actor)
             return;
-        if (actor.processingSince === null)
-            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?.(`interrupt marker で処理完了を補完 session=${session}`);
-        actor.lastInterruptDoneMs = this.nowMs();
+        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) {
+    applyProcessing(session, state, event, atMs) {
         const actor = this.actor(session);
         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）。
+            // だけが権威（中断→即再送信は通常どおり 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}`);
-                // hook が直書きした active の heartbeat も戻す（reaper の bump 代行で不死化させない）。
-                // ただし heartbeat がその hook の書込のままのときだけ。別の書込（新ターンの
-                // UserPromptSubmit 等）に置き換わっていれば触らない（生きたターンの reaper 保護を剥がさない）。
+                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 === "active" && latest.event === event) {
-                        writeHeartbeat(this.options.heartbeatDir, session, { ts: this.now(), state: "idle", event: "late-hook-after-interrupt" });
+                    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) {
@@ -1742,14 +1954,9 @@ export class SessionHub {
                 }
                 return false;
             }
-            actor.processingSince = this.now();
-            // ターン開始は UserPromptSubmit で確定し、継続 hook では進めない（未確定なら今）。
-            actor.processingSinceMs =
-                event === "UserPromptSubmit" || actor.processingSinceMs === null ? this.nowMs() : actor.processingSinceMs;
-        }
-        else {
             actor.processingSince = null;
             actor.processingSinceMs = null;
+            actor.turnStartFiredAtMs = null;
         }
         // 一覧 watch 中は処理開始/完了で pump を起動/停止する（前面購読とは独立）。
         this.syncPreview(session, actor);
@@ -2079,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);
 }