tailii-host 0.4.0 → 0.6.0

package/dist/hub/sessionHub.js

@@ -2,17 +2,40 @@
 // 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 { ensureDirectory0700 } from "../shared/paths.js";
+import { claudeProjectSlug, 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, findTrailingInterruptMarkerMs, } 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";
+/**
+ * backfilling 中の購読者は publishConversationEvent が丸ごと飛ばす。旗が立ちっぱなしになると
+ * 「接続は健全なのに会話だけ永久に更新されない」実障害になるため、履歴が一定時間 1 行も進まな
+ * ければ強制的に live へ切り替える。進捗があるうちは延長するので、巨大な transcript の再生を
+ * 途中で打ち切ることはない。
+ */
+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 か（新ターンの権威は UserPromptSubmit のみ）。 */
+function isContinuationHookEvent(event) {
+    return event === "PreToolUse" || event === "PostToolUse";
+}
+/** 既定の claude transcript 解決（`~/.claude/projects/<slug>/<sessionId>.jsonl`）。ID 未記録は null。 */
+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`);
+}
 export class SessionHub {
     options;
     clients = new Map();
@@ -20,6 +43,7 @@ export class SessionHub {
     previewWatchers = new Set();
     actors = new Map();
     now;
+    nowMs;
     replayLimit;
     injectionsInFlight = 0;
     codexStartsInFlight = 0;
@@ -30,6 +54,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; }
@@ -61,9 +86,51 @@ 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 末尾の中断マーカー 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 findTrailingInterruptMarkerMs(transcriptPath);
+    }
     /** 永続化済み設問を復元する。App Server の request handle は再起動を越せないため TUI のみ対象。 */
     restorePendingQuestions() {
         const restored = this.readPendingQuestions();
@@ -200,8 +267,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))
+                return;
+        }
         this.broadcast(message);
     }
     handleClientMessage(client, line) {
@@ -546,7 +615,8 @@ export class SessionHub {
                 actor.runtimeClaim = null;
             return;
         }
-        this.applyProcessing(message.session, message.state);
+        if (!this.applyProcessing(message.session, message.state, message.event))
+            return;
         this.broadcast(message);
     }
     async tick() {
@@ -692,6 +762,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) {
@@ -716,6 +790,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 が残る間は
@@ -791,7 +867,7 @@ 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");
     }
@@ -1024,20 +1100,48 @@ export class SessionHub {
         const meta = this.options.metadataStore.get(session);
         if (meta === null)
             return;
-        actor.subscribers.get(client).backfilling = true;
+        // 離脱→再購読で同じ client オブジェクトが**別の** SubscriberState / tail を持つ。古い
+        // backfill の後始末が新しい購読を壊さないよう、自分が始めた分だけを識別して触る。
+        const ownState = actor.subscribers.get(client);
+        ownState.backfilling = true;
         const boundarySeq = actor.nextServerSeq - 1;
         const liveCountsAtStart = new Map(actor.codexLive?.publishedContentCounts ?? []);
         const backfillCounts = new Map();
         let completedSynchronously = false;
+        let finished = false;
+        let stallTimer = null;
         let tail = null;
-        const finish = () => {
-            const state = actor.subscribers.get(client);
-            if (state === undefined)
+        const clearStallTimer = () => {
+            if (stallTimer === null)
+                return;
+            clearTimeout(stallTimer);
+            stallTimer = null;
+        };
+        const finish = (reason) => {
+            if (finished)
+                return;
+            finished = true;
+            clearStallTimer();
+            // 自分の tail だけを管理表から外す。停滞タイマーが再購読後に発火した場合、無条件に
+            // delete すると**新しい** tail が管理外になり、以後 unsubscribe しても停止できない。
+            if (actor.backfillTails.get(client) === tail)
+                actor.backfillTails.delete(client);
+            const superseded = actor.subscribers.get(client) !== ownState;
+            completedSynchronously = tail === null;
+            tail?.stop();
+            // 既に離脱済み、または再購読で別の backfill が走っているなら状態は触らない。
+            if (superseded)
                 return;
             // 共有 tail の emit 時点でイベントは transcript に存在する。その後 EOF まで読む
             // 履歴 tail に必ず含まれるため、同じ同期処理で live へ切り替えても取りこぼさない。
-            state.backfilling = false;
+            ownState.backfilling = false;
+            if (reason !== "history-done") {
+                this.options.log?.(`audit backfill-force-finish session=${session} reason=${reason}`);
+            }
             if (actor.codexLive !== null) {
+                // codex は rollout(履歴) と app-server(live) が同じ発話を二重に表すため、履歴側が
+                // 何を出したかで打ち消してから境界後を replay する。強制完了で履歴が途中まで進んで
+                // いた場合も `backfillCounts` にその分が入っているので、同じ経路が正しく効く。
                 const representedAfterBoundary = new Map();
                 for (const [key, count] of backfillCounts) {
                     const excess = count - (liveCountsAtStart.get(key) ?? 0);
@@ -1056,23 +1160,60 @@ export class SessionHub {
                     this.sendTo(client, { type: "conversation_event", session, ...event });
                 }
             }
-            completedSynchronously = tail === null;
-            tail?.stop();
-            actor.backfillTails.delete(client);
+            else if (reason !== "history-done") {
+                // 履歴を最後まで読めていない。境界後のイベントは履歴側に含まれないため replay で補う
+                // （止まった backfill が境界後の行まで到達している見込みは薄く、重複表示のリスクより
+                // 応答が丸ごと欠ける実害のほうが大きい）。
+                for (const event of actor.replayBuffer) {
+                    if (event.serverSeq <= boundarySeq)
+                        continue;
+                    this.sendTo(client, { type: "conversation_event", session, ...event });
+                }
+            }
+        };
+        // 進捗は「最後に 1 行流れた時刻」で測る。履歴行ごとに setTimeout を張り替えると
+        // 巨大な transcript でタイマー生成が支配的になるため、タイマーは 1 本のまま残時間を見る。
+        let lastProgressAt = Date.now();
+        const armStallTimer = (delayMs) => {
+            stallTimer = setTimeout(() => {
+                stallTimer = null;
+                if (finished)
+                    return;
+                const remaining = BACKFILL_STALL_TIMEOUT_MS - (Date.now() - lastProgressAt);
+                if (remaining > 0) {
+                    armStallTimer(remaining);
+                    return;
+                }
+                finish("stalled");
+            }, delayMs);
+            stallTimer.unref();
         };
         tail = this.options.tailFactory((payload) => {
             this.sendTo(client, { type: "conversation_event", session, serverSeq: 0, payload });
+            lastProgressAt = Date.now();
             const key = chatContentKey(payload);
             if (key !== null)
                 incrementCount(backfillCounts, key);
             if (payload.type === "chat_output" && payload.streamId === HISTORY_DONE_STREAM_ID)
-                finish();
+                finish("history-done");
         });
         if (!completedSynchronously)
             actor.backfillTails.set(client, tail);
-        tail.open(meta.cwd, meta.providerSessionId ?? meta.claudeSessionId ?? null, newerThanMs, meta.agent ?? "claude");
-        if (completedSynchronously)
+        try {
+            tail.open(meta.cwd, meta.providerSessionId ?? meta.claudeSessionId ?? null, newerThanMs, meta.agent ?? "claude");
+        }
+        catch (error) {
+            // transcript を開けない会話で旗を立てたまま抜けると live 配信が永久に止まる。
+            this.options.log?.(`audit backfill-open-failed session=${session} error=${String(error)}`);
+            finish("open-failed");
+            return;
+        }
+        if (completedSynchronously) {
             tail.stop();
+            return;
+        }
+        if (!finished)
+            armStallTimer(BACKFILL_STALL_TIMEOUT_MS);
     }
     canReplay(actor, afterSeq) {
         const first = actor.replayBuffer[0]?.serverSeq ?? actor.nextServerSeq;
@@ -1148,7 +1289,8 @@ 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,
+                focusedBy: new Set(), subscribers: new Map(),
                 nextServerSeq: 1, replayBuffer: [], tail: null, tailRetryTimer: null,
                 previewPump: null, backfillTails: new Map(),
                 seenClientMessageIds: new Set(), deliveredChatMessageIds: new Map(),
@@ -1356,14 +1498,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 {
@@ -1528,14 +1681,83 @@ export class SessionHub {
             type: "chat_output", v: PROTOCOL_V1, streamId, role: "system", text, eof: true,
         });
     }
-    applyProcessing(session, state) {
+    /**
+     * 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) {
+        if (event.kind !== "interrupted")
+            return;
+        if (this.actors.get(session) !== actor)
+            return;
+        if (actor.processingSince === null)
+            return;
+        if (this.options.metadataStore.get(session)?.agent === "codex")
+            return;
+        if (actor.processingSinceMs !== null && event.atMs < actor.processingSinceMs)
+            return;
+        this.options.log?.(`interrupt marker で処理完了を補完 session=${session}`);
+        actor.lastInterruptDoneMs = this.nowMs();
+        this.applyProcessing(session, "done");
+        this.broadcast({ type: "session_processing", session, state: "done" });
+    }
+    /**
+     * 処理中状態を反映する。戻り値 false は「中断済みターンの残響として無視した」（呼び手は
+     * broadcast しない）。`event` は hook 名（relay 由来。codex controller / 旧 hook は undefined）。
+     */
+    applyProcessing(session, state, event) {
         const actor = this.actor(session);
-        actor.processingSince = state === "active" ? this.now() : null;
+        if (state === "active") {
+            // 中断直後に遅着する継続 hook（Pre/PostToolUse）は中断済みターンの残響。hook は別プロセス
+            // 起動+relay で 100〜300ms 遅れるため、マーカー書込より後に届き得る。採用すると Stop hook の
+            // 無いターンが永久に処理中へ戻る（停止ボタン再点灯）。新ターンの開始は UserPromptSubmit
+            // だけが権威（中断→即再送信は通常どおり active）。
+            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 保護を剥がさない）。
+                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" });
+                    }
+                }
+                catch (error) {
+                    this.options.log?.(`heartbeat 書込失敗: ${String(error)}`);
+                }
+                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;
+        }
         // 一覧 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)}`);
@@ -1546,6 +1768,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 {