tailii-host 0.6.0 → 0.7.1

package/dist/codex/codexAppServer.js

@@ -1,6 +1,6 @@
 // codexAppServer.ts
 // Tailii host が共有 Codex App Server を再利用・起動し、thread ID を先に確定する最小クライアント。
-import { spawn } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as net from "node:net";
@@ -13,6 +13,14 @@ const THREAD_TITLE_PROMPT_MAX_LENGTH = 2_000;
 const THREAD_TITLE_MAX_LENGTH = 36;
 const THREAD_TITLE_FALLBACK_MAX_LENGTH = 60;
 const DEFAULT_TITLE_GENERATION_TIMEOUT_MS = 30_000;
+/** thread/items/list の 1 ページ当たり件数（server は 1..100 に clamp する。turns/list は常に limit 1）。 */
+const THREAD_HISTORY_PAGE_LIMIT = 100;
+/** 履歴ページングの上限ページ数（100 件 × 2000 ページ）。cursor が進まない版でも無限ループしない。 */
+const THREAD_HISTORY_MAX_PAGES = 2_000;
+/** 全履歴の取得で送信経路を塞がないための総時間上限。超過時は別接続で制御を復旧する。 */
+const THREAD_HISTORY_SNAPSHOT_TIMEOUT_MS = 3_000;
+/** タイトル生成で最初の user prompt を探す上限ページ数（paginated の thread/items/list）。 */
+const THREAD_TITLE_PROMPT_MAX_PAGES = 4;
 const THREAD_TITLE_OUTPUT_SCHEMA = {
     type: "object",
     properties: {
@@ -98,11 +106,12 @@ class WebSocketCodexAppServerConnection {
         });
     }
     async initialize() {
-        await this.request("initialize", {
+        const response = await this.request("initialize", {
             clientInfo: { name: "tailii_host", title: "Tailii Host", version: "0.1.1" },
             capabilities: { experimentalApi: true },
         });
         this.notify("initialized", undefined);
+        return response;
     }
     request(method, params, timeoutMs) {
         const id = this.nextId;
@@ -212,6 +221,8 @@ export class CodexAppServerThread {
     liveSubscriptionReady;
     connection;
     cwd;
+    liveSubscriptionError;
+    model;
     /** 読み取り専用の readiness 確認だけは、共有 App Server の一時的な混雑を自動回復する。 */
     // 初回5秒 + 再試行2秒に抑え、上位の15秒 Hub RPC に turn/start の予算を残す。
     static activeTurnReadMaxAttempts = 2;
@@ -220,17 +231,28 @@ export class CodexAppServerThread {
     supportsSteerClientUserMessageId = null;
     constructor(threadId, initialItems, initialActiveTurnId, 
     /**
-     * この接続で thread/resume（または作成元 bootstrap）が成功し、live 通知を受け取れるか。
-     * rollout 未生成の新規 thread は resume に失敗するため false。呼び出し側は初回 turn の
-     * 表示を rollout tail へフォールバックし、通知が来ない接続を live 権威にしない。
+     * この接続で thread/resume と履歴スナップショットの読み取り（または作成元 bootstrap）が
+     * 成功し、live 通知を受け取れるか。turn 履歴が未生成の新規 thread は false。呼び出し側は
+     * 履歴取得がタイムアウトした場合も false。表示は rollout tail へフォールバックし、
+     * この接続を live 本文の権威にしない（turn 操作と承認は接続を維持する）。
      */
-    liveSubscriptionReady, connection, cwd) {
+    liveSubscriptionReady, connection, cwd, 
+    /** liveSubscriptionReady=false の理由（履歴読み取りの失敗文言）。ログ診断用。 */
+    liveSubscriptionError = null, 
+    /**
+     * 購読時点で thread に設定されているモデル（thread/resume または作成元 thread/start の
+     * 応答 `thread.model`）。null は応答に含まれない旧 App Server。Hub はこれを `pc:model`
+     * として配信し、会話を開いていない間に変更されたモデルも開き直しで反映する。
+     */
+    model = null) {
         this.threadId = threadId;
         this.initialItems = initialItems;
         this.initialActiveTurnId = initialActiveTurnId;
         this.liveSubscriptionReady = liveSubscriptionReady;
         this.connection = connection;
         this.cwd = cwd;
+        this.liveSubscriptionError = liveSubscriptionError;
+        this.model = model;
     }
     async startTurn(text, clientUserMessageId, effort, sandbox, approvalPolicy) {
         if (text.length === 0)
@@ -258,29 +280,43 @@ export class CodexAppServerThread {
     async readActiveTurnId() {
         for (let attempt = 1;; attempt += 1) {
             try {
-                const response = await this.connection.request("thread/read", {
-                    threadId: this.threadId,
-                    includeTurns: true,
-                }, attempt === 1 ? undefined : CodexAppServerThread.activeTurnReadRetryTimeoutMs);
-                return extractActiveTurnId(response);
+                // 最新 turn だけを読む（turn は直列なので、実行中なら必ず末尾）。全履歴 hydration
+                // （thread/read includeTurns:true）は paginated thread で非推奨のため使わない。
+                const turns = await listThreadTurns(this.connection, this.threadId, {
+                    limit: 1,
+                    sortDirection: "desc",
+                    itemsView: "notLoaded",
+                    all: false,
+                    timeoutMs: attempt === 1 ? undefined : CodexAppServerThread.activeTurnReadRetryTimeoutMs,
+                });
+                return activeTurnIdOfTurns(turns);
             }
             catch (error) {
-                // 新規 thread の最初の rollout 行がまだ無い間は、idle とは断定できない。
-                // controller は手元の ID を維持するか、初回 turn/start へ進む。
-                if (isUnmaterializedThreadError(error, this.threadId))
-                    return undefined;
-                // thread/read は副作用が無い。未 materialize thread の初回送信と
+                // thread/turns/list は副作用が無い。未 materialize thread の初回送信と
                 // 別セッションの処理が共有 App Server 上で重なった場合のみ、
                 // 5秒 timeout を有界リトライする。turn/start / turn/steer は受理済みか
                 // 不明なため、この自動リトライの対象にしない。
-                if (!isRequestTimeout(error, "thread/read") ||
-                    attempt >= CodexAppServerThread.activeTurnReadMaxAttempts) {
-                    throw error;
+                if (isRequestTimeout(error, "thread/turns/list")) {
+                    if (attempt >= CodexAppServerThread.activeTurnReadMaxAttempts)
+                        throw error;
+                    continue;
                 }
+                // 新規 thread の最初の turn 記録がまだ無い間は、idle とは断定できない。
+                // controller は手元の ID を維持するか、初回 turn/start へ進む。判定は既知文言に加えて
+                // thread メタデータの可読性（文言非依存）で行う。判定文言の網羅漏れで新規会話が
+                // 全滅した実障害（2026-09-06）の再発防止。
+                if (await confirmThreadHistoryUnavailable(this.connection, this.threadId, error)) {
+                    return undefined;
+                }
+                throw error;
             }
         }
     }
-    /** 親履歴で欠落する sub-agent の終端状態を、子 thread 自身から読み直す。 */
+    /**
+     * 親履歴で欠落する sub-agent の終端状態を、子 thread 自身から読み直す。
+     * Thread の `model`（ロード中は現在の設定値、未ロードなら最後に永続化された値）も返し、
+     * 再オープン時に spawn item へ model が無い版でも実行モデルを復元できるようにする。
+     */
     async readThreadStatus(threadId) {
         for (let attempt = 1; attempt <= CodexAppServerThread.activeTurnReadMaxAttempts; attempt += 1) {
             try {
@@ -289,9 +325,11 @@ export class CodexAppServerThread {
                 if (thread === null || thread["status"] === undefined)
                     return undefined;
                 const timestampMs = codexTimestampMs(thread["createdAt"] ?? thread["updatedAt"] ?? thread["recencyAt"]);
+                const model = thread["model"];
                 return {
                     status: thread["status"],
                     ...(timestampMs === undefined ? {} : { timestampMs }),
+                    ...(typeof model === "string" && model.length > 0 ? { model } : {}),
                 };
             }
             catch (error) {
@@ -393,6 +431,19 @@ async function readCodexSecurityDefaults(connection, cwd) {
         : null;
     return { approvalPolicy, approvalsReviewer, sandbox };
 }
+/**
+ * 利用者設定（config.toml 階層）の既定モデル。config/read の `config.model` で、TUI の
+ * `/model` で保存した値も含む現在値を読む。未設定・旧 App Server・失敗時は null。
+ */
+async function readCodexConfiguredModel(connection) {
+    try {
+        const response = objectRecord(await connection.request("config/read", { includeLayers: false }));
+        return stringValue(objectRecord(response?.["config"])?.["model"]);
+    }
+    catch {
+        return null;
+    }
+}
 function objectRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value)
         ? value
@@ -422,6 +473,13 @@ export class CodexAppServerManager {
     startupLockPath;
     /** 最初の turn 前（rollout 未作成）の thread を生存させる作成元購読。openThread が引き継ぐ。 */
     bootstrapConnections = new Map();
+    /** thread/start 応答の model。bootstrap 接続を引き継ぐ openThread が購読時のモデルとして返す。 */
+    bootstrapThreadModels = new Map();
+    log;
+    readCliVersion;
+    cliVersionPromise = null;
+    /** 版ずれは同じ組み合わせにつき 1 回だけログする。 */
+    lastVersionMismatch = null;
     constructor(options = {}) {
         this.codexHome = options.codexHome ?? path.join(os.homedir(), ".codex");
         this.codexPath = options.codexPath ?? "codex";
@@ -436,6 +494,32 @@ export class CodexAppServerManager {
         this.titleGenerationTimeoutMs =
             options.titleGenerationTimeoutMs ?? DEFAULT_TITLE_GENERATION_TIMEOUT_MS;
         this.startupLockPath = path.join(path.dirname(this.socketPath), "tailii-start.lock");
+        this.log = options.log ?? null;
+        this.readCliVersion = options.cliVersion ?? (() => probeCodexCliVersion(this.codexPath));
+    }
+    /**
+     * initialize 応答の `userAgent`（`<client>/<server 版> (...)`）から daemon の版を読み、
+     * `codex --version` と食い違えばログに残す。共有 daemon は detached spawn で生き残るため、
+     * codex 更新後も旧バイナリが App Server を提供し続ける（2026-07-23 実障害）。他クライアントも
+     * 使う daemon を勝手には再起動せず、原因究明の手掛かりとして版ずれを可視化する。
+     */
+    noteServerVersion(initializeResponse) {
+        if (this.log === null)
+            return;
+        const serverVersion = extractServerVersion(initializeResponse);
+        if (serverVersion === null)
+            return;
+        this.cliVersionPromise ??= this.readCliVersion().catch(() => null);
+        void this.cliVersionPromise.then((cliVersion) => {
+            if (cliVersion === null || cliVersion === serverVersion)
+                return;
+            const key = `${serverVersion}->${cliVersion}`;
+            if (this.lastVersionMismatch === key)
+                return;
+            this.lastVersionMismatch = key;
+            this.log?.(`Codex App Server daemon の版 ${serverVersion} が codex CLI ${cliVersion} と一致しない` +
+                "（旧 daemon が残っている可能性。App Server 経由の操作が失敗するなら daemon を kill して再 spawn）");
+        });
     }
     /** serverを再利用または排他的に起動し、利用可能になるまで待つ。 */
     async ensureRunning() {
@@ -480,7 +564,7 @@ export class CodexAppServerManager {
         let connection = null;
         try {
             connection = await this.connect(this.socketPath, requestTimeoutMs);
-            await connection.initialize();
+            this.noteServerVersion(await connection.initialize());
             return connection;
         }
         catch {
@@ -589,6 +673,7 @@ export class CodexAppServerManager {
             // remote TUI/thread/resume が "no rollout found" になる。openThread まで保持して引き継ぐ。
             this.bootstrapConnections.get(threadId)?.close();
             this.bootstrapConnections.set(threadId, connection);
+            this.bootstrapThreadModels.set(threadId, threadModel(response));
             succeeded = true;
             return threadId;
         }
@@ -691,6 +776,17 @@ export class CodexAppServerManager {
                     seenCursors.add(cursor);
                 }
             } while (cursor !== null);
+            // model/list の isDefault は preset（サーバ側の推奨既定）で、利用者が config.toml に
+            // 書いた model とは別物。thread/start に model を渡さない新規会話は config の model で
+            // 起動するため、一覧に含まれる限りそちらを isDefault にして「既定」の表示と実体を揃える。
+            const configuredDefault = await readCodexConfiguredModel(connection);
+            const visibleModelIds = new Set(rawModels.flatMap((raw) => {
+                if (raw["hidden"] === true)
+                    return [];
+                const id = stringValue(raw["model"]) ?? stringValue(raw["id"]);
+                return id === null ? [] : [id];
+            }));
+            const effectiveDefault = configuredDefault !== null && visibleModelIds.has(configuredDefault) ? configuredDefault : null;
             // model/list がAPIキャッシュを更新した後に読む。App Serverの公開Model型には
             // context windowが無いため、同じCodex API応答の永続キャッシュから実効値を結合する。
             const cachedWindows = readModelContextWindows(path.join(this.codexHome, "models_cache.json"));
@@ -720,7 +816,7 @@ export class CodexAppServerManager {
                         ...(contextWindow !== undefined ? { contextWindow } : {}),
                         ...(defaultReasoningEffort !== null ? { defaultReasoningEffort } : {}),
                         ...(supportedReasoningEfforts.length > 0 ? { supportedReasoningEfforts } : {}),
-                        isDefault: raw["isDefault"] === true,
+                        isDefault: effectiveDefault !== null ? model === effectiveDefault : raw["isDefault"] === true,
                     }];
             });
         }
@@ -728,12 +824,34 @@ export class CodexAppServerManager {
             connection.close();
         }
     }
+    /** 指定threadの後続turnで使うモデルをApp Serverの設定APIへ反映する。 */
+    async setThreadModel(threadId, model) {
+        if (threadId.length === 0)
+            throw new Error("Codex thread ID must not be empty");
+        if (model.length === 0)
+            throw new Error("Codex model must not be empty");
+        await this.ensureRunning();
+        const connection = await this.connect(this.socketPath);
+        try {
+            await connection.initialize();
+            await connection.request("thread/settings/update", { threadId, model });
+        }
+        finally {
+            connection.close();
+        }
+    }
     /** 既存 thread を購読する長寿命接続を開く。turn と native approval はこの接続を流れる。 */
     async openThread(options) {
         await this.ensureRunning();
+        return this.openThreadAttempt(options, null);
+    }
+    async openThreadAttempt(options, historyTimeout) {
         const bootstrap = this.bootstrapConnections.get(options.threadId) ?? null;
         if (bootstrap !== null)
             this.bootstrapConnections.delete(options.threadId);
+        // 作成元接続を引き継ぐ場合は thread/start 応答の model を購読時のモデルとして使う。
+        let model = bootstrap !== null ? this.bootstrapThreadModels.get(options.threadId) ?? null : null;
+        this.bootstrapThreadModels.delete(options.threadId);
         const connection = bootstrap ?? (await this.connect(this.socketPath));
         const removeNotification = connection.onNotification((notification) => {
             options.onNotification?.(notification);
@@ -747,39 +865,82 @@ export class CodexAppServerManager {
             void handler(request).then((result) => connection.respond(request.id, result), (error) => connection.respondError(request.id, -32000, String(error)));
         });
         const removeDisconnect = connection.onDisconnect?.((error) => options.onDisconnect?.(error)) ?? (() => { });
+        let resumedSuccessfully = false;
         try {
             let initialItems = [];
             let initialActiveTurnId = null;
             let liveSubscriptionReady = bootstrap !== null;
+            let liveSubscriptionError = historyTimeout;
             if (bootstrap === null) {
                 await connection.initialize();
                 try {
-                    const response = await connection.request("thread/resume", {
+                    // 全履歴 hydration（excludeTurns:false）は paginated thread で非推奨（codex 0.153.4+ は
+                    // 呼び出した接続へ deprecationNotice を返す）。resume はメタデータだけにし、
+                    // Hub の rollout backfill と live 通知の境界に使う履歴 item と実行中 turn は
+                    // ページ API で読む（readThreadHistorySnapshot）。購読開始（resume）と履歴読み取りの
+                    // 間に完了した item は snapshot と live 通知の両方に現れるが、Hub は snapshot item を
+                    // rollout の occurrence と照合して 1 回だけ出す（flushCodexBuffer）。
+                    const resumed = await connection.request("thread/resume", {
                         threadId: options.threadId,
-                        // Hub の rollout backfill と live 通知の厳密な境界に履歴 item ID を使う。
-                        excludeTurns: false,
+                        excludeTurns: true,
                     });
-                    initialItems = extractThreadItems(response);
-                    initialActiveTurnId = extractActiveTurnId(response);
-                    liveSubscriptionReady = true;
+                    resumedSuccessfully = true;
+                    // thread の現在モデルは resume 応答が権威。履歴読み取りが失敗する未materialize
+                    // thread（turn 前）でも resume 自体は成立するため、snapshot より先に確定する。
+                    model = threadModel(resumed) ?? model;
+                    if (historyTimeout === null) {
+                        const snapshot = await readThreadHistorySnapshotWithRetry(connection, options.threadId, threadHistoryMode(resumed));
+                        initialItems = snapshot.items;
+                        initialActiveTurnId = snapshot.activeTurnId;
+                        liveSubscriptionReady = true;
+                    }
+                    else {
+                        // 大きい画像・tool 出力を含む履歴は、同じ socket の後続 RPC も塞ぐ。
+                        // 新しい接続で購読し直し、turn 状態だけ確認する。部分履歴を live の権威に
+                        // せず rollout fallback を使う。実行中なら controller が start ではなく steer する。
+                        initialActiveTurnId = activeTurnIdOfTurns(await listThreadTurns(connection, options.threadId, {
+                            limit: 1,
+                            sortDirection: "desc",
+                            itemsView: "notLoaded",
+                            all: false,
+                            timeoutMs: THREAD_METADATA_PROBE_TIMEOUT_MS,
+                        }));
+                    }
                 }
                 catch (error) {
-                    // thread/start から最初の user turn まで rollout は未作成で、別接続からの
-                    // thread/resume は "no rollout found" になる。ただし共有 App Server 内の
-                    // live thread 自体は存在し、この接続から turn/start を直接送れば materialize
-                    // できる。engine と Session Hub は別プロセスなので、この場合だけ履歴ゼロとして
-                    // 接続を維持し、最初の turn/start へ進ませる。
-                    if (!isUnmaterializedThreadError(error, options.threadId))
+                    // thread/start から最初の user turn まで turn 履歴は未作成で、別接続からの
+                    // 履歴読み取りは "no rollout found" / "list_turns is not supported yet" になる。
+                    // ただし共有 App Server 内の live thread 自体は存在し、この接続から turn/start を
+                    // 直接送れば materialize できる。engine と Session Hub は別プロセスなので、
+                    // この場合だけ履歴ゼロとして接続を維持し、最初の turn/start へ進ませる
+                    // （resume 自体が成立していても live 権威にはせず、従来どおり rollout fallback）。
+                    // 判定は文言一致に加えてメタデータ読み取りの可否（文言非依存）で行う。
+                    if (!(await confirmThreadHistoryUnavailable(connection, options.threadId, error))) {
                         throw error;
+                    }
+                    liveSubscriptionError = String(error);
+                    // 正常な turn 前（既知文言）と、materialize 済み thread の履歴読み取り失敗（要調査:
+                    // 会話を開くたびに rollout fallback へ落ち続ける）を hub.log で区別できるようにする。
+                    this.log?.(isUnmaterializedThreadError(error, options.threadId)
+                        ? `Codex thread ${options.threadId} は turn 前の未materialize（正常）: 履歴スナップショット無しで rollout fallback`
+                        : `Codex thread ${options.threadId} の履歴スナップショットを読めず rollout fallback（要調査）: ${liveSubscriptionError}`);
                 }
             }
-            return new CodexAppServerThread(options.threadId, initialItems, initialActiveTurnId, liveSubscriptionReady, connection, options.cwd ?? null);
+            return new CodexAppServerThread(options.threadId, initialItems, initialActiveTurnId, liveSubscriptionReady, connection, options.cwd ?? null, liveSubscriptionError, model);
         }
         catch (error) {
             removeNotification();
             removeServerRequest();
             removeDisconnect();
             connection.close();
+            if (historyTimeout === null && resumedSuccessfully && (isRequestTimeout(error, "thread/items/list") ||
+                isRequestTimeout(error, "thread/turns/list") ||
+                isRequestTimeout(error, "thread/read"))) {
+                this.log?.(`Codex thread ${options.threadId} の履歴取得がタイムアウト: ` +
+                    `新しい接続で turn 操作を復旧し、表示は rollout fallback へ移行: ${String(error)}`);
+                // 履歴の再取得・turn の再送はしない。新しい制御接続での復旧は 1 回だけ。
+                return this.openThreadAttempt(options, String(error));
+            }
             throw error;
         }
     }
@@ -871,15 +1032,16 @@ async function readThreadName(connection, threadId) {
 async function readThreadTitleTarget(connection, threadId, fallbackPrompt) {
     let response;
     try {
+        // 名前はメタデータだけの read で読む（includeTurns:true は paginated thread で非推奨）。
         response = await connection.request("thread/read", {
             threadId,
-            includeTurns: true,
+            includeTurns: false,
         });
     }
     catch (error) {
         // 作成直後は初回 turn/start 応答後もしばらく rollout が空の場合がある。
         // controller から渡された最初の入力を使い、既存 name だけ thread/list で保護する。
-        if (!isUnmaterializedThreadError(error, threadId))
+        if (!(await confirmThreadHistoryUnavailable(connection, threadId, error)))
             throw error;
         return {
             name: await readThreadNameFromList(connection, threadId),
@@ -895,9 +1057,20 @@ async function readThreadTitleTarget(connection, threadId, fallbackPrompt) {
         throw new Error("Codex App Server thread/read returned an invalid thread name");
     }
     const name = typeof rawName === "string" && rawName.trim().length > 0 ? rawName.trim() : null;
-    const firstUserPrompt = extractThreadItems(response)
-        .map(extractUserMessageText)
-        .find((value) => value !== null && value.trim().length > 0);
+    // 命名済みなら呼び出し側は生成しないので、履歴の読み取り（追加 RPC）はしない。
+    if (name !== null)
+        return { name, prompt: fallbackPrompt };
+    // 最初の user prompt は保存済み履歴を権威にする（TUI attach / resume の競合で
+    // controller の入力が後続メッセージになっていても、新規会話の命名を落とさない）。
+    let firstUserPrompt = null;
+    try {
+        firstUserPrompt = await readFirstUserPrompt(connection, threadId, threadHistoryMode(response));
+    }
+    catch (error) {
+        // 初回 turn/start 応答後も turn 履歴の flush までは読めない場合がある。
+        if (!(await confirmThreadHistoryUnavailable(connection, threadId, error)))
+            throw error;
+    }
     return {
         name,
         prompt: firstUserPrompt ?? fallbackPrompt,
@@ -1068,18 +1241,86 @@ function normalizeFallbackThreadTitle(raw) {
     const title = raw.replaceAll("\n", " ").replaceAll("\r", " ").trim();
     return title.slice(0, THREAD_TITLE_FALLBACK_MAX_LENGTH);
 }
+/**
+ * codex 0.153.4+ の `historyMode: "paginated"` thread は、turn が 1 件も無い間
+ * `thread/turns/list`（および全履歴 hydration の `thread/read includeTurns:true` /
+ * `thread/resume excludeTurns:false`）を JSON-RPC -32601 でこの文言のまま拒否する
+ * （thread id を含まない）。turn/start 自体は受理され、最初の turn 以降は成功する。
+ */
+const PAGINATED_THREAD_TURNS_UNAVAILABLE = "list_turns is not supported yet";
+/**
+ * thread/start 直後（最初の user turn 前）の読み取り失敗を、App Server の版ごとの文言から判定する。
+ * - `no rollout found for thread id <id>`: rollout ファイル未作成
+ * - `thread <id> is not materialized yet; <method> is unavailable before first user message`:
+ *   method 部分は `includeTurns` / `thread/turns/list` など版で異なるため前方一致
+ * - `failed to read session metadata ... is empty`: session_meta 行の flush 前
+ * - `list_turns is not supported yet`: paginated thread の turn 前（0.153.4 実測）
+ */
 function isUnmaterializedThreadError(error, threadId) {
     if (!(error instanceof Error))
         return false;
-    if (error.message === `no rollout found for thread id ${threadId}`)
+    const { message } = error;
+    if (message === `no rollout found for thread id ${threadId}`)
+        return true;
+    if (message.startsWith(`thread ${threadId} is not materialized yet;`))
+        return true;
+    if (message === PAGINATED_THREAD_TURNS_UNAVAILABLE)
         return true;
-    const notMaterializedYet = `thread ${threadId} is not materialized yet; ` +
-        "includeTurns is unavailable before first user message";
-    if (error.message === notMaterializedYet)
+    return message.includes(threadId) &&
+        message.includes("failed to read session metadata") &&
+        message.endsWith("is empty");
+}
+/** initialize 応答の userAgent `tailii_host/0.153.4 (...)` から server の数値版を取り出す。 */
+function extractServerVersion(initializeResponse) {
+    const userAgent = objectRecord(initializeResponse)?.["userAgent"];
+    if (typeof userAgent !== "string")
+        return null;
+    const match = /^[^\s/]+\/(\d+(?:\.\d+)+)/.exec(userAgent);
+    return match?.[1] ?? null;
+}
+/** `codex --version`（例: `codex-cli 0.153.4`）の数値版。取れなければ null。 */
+function probeCodexCliVersion(codexPath) {
+    return new Promise((resolve) => {
+        execFile(codexPath, ["--version"], { timeout: 5_000 }, (error, stdout) => {
+            if (error) {
+                resolve(null);
+                return;
+            }
+            resolve(/\d+(?:\.\d+)+/.exec(String(stdout))?.[0] ?? null);
+        });
+    });
+}
+/** 文言非依存判定で使う、メタデータだけの thread/read の期限。 */
+const THREAD_METADATA_PROBE_TIMEOUT_MS = 2_000;
+/**
+ * turn 履歴の読み取り（thread/turns/list。旧: thread/resume / thread/read includeTurns:true）の
+ * 失敗が「turn 履歴が未生成・未対応」なのかを、エラー文言に依存せず判定する。
+ *
+ * 1. 既知の文言（isUnmaterializedThreadError）なら即 true。
+ * 2. timeout は接続が刺さっている可能性があるため false（呼び出し側の有界リトライに委ねる）。
+ * 3. それ以外は、メタデータだけの `thread/read includeTurns:false` を短い期限で試す。
+ *    live thread は最初の turn 前でも（rollout 未作成でも）これに応答する一方、存在しない
+ *    thread は `thread not loaded` 等で失敗する。応答があれば thread は App Server から
+ *    見えており、履歴 hydration だけが不可＝turn/start へ進んでよい状態と判断する。
+ *
+ * App Server の文言は版ごとに変わる（no rollout found → not materialized yet →
+ * list_turns is not supported yet）。文言の網羅漏れで新規会話が全滅しないための安全側判定。
+ */
+async function confirmThreadHistoryUnavailable(connection, threadId, error) {
+    if (isUnmaterializedThreadError(error, threadId))
         return true;
-    return error.message.includes(threadId) &&
-        error.message.includes("failed to read session metadata") &&
-        error.message.endsWith("is empty");
+    if (!(error instanceof Error))
+        return false;
+    if (error.message.startsWith("Codex App Server request timed out"))
+        return false;
+    try {
+        const response = objectRecord(await connection.request("thread/read", { threadId, includeTurns: false }, THREAD_METADATA_PROBE_TIMEOUT_MS));
+        const thread = objectRecord(response?.["thread"]);
+        return thread !== null && thread["id"] === threadId;
+    }
+    catch {
+        return false;
+    }
 }
 function parseRemoteControlStatus(value) {
     if (typeof value !== "object" || value === null || Array.isArray(value))
@@ -1125,48 +1366,221 @@ function parseRemoteControlPairing(value) {
         expiresAt: expiresAt,
     };
 }
-function extractThreadItems(response) {
+/** thread/resume・thread/read 応答の `thread.historyMode`。欠落や未知の値は legacy 扱い。 */
+function threadHistoryMode(response) {
+    const thread = objectRecord(objectRecord(response)?.["thread"]);
+    return thread?.["historyMode"] === "paginated" ? "paginated" : "legacy";
+}
+/**
+ * host 側で検出した応答形・上限の異常（data 欠落、未知の item 形、turns 欠落、ページ上限）。
+ * server の一時障害ではなく恒久的なので、読み直しの対象にしない。
+ */
+class CodexHistoryShapeError extends Error {
+}
+/**
+ * cursor ページングの共通ループ。応答形が違う（data が配列でない）版は成功として扱わず throw する
+ * （「履歴ゼロなのに live 権威」という誤った状態を作らない。呼び出し側は未 materialize 判定→
+ * rollout fallback へ進む）。cursor が進まない・既出 cursor へ戻る（循環）・空ページ・上限ページ数・
+ * `until` 成立で打ち切り、無限ループしない。壊れた cursor のページは取り込んだうえで打ち切る
+ * （重複は呼び出し側が id で排除する）。
+ */
+async function pageThreadHistory(connection, method, threadId, params, options, collect, until = () => false) {
+    let cursor = null;
+    const visited = new Set();
+    for (let page = 1; page <= THREAD_HISTORY_MAX_PAGES; page += 1) {
+        const timeoutMs = historyRequestTimeout(method, options.deadlineMs, options.timeoutMs);
+        const response = objectRecord(await connection.request(method, {
+            threadId,
+            limit: options.limit,
+            sortDirection: options.sortDirection,
+            ...params,
+            ...(cursor === null ? {} : { cursor }),
+        }, timeoutMs));
+        const data = response?.["data"];
+        if (!Array.isArray(data)) {
+            throw new CodexHistoryShapeError(`Codex App Server ${method} response omitted data for thread ${threadId}`);
+        }
+        collect(data);
+        const rawNext = response?.["nextCursor"];
+        const next = typeof rawNext === "string" && rawNext.length > 0 ? rawNext : null;
+        if (!options.all || next === null || visited.has(next) || data.length === 0 || until())
+            return;
+        visited.add(next);
+        cursor = next;
+    }
+    throw new CodexHistoryShapeError(`Codex App Server ${method} exceeded ${THREAD_HISTORY_MAX_PAGES} pages for thread ${threadId}`);
+}
+function historyRequestTimeout(method, deadlineMs, timeoutMs) {
+    if (deadlineMs === undefined)
+        return timeoutMs;
+    const remaining = deadlineMs - Date.now();
+    if (remaining <= 0)
+        throw new Error(`Codex App Server request timed out: ${method}`);
+    return Math.min(remaining, timeoutMs ?? remaining);
+}
+/** id 付き要素の重複（同じページを返し続ける壊れた cursor 等）を排除する。id 無しは常に採用。 */
+function rememberId(seen, id) {
+    if (typeof id !== "string" || id.length === 0)
+        return true;
+    if (seen.has(id))
+        return false;
+    seen.add(id);
+    return true;
+}
+/**
+ * `thread/turns/list` で turn を読む。サポート下限の codex 0.144.5 から itemsView 付きで利用できる。
+ * 用途は turn 状態の読み取り（desc, limit 1, notLoaded）に限る。履歴の hydration には使わない
+ * （readThreadHistorySnapshot）: `itemsView:"full"` は server 側で「旧 client が thread/items/list へ
+ * 移行するまでの互換経路」とされ、legacy thread の turns/list は itemsView に関わらず
+ * リクエスト毎に rollout 全体を再生する（server 実装）。
+ */
+async function listThreadTurns(connection, threadId, options) {
+    const turns = [];
+    const seen = new Set();
+    await pageThreadHistory(connection, "thread/turns/list", threadId, { itemsView: options.itemsView }, options, (data) => {
+        for (const turn of data) {
+            const record = objectRecord(turn);
+            if (record !== null && rememberId(seen, record["id"]))
+                turns.push(record);
+        }
+    });
+    return turns;
+}
+/**
+ * `thread/items/list`（paginated thread 専用。legacy thread は -32601 `not supported yet`）で
+ * item を読む。応答の data は turn を跨いだ時系列順（asc）。0.153.4 は `{ turnId, item }` の
+ * 封筒、サポート下限 0.144.5 の protocol は素の ThreadItem 配列なので両方を受け、どちらでもない
+ * 形（非空ページで採用 0 件）は throw する（無言の空履歴で live 権威にしない）。
+ * `until` が true を返した時点で続きのページを読まない。
+ */
+async function listThreadItems(connection, threadId, options, until = () => false) {
+    const items = [];
+    const seen = new Set();
+    let pages = 0;
+    await pageThreadHistory(connection, "thread/items/list", threadId, {}, options, (data) => {
+        pages += 1;
+        let accepted = 0;
+        for (const entry of data) {
+            const record = objectRecord(entry);
+            const item = objectRecord(record?.["item"]) ??
+                (typeof record?.["type"] === "string" ? record : null);
+            if (item === null)
+                continue;
+            accepted += 1;
+            if (rememberId(seen, item["id"]))
+                items.push(item);
+        }
+        if (data.length > 0 && accepted === 0) {
+            throw new CodexHistoryShapeError(`Codex App Server thread/items/list returned items of unknown shape for thread ${threadId}`);
+        }
+    }, () => until(items, pages));
+    return items;
+}
+/**
+ * thread/read includeTurns:true 応答の `thread.turns`。protocol 上は常に配列（他の応答では空配列）
+ * なので、欠落は応答形の違いとして throw する（無言の空履歴で live 権威にしない）。
+ */
+function turnsOfThreadResponse(response) {
+    const turns = objectRecord(objectRecord(response)?.["thread"])?.["turns"];
+    if (!Array.isArray(turns)) {
+        throw new CodexHistoryShapeError("Codex App Server thread/read includeTurns:true response omitted thread.turns");
+    }
+    return turns
+        .map(objectRecord)
+        .filter((turn) => turn !== null);
+}
+/**
+ * 購読直後の履歴スナップショット（Hub の rollout backfill と live 通知の境界に使う item 列と、
+ * 別 client が開始した実行中 turn）を、非推奨でない API だけで読む。
+ * - paginated（codex 0.153.4+ の新規 thread）: server の案内どおり turn 状態は `thread/turns/list`
+ *   （desc, limit 1, notLoaded）、item は `thread/items/list`（asc）で読む。turn 前は最初の
+ *   `thread/turns/list` が `list_turns is not supported yet` で失敗し、呼び出し側が未 materialize
+ *   判定へ進む。item 列は全履歴 hydration（server の paginated_thread_full_turns）と同じ
+ *   （0.153.4 実測）。
+ * - legacy（rollout 保存の旧 thread）: `thread/items/list` は未対応（-32601）。全履歴 hydration
+ *   `thread/read includeTurns:true` は legacy では非推奨でなく（server の通知は paginated 限定）、
+ *   rollout を 1 回再生するだけで済む。`thread/turns/list itemsView:full` はページ毎に rollout
+ *   全体を再生する（server 実装）ため使わない。
+ */
+async function readThreadHistorySnapshot(connection, threadId, historyMode, deadlineMs) {
+    if (historyMode === "paginated") {
+        const latest = await listThreadTurns(connection, threadId, {
+            limit: 1,
+            sortDirection: "desc",
+            itemsView: "notLoaded",
+            all: false,
+            deadlineMs,
+        });
+        const items = await listThreadItems(connection, threadId, {
+            limit: THREAD_HISTORY_PAGE_LIMIT,
+            sortDirection: "asc",
+            all: true,
+            deadlineMs,
+        });
+        return { items, activeTurnId: activeTurnIdOfTurns(latest) };
+    }
+    const turns = turnsOfThreadResponse(await connection.request("thread/read", { threadId, includeTurns: true }, historyRequestTimeout("thread/read", deadlineMs)));
+    return { items: itemsOfTurns(turns), activeTurnId: activeTurnIdOfTurns(turns) };
+}
+/**
+ * 履歴スナップショットの読み取りを、ページング中の一時的な失敗（例: compaction で cursor の
+ * anchor turn が消えた `invalid cursor`）に備えて 1 回だけやり直す。timeout（接続が刺さっている
+ * 可能性）、未 materialize の既知文言（turn 前は何度読んでも同じ）、host 側で検出した応答形・
+ * 上限の異常（恒久的）は再試行しない。
+ */
+async function readThreadHistorySnapshotWithRetry(connection, threadId, historyMode) {
+    const deadlineMs = Date.now() + THREAD_HISTORY_SNAPSHOT_TIMEOUT_MS;
+    try {
+        return await readThreadHistorySnapshot(connection, threadId, historyMode, deadlineMs);
+    }
+    catch (error) {
+        if (!(error instanceof Error) ||
+            error instanceof CodexHistoryShapeError ||
+            error.message.startsWith("Codex App Server request timed out") ||
+            isUnmaterializedThreadError(error, threadId)) {
+            throw error;
+        }
+        return readThreadHistorySnapshot(connection, threadId, historyMode, deadlineMs);
+    }
+}
+/** 命名用に最初の user prompt を保存済み履歴から読む（無ければ null）。 */
+async function readFirstUserPrompt(connection, threadId, historyMode) {
+    if (historyMode === "legacy") {
+        // legacy は rollout を 1 回で読む（readThreadHistorySnapshot と同じ理由）。全 turn を走査する。
+        const response = await connection.request("thread/read", { threadId, includeTurns: true });
+        return firstUserPromptOfItems(itemsOfTurns(turnsOfThreadResponse(response)));
+    }
+    // paginated は先頭から user prompt が見つかるまで（上限ページ数まで）読む。
+    const items = await listThreadItems(connection, threadId, { limit: THREAD_HISTORY_PAGE_LIMIT, sortDirection: "asc", all: true }, (collected, pages) => pages >= THREAD_TITLE_PROMPT_MAX_PAGES || firstUserPromptOfItems(collected) !== null);
+    return firstUserPromptOfItems(items);
+}
+function firstUserPromptOfItems(items) {
+    return items
+        .map(extractUserMessageText)
+        .find((value) => value !== null && value.trim().length > 0) ?? null;
+}
+/** turn 一覧に含まれる item を時系列順に平坦化する。 */
+function itemsOfTurns(turns) {
     const result = [];
-    if (typeof response !== "object" || response === null)
-        return result;
-    const thread = response["thread"];
-    if (typeof thread !== "object" || thread === null)
-        return result;
-    const turns = thread["turns"];
-    if (!Array.isArray(turns))
-        return result;
     for (const turn of turns) {
-        if (typeof turn !== "object" || turn === null)
-            continue;
         const items = turn["items"];
         if (!Array.isArray(items))
             continue;
         for (const item of items) {
-            if (typeof item !== "object" || item === null || Array.isArray(item))
-                continue;
-            result.push(item);
+            const record = objectRecord(item);
+            if (record !== null)
+                result.push(record);
         }
     }
     return result;
 }
-/** thread/resume が返す turn 一覧から、別 client が開始した実行中 turn を復元する。 */
-function extractActiveTurnId(response) {
-    if (typeof response !== "object" || response === null)
-        return null;
-    const thread = response["thread"];
-    if (typeof thread !== "object" || thread === null)
-        return null;
-    const turns = thread["turns"];
-    if (!Array.isArray(turns))
-        return null;
+/** turn 一覧から、別 client が開始した実行中 turn を復元する（末尾から最初の inProgress）。 */
+function activeTurnIdOfTurns(turns) {
     for (let index = turns.length - 1; index >= 0; index -= 1) {
         const turn = turns[index];
-        if (typeof turn !== "object" || turn === null || Array.isArray(turn))
-            continue;
-        const record = turn;
-        if (record["status"] !== "inProgress")
+        if (turn === undefined || turn["status"] !== "inProgress")
             continue;
-        const id = record["id"];
+        const id = turn["id"];
         if (typeof id === "string" && id.length > 0)
             return id;
     }
@@ -1179,6 +1593,11 @@ function defaultLaunch(executable, args, env) {
     });
     child.unref();
 }
+/** thread/start / thread/resume 応答の `thread.model`。無ければ null（旧 App Server）。 */
+function threadModel(response) {
+    const thread = objectRecord(objectRecord(response)?.["thread"]);
+    return stringValue(thread?.["model"]);
+}
 function extractThreadId(response) {
     if (typeof response !== "object" || response === null)
         return null;