remote-codex 0.11.52 → 0.11.53

package/apps/supervisor-api/dist/index.js

@@ -8595,15 +8595,23 @@ var DEFERRED_COMMAND_DETAIL_TITLE = "Command Output";
 var DEFERRED_TOOL_DETAIL_TITLE = "Tool Call Details";
 var DEFERRED_AGENT_TOOL_DETAIL_TITLE = "Agent Details";
 function parseUuidV7Timestamp(id) {
-  const normalized = id.replace(/-/g, "");
-  if (!/^[0-9a-f]{32}$/i.test(normalized) || normalized[12]?.toLowerCase() !== "7") {
-    return null;
-  }
-  const millis = Number.parseInt(normalized.slice(0, 12), 16);
-  if (!Number.isFinite(millis)) {
-    return null;
+  const candidates = [
+    id,
+    ...id.match(
+      /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|[0-9a-f]{32}/gi
+    ) ?? []
+  ];
+  for (const candidate of candidates) {
+    const normalized = candidate.replace(/-/g, "");
+    if (!/^[0-9a-f]{32}$/i.test(normalized) || normalized[12]?.toLowerCase() !== "7") {
+      continue;
+    }
+    const millis = Number.parseInt(normalized.slice(0, 12), 16);
+    if (Number.isFinite(millis)) {
+      return new Date(millis).toISOString();
+    }
   }
-  return new Date(millis).toISOString();
+  return null;
 }
 function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -8911,6 +8919,31 @@ function formatToolCallHistoryItem(item, deferredDetails, kind = "toolCall") {
   }
   return historyItem;
 }
+function deferLargeHistoryItemDetails(turn, deferredDetails) {
+  return {
+    ...turn,
+    items: turn.items.map(
+      (item) => item.kind === "commandExecution" ? deferCommandHistoryItem(
+        item,
+        deferredDetails
+      ) : item.kind === "toolCall" || item.kind === "agentToolCall" || item.kind === "skillToolCall" ? deferToolCallHistoryItem(
+        item,
+        deferredDetails
+      ) : item
+    )
+  };
+}
+function visibleRuntimeTurnItems(items) {
+  const hasFinalAgentMessage = items.some(
+    (item) => item.kind === "agentMessage" && !isTransientAgentHistoryItem(item)
+  );
+  if (!hasFinalAgentMessage) {
+    return items;
+  }
+  return items.filter(
+    (item) => !(item.kind === "agentMessage" && isTransientAgentHistoryItem(item))
+  );
+}
 function extractWebSearchQueries(item) {
   const action = isRecord4(item.action) ? item.action : null;
   const result = isRecord4(item.result) ? item.result : null;
@@ -9360,6 +9393,18 @@ function liveCodexItemToHistoryItem(item, phase) {
     status: historyItem.status ?? (phase === "started" ? "running" : "completed")
   };
 }
