tailii-host 0.5.0 → 0.6.0

package/dist/hub/sessionHub.js

@@ -2,12 +2,14 @@
 // 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";
@@ -20,6 +22,20 @@ 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 か（新ターンの権威は 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();
@@ -27,6 +43,7 @@ export class SessionHub {
     previewWatchers = new Set();
     actors = new Map();
     now;
+    nowMs;
     replayLimit;
     injectionsInFlight = 0;
     codexStartsInFlight = 0;
@@ -37,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; }
@@ -68,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();
@@ -207,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) {
@@ -553,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() {
@@ -699,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) {
@@ -723,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 が残る間は
@@ -798,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");
     }
@@ -1220,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(),
@@ -1428,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 {
@@ -1600,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)}`);
@@ -1618,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 {