@jingyi0605/codingns 0.9.5 → 0.9.7

package/node_modules/@codingns/session-sync-core/dist/providers/codex.js

@@ -35,7 +35,7 @@ export class CodexAdapter {
         const startedAt = Date.now();
         const targetPath = normalizeWorkspacePath(workspacePath);
         const knownSessions = (options?.knownSessions ?? []).filter((session) => session.provider === this.providerId);
-        const threadMetadataIndex = this.readThreadMetadataIndex();
+        const threadMetadataIndex = await this.readThreadMetadataIndexForWorkspace(targetPath);
         const files = this.listSessionFiles(targetPath, threadMetadataIndex, knownSessions);
         const knownByRawStoreRef = new Map(knownSessions.map((session) => [session.rawStoreRef, session]));
         const knownByProviderSessionId = new Map(knownSessions.map((session) => [session.providerSessionId, session]));
@@ -239,6 +239,7 @@ export class CodexAdapter {
                 resolveCodexFallbackTitle(messages) ??
                 fileSessionId;
             const lastMessageAt = messages.at(-1)?.timestamp ?? (ensureText(metaPayload.timestamp) || null);
+            const fileActivityObservation = resolveCodexJsonlActivityObservation(filterInheritedCodexSubagentRecords(records, codexSessionId));
             const summary = this.hydrateSessionSummary({
                 provider: this.providerId,
                 providerSessionId: codexSessionId,
@@ -247,7 +248,8 @@ export class CodexAdapter {
                 rawStoreRef: filePath,
                 lastMessageAt,
                 messageCount: messages.length,
-                isArchived: false
+                isArchived: false,
+                activityObservation: fileActivityObservation
             }, filePath, stats, currentThreadMetadata, currentSpawnRelation);
             sessionsByProviderSessionId.set(codexSessionId, summary);
             this.touchSessionSummaryCache(filePath, {
@@ -556,6 +558,19 @@ export class CodexAdapter {
     }
     async renameSessionTitle(providerSessionId, rawStoreRef, title) {
         const nextTitle = title.trim();
+        const transport = this.options.threadControlTransportFactory?.();
+        if (transport) {
+            try {
+                await transport.initialize();
+                await transport.setThreadName?.(providerSessionId, nextTitle);
+            }
+            catch {
+                // app-server 的 thread/name/set 是首选，但失败时不能破坏原有本地改名能力。
+            }
+            finally {
+                transport.close();
+            }
+        }
         const resolvedStoreRef = this.resolveSessionFilePath(rawStoreRef, providerSessionId);
         const indexPath = join(this.options.homeDir, "session_index.jsonl");
         const stateDbPath = findLatestCodexStateDatabase(this.options.homeDir);
@@ -794,11 +809,15 @@ export class CodexAdapter {
                         title: normalizeCodexIndexedTitle(ensureText(record.thread_name)) || null,
                         cwd: null,
                         createdAtMs: null,
+                        updatedAtMs: null,
                         firstUserMessage: null,
                         agentNickname: null,
                         agentRole: null,
+                        parentProviderSessionId: null,
+                        parentRelationKind: null,
                         isArchived: null,
-                        rolloutPath: null
+                        rolloutPath: null,
+                        activityObservation: null
                     });
                 }
                 catch {
@@ -844,15 +863,19 @@ export class CodexAdapter {
                     title: current?.title ?? dbTitle,
                     cwd: ensureText(row.cwd).trim() || (current?.cwd ?? null),
                     createdAtMs: Number.isFinite(createdAtSeconds) ? createdAtSeconds * 1000 : null,
+                    updatedAtMs: current?.updatedAtMs ?? null,
                     firstUserMessage: ensureText(row.first_user_message).trim() || (current?.firstUserMessage ?? null),
                     agentNickname: ensureText(row.agent_nickname).trim() || (current?.agentNickname ?? null),
                     agentRole: ensureText(row.agent_role).trim() || (current?.agentRole ?? null),
+                    parentProviderSessionId: current?.parentProviderSessionId ?? null,
+                    parentRelationKind: current?.parentRelationKind ?? null,
                     rolloutPath: ensureText(row.rollout_path).trim() || (current?.rolloutPath ?? null),
                     isArchived: typeof row.archived === "number"
                         ? row.archived === 1
                         : ensureText(row.rollout_path).includes("archived_sessions")
                             ? true
-                            : (current?.isArchived ?? null)
+                            : (current?.isArchived ?? null),
+                    activityObservation: current?.activityObservation ?? null
                 });
             }
         }
@@ -876,6 +899,91 @@ export class CodexAdapter {
         };
         return index;
     }
+    async readThreadMetadataIndexForWorkspace(workspacePath) {
+        const index = new Map(this.readThreadMetadataIndex());
+        await this.mergeAppServerThreadMetadata(index, workspacePath);
+        return index;
+    }
+    async mergeAppServerThreadMetadata(index, workspacePath) {
+        const createTransport = this.options.threadControlTransportFactory;
+        if (!createTransport) {
+            return;
+        }
+        const transport = createTransport();
+        try {
+            await transport.initialize();
+            const threads = await transport.listThreads?.({ workspacePath });
+            if (!threads || threads.length === 0) {
+                return;
+            }
+            for (const thread of threads) {
+                const metadata = normalizeCodexAppServerThreadMetadata(thread);
+                if (!metadata) {
+                    continue;
+                }
+                const current = index.get(metadata.threadId);
+                index.set(metadata.threadId, {
+                    title: metadata.title ?? current?.title ?? null,
+                    cwd: metadata.cwd ?? current?.cwd ?? null,
+                    createdAtMs: metadata.createdAtMs ?? current?.createdAtMs ?? null,
+                    updatedAtMs: metadata.updatedAtMs ?? current?.updatedAtMs ?? null,
+                    firstUserMessage: metadata.firstUserMessage ?? current?.firstUserMessage ?? null,
+                    agentNickname: metadata.agentNickname ?? current?.agentNickname ?? null,
+                    agentRole: metadata.agentRole ?? current?.agentRole ?? null,
+                    parentProviderSessionId: metadata.parentProviderSessionId ?? current?.parentProviderSessionId ?? null,
+                    parentRelationKind: metadata.parentRelationKind ?? current?.parentRelationKind ?? null,
+                    isArchived: metadata.isArchived ?? current?.isArchived ?? null,
+                    rolloutPath: metadata.rolloutPath ?? current?.rolloutPath ?? null,
+                    activityObservation: metadata.activityObservation ?? current?.activityObservation ?? null
+                });
+            }
+            await this.mergeAppServerSubagentActivityFromParentThreads(index, threads, transport);
+        }
+        catch {
+            // app-server 是增强信息来源，失败时退回 JSONL/state DB，不能拖垮会话列表。
+        }
+        finally {
+            transport.close();
+        }
+    }
+    async mergeAppServerSubagentActivityFromParentThreads(index, threads, transport) {
+        const childrenByParentThreadId = new Map();
+        for (const thread of threads) {
+            const metadata = normalizeCodexAppServerThreadMetadata(thread);
+            if (!metadata
+                || metadata.parentRelationKind !== "spawn"
+                || !metadata.parentProviderSessionId) {
+                continue;
+            }
+            const children = childrenByParentThreadId.get(metadata.parentProviderSessionId) ?? [];
+            children.push(metadata.threadId);
+            childrenByParentThreadId.set(metadata.parentProviderSessionId, children);
+        }
+        for (const [parentThreadId, childThreadIds] of childrenByParentThreadId) {
+            let parentThread = null;
+            try {
+                const result = await transport.readThread(parentThreadId);
+                parentThread = asCodexRecord(result.thread) ?? result;
+            }
+            catch {
+                continue;
+            }
+            for (const childThreadId of childThreadIds) {
+                const observation = resolveLatestCodexCollabAgentActivityObservation(parentThread, childThreadId);
+                if (!observation) {
+                    continue;
+                }
+                const current = index.get(childThreadId);
+                if (!current) {
+                    continue;
+                }
+                index.set(childThreadId, {
+                    ...current,
+                    activityObservation: observation
+                });
+            }
+        }
+    }
     listSessionFiles(targetPath, threadMetadataIndex, knownSessions) {
         const activeFiles = walkJsonlFiles(join(this.options.homeDir, "sessions"));
         const archivedFiles = this.listArchivedSessionFiles(targetPath, threadMetadataIndex, knownSessions);
@@ -1151,12 +1259,20 @@ export class CodexAdapter {
         const indexedTitle = normalizeCodexIndexedTitle(metadata?.title);
         const normalizedFirstUserMessage = normalizeCodexIndexedTitle(metadata?.firstUserMessage);
         if (indexedTitle) {
+            if (isCodexSubagentThread(metadata, null)
+                && normalizedFirstUserMessage
+                && indexedTitle === normalizedFirstUserMessage) {
+                return null;
+            }
             // Codex 有时会把第一条用户消息原样回填成 title，这种脏标题仍然按统一长度预算裁掉。
             if (normalizedFirstUserMessage && indexedTitle === normalizedFirstUserMessage) {
                 return indexedTitle.slice(0, CODEX_SESSION_TITLE_MAX_LENGTH);
             }
             return indexedTitle;
         }
+        if (isCodexSubagentThread(metadata, null)) {
+            return null;
+        }
         return normalizeCodexMessageTitle(metadata?.firstUserMessage);
     }
     readSpawnedAgentRelationIndex(files, targetPath, threadMetadataIndex, candidateThreadIds) {
@@ -1283,6 +1399,13 @@ export class CodexAdapter {
             if (directRelations.has(threadId)) {
                 continue;
             }
+            if (metadata.parentProviderSessionId) {
+                directRelations.set(threadId, {
+                    parentProviderSessionId: metadata.parentProviderSessionId,
+                    kind: metadata.parentRelationKind ?? "spawn"
+                });
+                continue;
+            }
             if (!metadata.agentRole && !metadata.agentNickname) {
                 continue;
             }
@@ -1331,11 +1454,13 @@ export class CodexAdapter {
     hydrateSessionSummary(summary, filePath, stats, metadata, relation) {
         const resolvedRelation = relation ?? null;
         const resolvedMetadata = metadata ?? null;
+        const metadataTitle = resolveCodexMetadataTitle(resolvedMetadata);
         const isSubagent = resolvedMetadata || resolvedRelation
             ? isCodexSubagentThread(resolvedMetadata, resolvedRelation)
             : Boolean(summary.isSubagent);
         return {
             ...summary,
+            title: metadataTitle ?? summary.title,
             rawStoreRef: filePath,
             isArchived: resolveCodexArchivedState(resolvedMetadata, filePath),
             parentProviderSessionId: resolvedRelation?.parentProviderSessionId ?? summary.parentProviderSessionId ?? null,
@@ -1344,14 +1469,15 @@ export class CodexAdapter {
                 ? buildCodexSubagentLabel(resolvedMetadata)
                 : summary.subagentLabel ?? null,
             sourceMtimeMs: stats.mtimeMs,
-            sourceSizeBytes: stats.size
+            sourceSizeBytes: stats.size,
+            activityObservation: mergeCodexActivityObservation(resolvedMetadata?.activityObservation ?? null, summary.activityObservation ?? null)
         };
     }
     parseMessages(filePath, records, providerSessionId) {
         return this.parseMessagesFromEntries(filePath, records, providerSessionId);
     }
     parseMessagesFromEntries(filePath, records, providerSessionId) {
-        const effectiveRecords = filterRolledBackCodexRecords(records);
+        const effectiveRecords = filterRolledBackCodexRecords(filterInheritedCodexSubagentRecords(records, providerSessionId));
         const messages = [];
         const messageIndexesByKey = new Map();
         const toolNameById = new Map();
@@ -1699,6 +1825,105 @@ function filterRolledBackCodexRecords(records) {
     }
     return filteredRecords;
 }
+function filterInheritedCodexSubagentRecords(records, providerSessionId) {
+    const boundary = resolveCodexSessionInheritanceBoundary(records, providerSessionId);
+    if (!boundary.inheritedParentThreadId || boundary.startLineNumber === null) {
+        return records;
+    }
+    const startLineNumber = boundary.startLineNumber;
+    return records.filter((record) => {
+        if (record.lineNumber < startLineNumber) {
+            return shouldKeepCodexRecordBeforeSubagentBoundary(record, boundary.threadId);
+        }
+        return true;
+    });
+}
+function resolveCodexSessionInheritanceBoundary(records, providerSessionId) {
+    const fallbackThreadId = ensureText(providerSessionId).trim();
+    let currentThreadId = fallbackThreadId;
+    let inheritedParentThreadId = null;
+    let startLineNumber = null;
+    for (const record of records) {
+        if (record.data.type !== "session_meta") {
+            continue;
+        }
+        const payload = (record.data.payload ?? {});
+        const metaId = ensureText(payload.id).trim();
+        const threadId = looksLikeCodexThreadId(metaId) ? metaId : fallbackThreadId || metaId;
+        const parentRelation = resolveCodexParentThreadRelation(payload);
+        const isSubagent = parentRelation.kind === "spawn"
+            || ensureText(payload.thread_source).trim() === "subagent"
+            || ensureText(payload.agent_nickname).trim().length > 0
+            || ensureText(payload.agent_role).trim().length > 0;
+        if (isSubagent
+            && parentRelation.parentThreadId
+            && (!fallbackThreadId || threadId === fallbackThreadId)) {
+            currentThreadId = threadId;
+            inheritedParentThreadId = parentRelation.parentThreadId;
+            continue;
+        }
+        if (inheritedParentThreadId && threadId === inheritedParentThreadId) {
+            continue;
+        }
+        if (inheritedParentThreadId && threadId === currentThreadId && startLineNumber === null) {
+            startLineNumber = record.lineNumber;
+        }
+    }
+    if (inheritedParentThreadId && startLineNumber === null) {
+        startLineNumber = findFirstOwnCodexSubagentTurnLineNumber(records, currentThreadId, inheritedParentThreadId);
+    }
+    return {
+        threadId: currentThreadId,
+        inheritedParentThreadId,
+        startLineNumber
+    };
+}
+function findFirstOwnCodexSubagentTurnLineNumber(records, threadId, inheritedParentThreadId) {
+    for (const record of records) {
+        if (record.data.type === "turn_context") {
+            const payload = (record.data.payload ?? {});
+            const turnId = ensureText(payload.turn_id).trim();
+            if (isCodexOwnTurnId(turnId, threadId, inheritedParentThreadId)) {
+                return record.lineNumber;
+            }
+            continue;
+        }
+        if (record.data.type !== "event_msg") {
+            continue;
+        }
+        const payload = (record.data.payload ?? {});
+        const eventType = ensureText(payload.type).trim();
+        const turnId = ensureText(payload.turn_id).trim();
+        if (eventType === "task_started"
+            && turnId.length > 0
+            && isCodexOwnTurnId(turnId, threadId, inheritedParentThreadId)) {
+            return record.lineNumber;
+        }
+    }
+    return null;
+}
+function isCodexOwnTurnId(turnId, threadId, inheritedParentThreadId) {
+    if (!looksLikeCodexThreadId(turnId)) {
+        return false;
+    }
+    if (turnId === inheritedParentThreadId) {
+        return false;
+    }
+    if (looksLikeCodexThreadId(threadId)) {
+        // Codex 的 thread id / turn id 都是 UUIDv7。子 Agent 自己的 turn 会在子 thread 创建之后；
+        // fork 继承来的父会话 turn 一定早于子 thread。这里用时间有序 ID 切掉继承前缀。
+        return turnId.localeCompare(threadId) >= 0;
+    }
+    return !turnId.startsWith(inheritedParentThreadId.slice(0, 8));
+}
+function shouldKeepCodexRecordBeforeSubagentBoundary(record, threadId) {
+    if (record.data.type !== "session_meta") {
+        return false;
+    }
+    const payload = (record.data.payload ?? {});
+    const metaId = ensureText(payload.id).trim();
+    return metaId === threadId;
+}
 function buildRecentHistoryPage(messages, totalMessageCount, limit) {
     const effectiveTotal = Math.max(totalMessageCount, messages.length);
     const pageMessages = messages.slice(-Math.min(limit, messages.length)).map((message, index, items) => ({
@@ -1952,6 +2177,13 @@ function readNonNegativeInteger(value) {
     }
     return null;
 }
+function readFiniteNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    const parsed = Number.parseFloat(ensureText(value));
+    return Number.isFinite(parsed) ? parsed : null;
+}
 function clampUsageRatio(promptTokens, contextWindow) {
     if (contextWindow <= 0) {
         return 0;
@@ -2019,6 +2251,353 @@ function resolveCodexParentThreadRelation(payload) {
         kind: null
     };
 }
+function normalizeCodexAppServerThreadMetadata(thread) {
+    const threadId = ensureText(thread.id).trim();
+    if (!looksLikeCodexThreadId(threadId)) {
+        return null;
+    }
+    const source = thread.source;
+    const sourceRecord = typeof source === "object" && source !== null
+        ? source
+        : null;
+    const subAgentSource = typeof sourceRecord?.subAgent === "object" && sourceRecord.subAgent !== null
+        ? sourceRecord.subAgent
+        : typeof sourceRecord?.subagent === "object" && sourceRecord.subagent !== null
+            ? sourceRecord.subagent
+            : null;
+    const threadSpawn = typeof subAgentSource?.thread_spawn === "object" && subAgentSource.thread_spawn !== null
+        ? subAgentSource.thread_spawn
+        : typeof subAgentSource?.threadSpawn === "object" && subAgentSource.threadSpawn !== null
+            ? subAgentSource.threadSpawn
+            : null;
+    const spawnParentThreadId = ensureText(threadSpawn?.parent_thread_id).trim()
+        || ensureText(threadSpawn?.parentThreadId).trim();
+    const forkedFromId = ensureText(thread.forkedFromId ?? thread.forked_from_id).trim();
+    const parentProviderSessionId = spawnParentThreadId || forkedFromId || null;
+    const agentNickname = ensureText(thread.agentNickname ?? thread.agent_nickname).trim()
+        || ensureText(threadSpawn?.agent_nickname ?? threadSpawn?.agentNickname).trim()
+        || null;
+    const agentRole = ensureText(thread.agentRole ?? thread.agent_role).trim()
+        || ensureText(threadSpawn?.agent_role ?? threadSpawn?.agentRole).trim()
+        || null;
+    const createdAtSeconds = readFiniteNumber(thread.createdAt ?? thread.created_at);
+    const updatedAtSeconds = readFiniteNumber(thread.updatedAt ?? thread.updated_at);
+    const preview = ensureText(thread.preview).trim();
+    const name = normalizeCodexIndexedTitle(ensureText(thread.name));
+    const path = ensureText(thread.path).trim();
+    const cwd = ensureText(thread.cwd).trim();
+    const activityObservation = resolveCodexThreadActivityObservation(thread);
+    return {
+        threadId,
+        title: name || null,
+        cwd: cwd || null,
+        createdAtMs: createdAtSeconds !== null ? createdAtSeconds * 1000 : null,
+        updatedAtMs: updatedAtSeconds !== null ? updatedAtSeconds * 1000 : null,
+        firstUserMessage: preview || null,
+        agentNickname,
+        agentRole,
+        parentProviderSessionId,
+        parentRelationKind: spawnParentThreadId.length > 0
+            ? "spawn"
+            : forkedFromId.length > 0
+                ? "fork"
+                : null,
+        isArchived: null,
+        rolloutPath: path || null,
+        activityObservation
+    };
+}
+function resolveCodexThreadActivityObservation(thread) {
+    const direct = resolveCodexThreadStatusActivityObservation(thread);
+    const threadId = ensureText(thread.id).trim();
+    const parent = resolveLatestCodexCollabAgentActivityObservation(thread, threadId);
+    if (!direct) {
+        return parent;
+    }
+    if (!parent) {
+        return direct;
+    }
+    if (isTerminalProviderSessionObservation(parent)
+        && (direct.runningState === "starting" || direct.runningState === "running")) {
+        return parent;
+    }
+    const directAt = direct.observedAt ?? "";
+    const parentAt = parent.observedAt ?? "";
+    if (parentAt && (!directAt || parentAt.localeCompare(directAt) >= 0)) {
+        return parent;
+    }
+    return direct;
+}
+function resolveCodexJsonlActivityObservation(records) {
+    let latest = null;
+    for (const record of records) {
+        if (record.data.type !== "event_msg") {
+            continue;
+        }
+        const payload = (record.data.payload ?? {});
+        const eventType = ensureText(payload.type).trim();
+        const turnId = ensureText(payload.turn_id).trim() || null;
+        const observedAt = (codexSecondsToIso(payload.completed_at ?? payload.completedAt)
+            ?? codexSecondsToIso(payload.started_at ?? payload.startedAt)
+            ?? ensureText(record.data.timestamp).trim())
+            || null;
+        let observation = null;
+        if (eventType === "task_started") {
+            observation = {
+                runningState: "running",
+                confidence: "strong",
+                observedAt,
+                detail: null,
+                errorCode: null,
+                runId: turnId
+            };
+        }
+        else if (eventType === "task_complete") {
+            observation = {
+                runningState: "completed",
+                confidence: "strong",
+                observedAt,
+                detail: null,
+                errorCode: null,
+                runId: turnId
+            };
+        }
+        else if (eventType === "task_failed") {
+            observation = {
+                runningState: "failed",
+                confidence: "strong",
+                observedAt,
+                detail: ensureText(payload.error).trim()
+                    || ensureText(payload.message).trim()
+                    || "Codex task failed",
+                errorCode: "CODEX_TASK_FAILED",
+                runId: turnId
+            };
+        }
+        if (!observation) {
+            continue;
+        }
+        if (!latest || compareNullableIso(observation.observedAt, latest.observedAt) >= 0) {
+            latest = observation;
+        }
+    }
+    return latest;
+}
+function mergeCodexActivityObservation(primary, fallback) {
+    if (!primary) {
+        return fallback;
+    }
+    if (!fallback) {
+        return primary;
+    }
+    if (isTerminalProviderSessionObservation(primary)) {
+        return primary;
+    }
+    if (isTerminalProviderSessionObservation(fallback)) {
+        return fallback;
+    }
+    if (primary.runningState === "starting" || primary.runningState === "running") {
+        return primary;
+    }
+    if (fallback.runningState === "starting" || fallback.runningState === "running") {
+        return fallback;
+    }
+    const primaryAt = primary.observedAt ?? "";
+    const fallbackAt = fallback.observedAt ?? "";
+    return fallbackAt && (!primaryAt || fallbackAt.localeCompare(primaryAt) > 0)
+        ? fallback
+        : primary;
+}
+function isTerminalProviderSessionObservation(observation) {
+    return observation.runningState === "completed"
+        || observation.runningState === "interrupted"
+        || observation.runningState === "failed";
+}
+function resolveCodexThreadStatusActivityObservation(thread) {
+    const status = asCodexRecord(thread.status);
+    const statusType = ensureText(status?.type).trim();
+    const observedAt = codexSecondsToIso(thread.updatedAt ?? thread.updated_at);
+    if (statusType === "active") {
+        return {
+            runningState: "running",
+            confidence: "authoritative",
+            observedAt,
+            detail: null,
+            errorCode: null,
+            runId: null
+        };
+    }
+    if (statusType === "idle" || statusType === "notLoaded") {
+        return {
+            runningState: "idle",
+            confidence: "strong",
+            observedAt,
+            detail: null,
+            errorCode: null,
+            runId: null
+        };
+    }
+    if (statusType === "systemError") {
+        return {
+            runningState: "failed",
+            confidence: "strong",
+            observedAt,
+            detail: "Codex app-server reported a system error",
+            errorCode: "CODEX_APP_SERVER_SYSTEM_ERROR",
+            runId: null
+        };
+    }
+    return null;
+}
+function resolveLatestCodexCollabAgentActivityObservation(thread, threadId) {
+    if (!threadId) {
+        return null;
+    }
+    let latest = null;
+    for (const turn of collectCodexThreadTurns(thread)) {
+        const turnRecord = asCodexRecord(turn);
+        const observedAt = codexSecondsToIso(turnRecord?.completedAt ?? turnRecord?.completed_at)
+            ?? codexSecondsToIso(turnRecord?.startedAt ?? turnRecord?.started_at)
+            ?? codexSecondsToIso(thread.updatedAt ?? thread.updated_at);
+        const runId = ensureText(turnRecord?.id).trim() || null;
+        const items = Array.isArray(turnRecord?.items) ? turnRecord.items : [];
+        for (const item of items) {
+            const itemRecord = asCodexRecord(item);
+            if (!itemRecord || ensureText(itemRecord.type).trim() !== "collabAgentToolCall") {
+                continue;
+            }
+            const receivers = Array.isArray(itemRecord.receiverThreadIds)
+                ? itemRecord.receiverThreadIds.map((value) => ensureText(value).trim())
+                : [];
+            if (!receivers.includes(threadId)) {
+                continue;
+            }
+            const agentsStates = asCodexRecord(itemRecord.agentsStates);
+            const agentState = asCodexRecord(agentsStates?.[threadId]);
+            const agentStatus = ensureText(agentState?.status).trim();
+            const observation = mapCodexCollabAgentStatusToActivityObservation({
+                status: agentStatus,
+                message: ensureText(agentState?.message).trim() || null,
+                tool: ensureText(itemRecord.tool).trim(),
+                callStatus: ensureText(itemRecord.status).trim(),
+                observedAt,
+                runId
+            });
+            if (!observation) {
+                continue;
+            }
+            if (!latest || compareNullableIso(observation.observedAt, latest.observedAt) >= 0) {
+                latest = observation;
+            }
+        }
+    }
+    return latest;
+}
+function mapCodexCollabAgentStatusToActivityObservation(input) {
+    const terminalDetail = input.message ?? null;
+    switch (input.status) {
+        case "pendingInit":
+            return {
+                runningState: "starting",
+                confidence: "authoritative",
+                observedAt: input.observedAt,
+                detail: input.tool ? `Codex sub-agent ${input.tool} is pending` : null,
+                errorCode: null,
+                runId: input.runId
+            };
+        case "running":
+            return {
+                runningState: "running",
+                confidence: "authoritative",
+                observedAt: input.observedAt,
+                detail: null,
+                errorCode: null,
+                runId: input.runId
+            };
+        case "completed":
+            return {
+                runningState: "completed",
+                confidence: "strong",
+                observedAt: input.observedAt,
+                detail: terminalDetail,
+                errorCode: null,
+                runId: input.runId
+            };
+        case "interrupted":
+            return {
+                runningState: "interrupted",
+                confidence: "strong",
+                observedAt: input.observedAt,
+                detail: terminalDetail,
+                errorCode: null,
+                runId: input.runId
+            };
+        case "errored":
+            return {
+                runningState: "failed",
+                confidence: "strong",
+                observedAt: input.observedAt,
+                detail: terminalDetail ?? "Codex sub-agent failed",
+                errorCode: "CODEX_SUBAGENT_FAILED",
+                runId: input.runId
+            };
+        case "shutdown":
+        case "notFound":
+            return {
+                runningState: "completed",
+                confidence: "strong",
+                observedAt: input.observedAt,
+                detail: terminalDetail,
+                errorCode: null,
+                runId: input.runId
+            };
+        default:
+            if (input.tool === "closeAgent" && input.callStatus === "completed") {
+                return {
+                    runningState: "completed",
+                    confidence: "strong",
+                    observedAt: input.observedAt,
+                    detail: terminalDetail,
+                    errorCode: null,
+                    runId: input.runId
+                };
+            }
+            return null;
+    }
+}
+function collectCodexThreadTurns(thread) {
+    if (Array.isArray(thread.turns)) {
+        return thread.turns;
+    }
+    const nestedThread = asCodexRecord(thread.thread);
+    if (Array.isArray(nestedThread?.turns)) {
+        return nestedThread.turns;
+    }
+    return [];
+}
+function asCodexRecord(value) {
+    return value && typeof value === "object" ? value : null;
+}
+function codexSecondsToIso(value) {
+    const seconds = readFiniteNumber(value);
+    if (seconds === null) {
+        return null;
+    }
+    const date = new Date(seconds * 1000);
+    return Number.isFinite(date.getTime()) ? date.toISOString() : null;
+}
+function compareNullableIso(left, right) {
+    if (left === right) {
+        return 0;
+    }
+    if (!left) {
+        return -1;
+    }
+    if (!right) {
+        return 1;
+    }
+    return left.localeCompare(right);
+}
 function toTimestampMs(value) {
     const timestampMs = Date.parse(ensureText(value).trim());
     return Number.isFinite(timestampMs) ? timestampMs : null;
@@ -2043,6 +2622,17 @@ function pickClosestCodexSpawnRecord(spawnRecords, workspacePath, message, creat
 function isCodexSubagentThread(metadata, relation) {
     return Boolean(relation?.kind === "spawn" || metadata?.agentRole || metadata?.agentNickname);
 }
+function resolveCodexMetadataTitle(metadata) {
+    const title = normalizeCodexIndexedTitle(metadata?.title);
+    if (!title) {
+        return null;
+    }
+    const firstUserMessage = normalizeCodexIndexedTitle(metadata?.firstUserMessage);
+    if (firstUserMessage && title === firstUserMessage) {
+        return null;
+    }
+    return title;
+}
 function buildCodexSubagentLabel(metadata) {
     const agentRole = metadata?.agentRole?.trim() || "";
     const agentNickname = metadata?.agentNickname?.trim() || "";