+function agentTurnToThreadTurnDto(turn, deferredDetails) {
+  const baseTurn = {
+    id: turn.providerTurnId,
+    startedAt: turn.startedAt ?? parseUuidV7Timestamp(turn.providerTurnId),
+    status: turn.status,
+    error: turn.error?.message ?? null,
+    items: visibleRuntimeTurnItems(turn.items).map(
+      (item, transcriptIndex) => item.transcriptOrder === transcriptIndex ? item : { ...item, transcriptOrder: transcriptIndex }
+    )
+  };
+  return deferredDetails ? deferLargeHistoryItemDetails(baseTurn, deferredDetails) : baseTurn;
+}
 function codexTurnToAgentTurn(turn) {
   return {
     providerTurnId: turn.id,
@@ -9374,6 +9419,10 @@ function codexTurnToAgentTurn(turn) {
 }
 
 // ../../packages/codex/src/local-session-store.ts
+import {
+  unwatchFile,
+  watchFile
+} from "fs";
 import fs6 from "fs/promises";
 import path7 from "path";
 import Database2 from "better-sqlite3";
@@ -9391,6 +9440,76 @@ function summarizeTitleFromTurns(turns) {
 function createHistoryItemId(turnId, prefix, index) {
   return `${turnId}-${prefix}-${index}`;
 }
+function transcriptMessageText(payload) {
+  if (!Array.isArray(payload?.content)) {
+    return null;
+  }
+  const text2 = payload.content.filter(
+    (content) => (content?.type === "input_text" || content?.type === "output_text") && typeof content.text === "string" && content.text.trim()
+  ).map((content) => content.text).join("\n\n");
+  return text2 || null;
+}
+function camelCaseKey(key) {
+  return key.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function camelCaseValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(camelCaseValue);
+  }
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([key, entry]) => [
+      camelCaseKey(key),
+      camelCaseValue(entry)
+    ])
+  );
+}
+function completedRolloutHistoryItem(payload, timestamp) {
+  if (!payload?.item || typeof payload.item !== "object") {
+    return null;
+  }
+  const normalized = camelCaseValue(payload.item);
+  if (typeof normalized.id !== "string" || typeof normalized.type !== "string") {
+    return null;
+  }
+  const normalizedType = normalized.type.charAt(0).toLowerCase() + normalized.type.slice(1);
+  if (normalizedType === "userMessage" || normalizedType === "agentMessage") {
+    return null;
+  }
+  if (normalizedType === "reasoning") {
+    const summaryText = normalized.summaryText;
+    normalized.summary = Array.isArray(summaryText) ? summaryText.filter((entry) => typeof entry === "string") : typeof summaryText === "string" && summaryText.trim() ? [summaryText] : [];
+    const rawContent = normalized.rawContent;
+    normalized.text = Array.isArray(rawContent) ? rawContent.map(
+      (entry) => typeof entry === "string" ? entry : entry && typeof entry === "object" && typeof entry.text === "string" ? entry.text : ""
+    ).filter(Boolean).join("\n") : "";
+  }
+  const createdAtCandidate = typeof payload.started_at_ms === "number" ? payload.started_at_ms : timestamp ?? null;
+  const agentTurn = codexTurnToAgentTurn({
+    id: typeof payload.turn_id === "string" ? payload.turn_id : "rollout-turn",
+    status: "inProgress",
+    error: null,
+    items: [
+      {
+        ...normalized,
+        id: normalized.id,
+        type: normalizedType,
+        createdAt: createdAtCandidate
+      }
+    ]
+  });
+  return agentTurn.items[0] ?? null;
+}
+function appendUniqueTurnItem(turn, item) {
+  const existingIndex = turn.items.findIndex((entry) => entry.id === item.id);
+  if (existingIndex >= 0) {
+    turn.items[existingIndex] = item;
+    return;
+  }
+  turn.items.push(item);
+}
 function finalizeTurn(turn, turns) {
   if (!turn || turn.items.length === 0) {
     return;
@@ -9403,7 +9522,98 @@ function finalizeTurn(turn, turns) {
     items: turn.items
   });
 }
+function isoTimestampFromEpochSeconds(value) {
+  return value === null || !Number.isFinite(value) ? null : new Date(value * 1e3).toISOString();
+}
+function normalizePaginatedTurnStatus(status) {
+  switch (status) {
+    case "completed":
+    case "interrupted":
+    case "failed":
+    case "inProgress":
+      return status;
+    default:
+      return "inProgress";
+  }
+}
+function parsePaginatedTurnError(value) {
+  if (!value) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(value);
+    if (parsed && typeof parsed === "object" && typeof parsed.message === "string") {
+      return parsed;
+    }
+    return { message: value };
+  } catch {
+    return { message: value };
+  }
+}
+function mergeSessionTurns(paginatedTurns, transcriptTurns) {
+  if (paginatedTurns.length === 0) {
+    return transcriptTurns;
+  }
+  const transcriptById = new Map(
+    transcriptTurns.map((turn) => [turn.id, turn])
+  );
+  const merged = paginatedTurns.map((turn) => {
+    const transcriptTurn = transcriptById.get(turn.id);
+    if (!transcriptTurn) {
+      return turn;
+    }
+    transcriptById.delete(turn.id);
+    const paginatedItemIds = new Set(turn.items.map((item) => item.id));
+    const missingTranscriptItems = transcriptTurn.items.filter(
+      (item) => !paginatedItemIds.has(item.id)
+    );
+    const items = [...turn.items, ...missingTranscriptItems].map((item, index) => ({ item, index })).sort((left, right) => {
+      const leftMillis = Date.parse(left.item.createdAt ?? "");
+      const rightMillis = Date.parse(right.item.createdAt ?? "");
+      if (Number.isFinite(leftMillis) && Number.isFinite(rightMillis)) {
+        const delta = leftMillis - rightMillis;
+        return delta === 0 ? left.index - right.index : delta;
+      }
+      if (Number.isFinite(leftMillis)) return -1;
+      if (Number.isFinite(rightMillis)) return 1;
+      return left.index - right.index;
+    }).map((entry, transcriptOrder) => ({
+      ...entry.item,
+      transcriptOrder
+    }));
+    return {
+      ...turn,
+      startedAt: turn.startedAt ?? transcriptTurn.startedAt,
+      status: transcriptTurn.status,
+      error: transcriptTurn.error ?? turn.error,
+      items
+    };
+  });
+  merged.push(...transcriptById.values());
+  return merged.sort(
+    (left, right) => (left.startedAt ?? "").localeCompare(right.startedAt ?? "")
+  );
+}
 function parseTranscript(contents) {
+  const entries = contents.split("\n").filter((line) => line.trim()).flatMap((line) => {
+    try {
+      return [JSON.parse(line)];
+    } catch {
+      return [];
+    }
+  });
+  let transcriptSegmentIndex = -1;
+  const indexedEntries = entries.map((entry) => {
+    if (entry.type === "event_msg" && entry.payload?.type === "task_started") {
+      transcriptSegmentIndex += 1;
+    }
+    return { entry, segmentIndex: transcriptSegmentIndex };
+  });
+  const legacyMessageSegments = new Set(
+    indexedEntries.filter(
+      ({ entry }) => entry.type === "event_msg" && (entry.payload?.type === "user_message" || entry.payload?.type === "agent_message")
+    ).map(({ segmentIndex }) => segmentIndex)
+  );
   const turns = [];
   let cwd = null;
   let currentTurn = null;
@@ -9426,16 +9636,7 @@ function parseTranscript(contents) {
     userItemCount = 0;
     return currentTurn;
   };
-  for (const line of contents.split("\n")) {
-    if (!line.trim()) {
-      continue;
-    }
-    let entry;
-    try {
-      entry = JSON.parse(line);
-    } catch {
-      continue;
-    }
+  for (const { entry, segmentIndex } of indexedEntries) {
     if (entry.type === "session_meta") {
       const payload2 = entry.payload ?? {};
       if (typeof payload2.cwd === "string" && payload2.cwd.trim()) {
@@ -9443,6 +9644,33 @@ function parseTranscript(contents) {
       }
       continue;
     }
+    if (!legacyMessageSegments.has(segmentIndex) && entry.type === "response_item" && entry.payload?.type === "message") {
+      const payload2 = entry.payload;
+      const text2 = transcriptMessageText(payload2);
+      if (!text2 || payload2.role !== "user" && payload2.role !== "assistant") {
+        continue;
+      }
+      const turn = ensureCurrentTurn(entry.timestamp);
+      if (payload2.role === "user") {
+        userItemCount += 1;
+        turn.items.push({
+          id: typeof payload2.id === "string" && payload2.id.trim() ? payload2.id : createHistoryItemId(turn.id, "user", userItemCount),
+          kind: "userMessage",
+          text: text2,
+          createdAt: entry.timestamp ?? null
+        });
+      } else {
+        agentItemCount += 1;
+        turn.items.push({
+          id: typeof payload2.id === "string" && payload2.id.trim() ? payload2.id : createHistoryItemId(turn.id, "agent", agentItemCount),
+          kind: "agentMessage",
+          text: text2,
+          status: typeof payload2.phase === "string" ? payload2.phase : null,
+          createdAt: entry.timestamp ?? null
+        });
+      }
+      continue;
+    }
     if (entry.type !== "event_msg") {
       continue;
     }
@@ -9467,7 +9695,8 @@ function parseTranscript(contents) {
       turn.items.push({
         id: createHistoryItemId(turn.id, "user", userItemCount),
         kind: "userMessage",
-        text: payload.message
+        text: payload.message,
+        createdAt: entry.timestamp ?? null
       });
       continue;
     }
@@ -9478,10 +9707,21 @@ function parseTranscript(contents) {
         id: createHistoryItemId(turn.id, "agent", agentItemCount),
         kind: "agentMessage",
         text: payload.message,
-        status: typeof payload.phase === "string" ? payload.phase : null
+        status: typeof payload.phase === "string" ? payload.phase : null,
+        createdAt: entry.timestamp ?? null
       });
       continue;
     }
+    if (payloadType === "item_completed") {
+      const item = completedRolloutHistoryItem(
+        payload,
+        typeof entry.timestamp === "string" ? entry.timestamp : null
+      );
+      if (item) {
+        appendUniqueTurnItem(ensureCurrentTurn(entry.timestamp), item);
+      }
+      continue;
+    }
     if (payloadType === "task_complete") {
       const turn = ensureCurrentTurn(entry.timestamp);
       turn.status = turn.error ? "failed" : "completed";
@@ -9511,10 +9751,14 @@ async function fileExists(filePath) {
   }
 }
 var LocalCodexSessionStore = class {
-  constructor(codexHome) {
+  constructor(codexHome, options = {}) {
     this.codexHome = codexHome;
+    this.watchIntervalMs = options.watchIntervalMs ?? 500;
+    this.watchThrottleMs = options.watchThrottleMs ?? 1500;
   }
   codexHome;
+  watchIntervalMs;
+  watchThrottleMs;
   async findSession(sessionId) {
     const stateRecord = await this.findSessionInStateDatabases(sessionId);
     const transcriptPath = await this.resolveTranscriptPath(
@@ -9522,6 +9766,7 @@ var LocalCodexSessionStore = class {
       sessionId
     );
     const transcript = transcriptPath ? parseTranscript(await fs6.readFile(transcriptPath, "utf8")) : null;
+    const paginatedTurns = await this.findPaginatedTurns(sessionId);
     const cwd = stateRecord?.cwd ?? transcript?.cwd ?? null;
     if (!cwd) {
       return null;
@@ -9532,7 +9777,57 @@ var LocalCodexSessionStore = class {
       title: stateRecord?.title?.trim() || transcript?.title?.trim() || basenameFromPath(cwd),
       model: stateRecord?.model ?? null,
       rolloutPath: transcriptPath,
-      turns: transcript?.turns ?? []
+      turns: mergeSessionTurns(paginatedTurns, transcript?.turns ?? [])
+    };
+  }
+  async watchSession(sessionId, onChange) {
+    const stateRecord = await this.findSessionInStateDatabases(sessionId);
+    const transcriptPath = await this.resolveTranscriptPath(
+      stateRecord?.rolloutPath ?? null,
+      sessionId
+    );
+    if (!transcriptPath) {
+      return () => {
+      };
+    }
+    let stopped = false;
+    let lastEmittedAt = 0;
+    let pending = null;
+    const emit = () => {
+      pending = null;
+      if (stopped) {
+        return;
+      }
+      lastEmittedAt = Date.now();
+      onChange();
+    };
+    const schedule = () => {
+      if (stopped || pending) {
+        return;
+      }
+      const delay = Math.max(
+        0,
+        this.watchThrottleMs - (Date.now() - lastEmittedAt)
+      );
+      pending = setTimeout(emit, delay);
+    };
+    const listener = (current, previous) => {
+      if (current.size !== previous.size || current.mtimeMs !== previous.mtimeMs) {
+        schedule();
+      }
+    };
+    watchFile(
+      transcriptPath,
+      { persistent: false, interval: this.watchIntervalMs },
+      listener
+    );
+    return () => {
+      stopped = true;
+      if (pending) {
+        clearTimeout(pending);
+        pending = null;
+      }
+      unwatchFile(transcriptPath, listener);
     };
   }
   async findImportSession(sessionId, input) {
@@ -9557,29 +9852,36 @@ var LocalCodexSessionStore = class {
     };
   }
   async findSessionInStateDatabases(sessionId) {
-    let entries;
-    try {
-      entries = await fs6.readdir(this.codexHome);
-    } catch {
-      return null;
-    }
-    const stateFiles = await Promise.all(
-      entries.filter((entry) => /^state_\d+\.sqlite$/i.test(entry)).map(async (entry) => {
-        const absPath = path7.join(this.codexHome, entry);
-        const stats = await fs6.stat(absPath);
-        return {
-          absPath,
-          mtimeMs: stats.mtimeMs
-        };
-      })
-    );
+    const stateFiles = (await Promise.all(
+      [this.codexHome, path7.join(this.codexHome, "sqlite")].map(
+        async (directory) => {
+          let entries;
+          try {
+            entries = await fs6.readdir(directory);
+          } catch {
+            return [];
+          }
+          return Promise.all(
+            entries.filter((entry) => /^state_\d+\.sqlite$/i.test(entry)).map(async (entry) => {
+              const absPath = path7.join(directory, entry);
+              const stats = await fs6.stat(absPath);
+              return {
+                absPath,
+                mtimeMs: stats.mtimeMs
+              };
+            })
+          );
+        }
+      )
+    )).flat();
     stateFiles.sort((left, right) => right.mtimeMs - left.mtimeMs);
     for (const stateFile of stateFiles) {
-      const sqlite = new Database2(stateFile.absPath, {
-        readonly: true,
-        fileMustExist: true
-      });
+      let sqlite = null;
       try {
+        sqlite = new Database2(stateFile.absPath, {
+          readonly: true,
+          fileMustExist: true
+        });
         const row = sqlite.prepare(
           `
               SELECT
@@ -9598,11 +9900,91 @@ var LocalCodexSessionStore = class {
         }
       } catch {
       } finally {
-        sqlite.close();
+        sqlite?.close();
       }
     }
     return null;
   }
+  async findPaginatedTurns(sessionId) {
+    const databasePath = path7.join(this.codexHome, "thread_history_1.sqlite");
+    let sqlite = null;
+    try {
+      sqlite = new Database2(databasePath, {
+        readonly: true,
+        fileMustExist: true
+      });
+      const turnRows = sqlite.prepare(
+        `
+          SELECT
+            turn_id AS turnId,
+            rollout_ordinal AS rolloutOrdinal,
+            status,
+            error_json AS errorJson,
+            started_at AS startedAt
+          FROM thread_turns
+          WHERE thread_id = ?
+          ORDER BY rollout_ordinal ASC
+        `
+      ).all(sessionId);
+      if (turnRows.length === 0) {
+        return [];
+      }
+      const itemRows = sqlite.prepare(
+        `
+          SELECT
+            turn_id AS turnId,
+            rollout_ordinal AS rolloutOrdinal,
+            created_at_ms AS createdAtMs,
+            item_type AS itemType,
+            item_json AS itemJson
+          FROM thread_items
+          WHERE thread_id = ?
+          ORDER BY rollout_ordinal ASC
+        `
+      ).all(sessionId);
+      const itemsByTurnId = /* @__PURE__ */ new Map();
+      for (const row of itemRows) {
+        let parsed;
+        try {
+          parsed = JSON.parse(row.itemJson);
+        } catch {
+          continue;
+        }
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+          continue;
+        }
+        const parsedRecord = parsed;
+        if (typeof parsedRecord.id !== "string" || !parsedRecord.id.trim()) {
+          continue;
+        }
+        const item = {
+          ...parsedRecord,
+          id: parsedRecord.id,
+          type: typeof parsedRecord.type === "string" ? parsedRecord.type : row.itemType,
+          createdAt: row.createdAtMs
+        };
+        const turnItems = itemsByTurnId.get(row.turnId) ?? [];
+        turnItems.push(item);
+        itemsByTurnId.set(row.turnId, turnItems);
+      }
+      return turnRows.map((row) => {
+        const agentTurn = codexTurnToAgentTurn({
+          id: row.turnId,
+          status: normalizePaginatedTurnStatus(row.status),
+          error: parsePaginatedTurnError(row.errorJson),
+          items: itemsByTurnId.get(row.turnId) ?? []
+        });
+        return agentTurnToThreadTurnDto({
+          ...agentTurn,
+          startedAt: isoTimestampFromEpochSeconds(row.startedAt)
+        });
+      });
+    } catch {
+      return [];
+    } finally {
+      sqlite?.close();
+    }
+  }
   async resolveTranscriptPath(rolloutPath, sessionId) {
     if (rolloutPath?.trim()) {
       const absolutePath = path7.isAbsolute(rolloutPath) ? rolloutPath : path7.resolve(this.codexHome, rolloutPath);
@@ -25206,24 +25588,30 @@ var DEFERRED_FILE_READ_DETAIL_TITLE = "File Read Details";
 var DEFERRED_WEB_SEARCH_DETAIL_TITLE = "Web Search Details";
 var DEFERRED_HOOK_DETAIL_TITLE = "Hook Details";
 function parseUuidV7Timestamp2(id) {
-  const normalized = id.replace(/-/g, "");
-  if (!/^[0-9a-f]{32}$/i.test(normalized) || normalized[12]?.toLowerCase() !== "7") {
-    return null;
-  }
-  const millis = Number.parseInt(normalized.slice(0, 12), 16);
-  if (!Number.isFinite(millis)) {
-    return null;
+  const candidates = [
+    id,
+    ...id.match(
+      /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|[0-9a-f]{32}/gi
+    ) ?? []
+  ];
+  for (const candidate of candidates) {
+    const normalized = candidate.replace(/-/g, "");
+    if (!/^[0-9a-f]{32}$/i.test(normalized) || normalized[12]?.toLowerCase() !== "7") {
+      continue;
+    }
+    const millis = Number.parseInt(normalized.slice(0, 12), 16);
+    if (Number.isFinite(millis)) {
+      return new Date(millis).toISOString();
+    }
   }
-  return new Date(millis).toISOString();
+  return null;
 }
-function normalizeHistoryItemCreatedAt(item, fallback) {
+function normalizeHistoryItemCreatedAt(item) {
   if (item.createdAt) {
     return item;
   }
-  return {
-    ...item,
-    createdAt: parseUuidV7Timestamp2(item.id) ?? fallback
-  };
+  const inferredCreatedAt = parseUuidV7Timestamp2(item.id);
+  return inferredCreatedAt ? { ...item, createdAt: inferredCreatedAt } : item;
 }
 function summarizeText(text2, fallback) {
   const lines = text2.replace(/\r\n/g, "\n").split("\n");
@@ -25362,7 +25750,7 @@ function deferHistoryItemDetail(item, deferredDetails) {
 function deferHistoryItemDetailForTransport(item) {
   return deferHistoryItemDetail(item, /* @__PURE__ */ new Map());
 }
-function deferLargeHistoryItemDetails(turn, deferredDetails) {
+function deferLargeHistoryItemDetails2(turn, deferredDetails) {
   return {
     ...turn,
     items: turn.items.map((item) => deferHistoryItemDetail(item, deferredDetails))
@@ -25380,7 +25768,7 @@ function shouldPersistRuntimeFinalHistoryItem(item) {
   }
   return shouldPersistFinalHistoryItem(item);
 }
-function visibleRuntimeTurnItems(items) {
+function visibleRuntimeTurnItems2(items) {
   const hasFinalAgentMessage = items.some(
     (item) => item.kind === "agentMessage" && !isTransientAgentHistoryItem(item)
   );
@@ -25413,7 +25801,7 @@ function historyItemTranscriptOrder(item) {
 }
 function copyPersistedOrderingHints(item, persistedItem, turnStartedAt) {
   let nextItem = item;
-  if (persistedItem.createdAt && (!nextItem.createdAt || nextItem.kind === "agentMessage" && nextItem.createdAt === turnStartedAt)) {
+  if (persistedItem.createdAt && (!nextItem.createdAt || nextItem.createdAt === turnStartedAt)) {
     nextItem = { ...nextItem, createdAt: persistedItem.createdAt };
   }
   if (hasHistoryItemSequence(persistedItem)) {
@@ -25587,21 +25975,20 @@ function mergePersistedHistoryItemsIntoTurns(turns, persistedItemsByTurnId, defe
     };
   });
 }
-function agentTurnToThreadTurnDto(turn, deferredDetails) {
+function agentTurnToThreadTurnDto2(turn, deferredDetails) {
   const startedAt = turn.startedAt ?? parseUuidV7Timestamp2(turn.providerTurnId);
   const baseTurn = {
     id: turn.providerTurnId,
     startedAt,
     status: turn.status,
     error: turn.error?.message ?? null,
-    items: visibleRuntimeTurnItems(turn.items).map(
+    items: visibleRuntimeTurnItems2(turn.items).map(
       (item, transcriptIndex) => normalizeHistoryItemCreatedAt(
-        item.transcriptOrder === transcriptIndex ? item : { ...item, transcriptOrder: transcriptIndex },
-        startedAt
+        item.transcriptOrder === transcriptIndex ? item : { ...item, transcriptOrder: transcriptIndex }
       )
     )
   };
-  return deferredDetails ? deferLargeHistoryItemDetails(baseTurn, deferredDetails) : baseTurn;
+  return deferredDetails ? deferLargeHistoryItemDetails2(baseTurn, deferredDetails) : baseTurn;
 }
 function applyRecordedTurnItemOrder(turn, turnItemOrder) {
   const itemOrder = turnItemOrder.get(turn.id);
@@ -27245,10 +27632,7 @@ var ThreadDetailAssembler = class {
     if (cached) {
       return cached;
     }
-    let remoteSession = await this.input.callbacks.readRemoteSession(
-      input.record,
-      options
-    );
+    let remoteSession = input.record.source === "local_codex_import" && input.record.isConnected === false ? null : await this.input.callbacks.readRemoteSession(input.record, options);
     if (!remoteSession) {
       return this.buildLocalFallbackEntry({
         ...input,
@@ -27317,7 +27701,7 @@ var ThreadDetailAssembler = class {
       input.localThreadId,
       remoteSession.turns
     );
-    const visibleTurns = this.input.liveState.visibleRemoteTurns(input.localThreadId, remoteSession.turns).map((turn) => agentTurnToThreadTurnDto(turn, deferredDetails));
+    const visibleTurns = this.input.liveState.visibleRemoteTurns(input.localThreadId, remoteSession.turns).map((turn) => agentTurnToThreadTurnDto2(turn, deferredDetails));
     const visibleTurnsWithActiveLiveTurn = appendActiveLiveTurnIfMissing(
       visibleTurns,
       input.localThreadId,
@@ -27404,7 +27788,7 @@ var ThreadDetailAssembler = class {
       deferredDetails
     ).map(
       (turn) => buildTurnDto(
-        deferLargeHistoryItemDetails(turn, deferredDetails),
+        deferLargeHistoryItemDetails2(turn, deferredDetails),
         input.turnMetadataById.get(turn.id) ?? fallbackMetadata
       )
     );
@@ -31040,6 +31424,7 @@ var ThreadService = class {
   constructor(db, agentRuntimes, eventBus, localSessionStore, workspaceRoot, providerManagement, pluginService, config) {
     this.db = db;
     this.eventBus = eventBus;
+    this.localSessionStore = localSessionStore;
     this.workspaceRoot = workspaceRoot;
     this.pluginService = pluginService;
     this.config = config;
@@ -31260,6 +31645,7 @@ var ThreadService = class {
   }
   db;
   eventBus;
+  localSessionStore;
   workspaceRoot;
   pluginService;
   config;
@@ -31283,6 +31669,8 @@ var ThreadService = class {
   forkCoordinator;
   attachmentCoordinator;
   importCoordinator;
+  localImportWatcherStops = /* @__PURE__ */ new Map();
+  localImportWatcherStarts = /* @__PURE__ */ new Map();
   normalizeProvider(provider2) {
     return this.providerRuntime.normalizeProvider(provider2);
   }
@@ -31330,7 +31718,7 @@ var ThreadService = class {
       if (displayTurnId === turn.providerTurnId) {
         continue;
       }
-      const dto = agentTurnToThreadTurnDto(
+      const dto = agentTurnToThreadTurnDto2(
         turn,
         /* @__PURE__ */ new Map()
       );
@@ -31458,6 +31846,11 @@ var ThreadService = class {
   async getThreadDetail(localThreadId, options = {}) {
     const record2 = this.requireThreadRecord(localThreadId);
     const workspace = this.requireWorkspaceForThread(record2);
+    if (record2.source === "local_codex_import" && record2.isConnected === false) {
+      await this.ensureLocalImportWatcher(record2);
+    } else {
+      this.stopLocalImportWatcher(record2.id);
+    }
     this.requireProviderSessionId(record2);
     const loadedIds = await this.listLoadedProviderSessionIds(record2.provider);
     const workspacePathStatus = await pathExists3(workspace.absPath) ? "present" : "missing";
@@ -32081,6 +32474,52 @@ var ThreadService = class {
   async handleRuntimeEvent(event) {
     await this.runtimeEventProjector.handleRuntimeEvent(event);
   }
+  close() {
+    for (const stop of this.localImportWatcherStops.values()) {
+      stop();
+    }
+    this.localImportWatcherStops.clear();
+    this.localImportWatcherStarts.clear();
+  }
+  async ensureLocalImportWatcher(record2) {
+    if (!record2.providerSessionId || !this.localSessionStore.watchSession || this.localImportWatcherStops.has(record2.id)) {
+      return;
+    }
+    const existingStart = this.localImportWatcherStarts.get(record2.id);
+    if (existingStart) {
+      await existingStart;
+      return;
+    }
+    const start = this.localSessionStore.watchSession(
+      record2.providerSessionId,
+      () => {
+        const current = getThreadRecordById(this.db, record2.id);
+        if (!current || current.source !== "local_codex_import" || current.isConnected !== false) {
+          this.stopLocalImportWatcher(record2.id);
+          return;
+        }
+        this.invalidateThreadDetailCache(record2.id);
+        this.emitThreadEvent("thread.updated", record2.id, {
+          reason: "external_session_updated"
+        });
+      }
+    ).then((stop) => {
+      const current = getThreadRecordById(this.db, record2.id);
+      if (!current || current.source !== "local_codex_import" || current.isConnected !== false) {
+        stop();
+        return;
+      }
+      this.localImportWatcherStops.set(record2.id, stop);
+    }).finally(() => {
+      this.localImportWatcherStarts.delete(record2.id);
+    });
+    this.localImportWatcherStarts.set(record2.id, start);
+    await start;
+  }
+  stopLocalImportWatcher(localThreadId) {
+    this.localImportWatcherStops.get(localThreadId)?.();
+    this.localImportWatcherStops.delete(localThreadId);
+  }
   shouldPreserveCompletedPendingSteer(localThreadId) {
     const record2 = getThreadRecordById(this.db, localThreadId);
     if (!record2) {
@@ -38147,6 +38586,7 @@ function buildApp(options = {}) {
   });
   app2.addHook("onClose", async () => {
     cleanupRelayActivity?.();
+    threadService.close();
     await shellService.stop();
     relayTunnelClient?.stop();
     await Promise.all(agentRuntimes.all().map((runtime) => runtime.stop()));