@promptbook/cli 0.113.0-9 → 0.114.0-1

package/apps/agents-server/src/utils/taskTerminal/resolveAdminTaskTerminalSession.ts

@@ -1,10 +1,14 @@
+import { readFile } from 'fs/promises';
+import { join } from 'path';
 import { spaceTrim } from 'spacetrim';
+import { buildAgentMessageRuntimeLogPathFromFileName } from '../../../../../src/utils/agent-message-runtime/agentMessageRuntimePaths';
 import { getUserChatJobById } from '../userChat/getUserChatJobById';
 import { getUserChatTimeoutById } from '../userChatTimeout/userChatTimeoutStore/getUserChatTimeoutById';
 import { VPS_SELF_UPDATE_ADMIN_CHAT_TASK_ID } from '../getAdminChatTasksResponse/mapVpsSelfUpdateJobToAdminChatTask';
+import { getLocalUserChatJobMetadata } from '../localChatRunner/LocalUserChatJobMetadata';
+import { resolveLocalAgentRootPath } from '../localChatRunner/ensureLocalAgentFolder';
 import { listPagePreviewBrowserAdminTasks } from '../pagePreviewBrowserSessions';
 import {
-    readVpsSelfUpdateJobSnapshot,
     readVpsSelfUpdateJobTaskSnapshots,
     readVpsSelfUpdateLogFileContent,
 } from '../vpsSelfUpdate';
@@ -28,9 +32,9 @@ const VPS_SELF_UPDATE_TASK_ID_PREFIX = `${VPS_SELF_UPDATE_ADMIN_CHAT_TASK_ID}:`;
 const PAGE_PREVIEW_TASK_ID_PREFIX = 'page-preview-';
 
 /**
- * How often the standalone VPS self-update installer log file is polled while streaming.
+ * How often a task-owned terminal log file is polled while streaming.
  */
-const VPS_SELF_UPDATE_TERMINAL_POLL_INTERVAL_MS = 2_000;
+const TASK_TERMINAL_LOG_FILE_POLL_INTERVAL_MS = 2_000;
 
 /**
  * Terminal subscribe function compatible with the shared admin terminal SSE helper.
@@ -92,6 +96,22 @@ async function resolveDurableTaskTerminalSession(taskId: string): Promise<AdminT
 
     const isRunning = task.status === 'QUEUED' || task.status === 'RUNNING';
 
+    if (job) {
+        const localRunnerMetadata = getLocalUserChatJobMetadata(job);
+
+        if (localRunnerMetadata) {
+            return await resolveLocalUserChatJobTerminalSession({
+                taskId,
+                isRunning,
+                startedAt: task.startedAt || task.queuedAt || task.createdAt,
+                finishedAt: task.completedAt,
+                exitCode: resolveFinishedTaskExitCode(task.status),
+                agentDirectoryName: localRunnerMetadata.agentDirectoryName,
+                fileName: localRunnerMetadata.fileName,
+            });
+        }
+    }
+
     return {
         session: createInMemoryTaskTerminalSession({
             taskId,
@@ -104,6 +124,47 @@ async function resolveDurableTaskTerminalSession(taskId: string): Promise<AdminT
     };
 }
 
+/**
+ * Resolves the terminal session backed by the local coding-harness runtime log file.
+ *
+ * @param options - Durable job lifecycle fields and local runner metadata.
+ * @returns Terminal resolution backed by the per-job harness log file.
+ */
+async function resolveLocalUserChatJobTerminalSession(options: {
+    readonly taskId: string;
+    readonly isRunning: boolean;
+    readonly startedAt: string;
+    readonly finishedAt: string | null;
+    readonly exitCode: number | null;
+    readonly agentDirectoryName: string;
+    readonly fileName: string;
+}): Promise<AdminTaskTerminalResolution> {
+    const runtimeLogPath = resolveLocalUserChatJobRuntimeLogPath({
+        agentDirectoryName: options.agentDirectoryName,
+        fileName: options.fileName,
+    });
+    const terminalLogSnapshot = getTaskTerminalLogSnapshot(options.taskId);
+    const output = (await readOptionalTextFile(runtimeLogPath)) || terminalLogSnapshot?.output || '';
+    const session: TaskTerminalLogSnapshot = {
+        id: options.taskId,
+        isRunning: options.isRunning,
+        output,
+        startedAt: options.startedAt,
+        finishedAt: options.finishedAt,
+        exitCode: options.exitCode,
+        signal: null,
+    };
+
+    return {
+        session,
+        subscribe: createPolledTaskTerminalLogFileSubscribe({
+            session,
+            readOutput: () => readOptionalTextFile(runtimeLogPath),
+            resolveExitSnapshot: (knownOutput) => resolveDurableTaskExitSnapshot(options.taskId, session, knownOutput),
+        }),
+    };
+}
+
 /**
  * Resolves the terminal session of one ephemeral browser-preview stream.
  *
@@ -159,6 +220,60 @@ function createInMemoryTaskTerminalSession(options: {
     };
 }
 
+/**
+ * Builds the runtime log path created by the foreground local coding harness.
+ *
+ * @param options - Local runner folder and queued message filename.
+ * @returns Absolute path to the live harness runtime log file.
+ */
+function resolveLocalUserChatJobRuntimeLogPath(options: {
+    readonly agentDirectoryName: string;
+    readonly fileName: string;
+}): string {
+    return buildAgentMessageRuntimeLogPathFromFileName(
+        join(resolveLocalAgentRootPath(), options.agentDirectoryName),
+        options.fileName,
+    );
+}
+
+/**
+ * Resolves a durable chat-task exit snapshot while a file-backed terminal stream is open.
+ *
+ * @param taskId - Durable chat job identifier.
+ * @param session - Initial terminal session snapshot.
+ * @param knownOutput - Latest terminal output already sent to the browser.
+ * @returns Exit snapshot or `null` while the job is still active.
+ */
+async function resolveDurableTaskExitSnapshot(
+    taskId: string,
+    session: TaskTerminalLogSnapshot,
+    knownOutput: string,
+): Promise<TaskTerminalLogSnapshot | null> {
+    const latestJob = await getUserChatJobById(taskId);
+
+    if (!latestJob) {
+        return {
+            ...session,
+            isRunning: false,
+            output: knownOutput,
+            finishedAt: new Date().toISOString(),
+            exitCode: 1,
+        };
+    }
+
+    if (latestJob.status === 'QUEUED' || latestJob.status === 'RUNNING') {
+        return null;
+    }
+
+    return {
+        ...session,
+        isRunning: false,
+        output: knownOutput,
+        finishedAt: latestJob.completedAt || new Date().toISOString(),
+        exitCode: resolveFinishedTaskExitCode(latestJob.status) ?? 1,
+    };
+}
+
 /**
  * Maps one finished durable-task status to the synthetic terminal exit code.
  *
@@ -192,8 +307,8 @@ async function resolveVpsSelfUpdateTaskTerminalSession(taskId: string): Promise<
         return null;
     }
 
-    const latestJob = await readVpsSelfUpdateJobSnapshot();
-    const isLatestJob = resolveVpsSelfUpdateJobIdentity(latestJob) === jobIdentity;
+    const latestJob = jobSnapshots[0] ?? null;
+    const isLatestJob = latestJob !== null && resolveVpsSelfUpdateJobIdentity(latestJob) === jobIdentity;
     const output = isLatestJob
         ? (await readVpsSelfUpdateLogFileContent()) || ''
         : createArchivedVpsSelfUpdateLogPlaceholder(job);
@@ -211,10 +326,58 @@ async function resolveVpsSelfUpdateTaskTerminalSession(taskId: string): Promise<
 
     return {
         session,
-        subscribe: createVpsSelfUpdateLogFileSubscribe({ session, jobIdentity }),
+        subscribe: createPolledTaskTerminalLogFileSubscribe({
+            session,
+            readOutput: async () => {
+                const latestJobSnapshot = await readLatestVpsSelfUpdateTaskSnapshot();
+                if (!latestJobSnapshot) {
+                    return null;
+                }
+
+                const isStillLatestJob = resolveVpsSelfUpdateJobIdentity(latestJobSnapshot) === jobIdentity;
+
+                return isStillLatestJob ? (await readVpsSelfUpdateLogFileContent()) || '' : null;
+            },
+            resolveExitSnapshot: async (knownOutput) => {
+                const latestJobSnapshot = await readLatestVpsSelfUpdateTaskSnapshot();
+                if (!latestJobSnapshot) {
+                    return {
+                        ...session,
+                        isRunning: false,
+                        output: knownOutput,
+                        finishedAt: new Date().toISOString(),
+                        exitCode: 1,
+                    };
+                }
+
+                const isStillLatestJob = resolveVpsSelfUpdateJobIdentity(latestJobSnapshot) === jobIdentity;
+
+                if (isStillLatestJob && latestJobSnapshot.status === 'running') {
+                    return null;
+                }
+
+                return {
+                    ...session,
+                    isRunning: false,
+                    output: knownOutput,
+                    finishedAt: latestJobSnapshot.finishedAt || new Date().toISOString(),
+                    exitCode: resolveVpsSelfUpdateExitCode(latestJobSnapshot.status) ?? 1,
+                };
+            },
+        }),
     };
 }
 
+/**
+ * Reads the latest restart-aware standalone VPS self-update task snapshot.
+ *
+ * @returns Latest self-update task snapshot or `null` when no task snapshot is persisted.
+ */
+async function readLatestVpsSelfUpdateTaskSnapshot(): Promise<VpsSelfUpdateJobSnapshot | null> {
+    const jobSnapshots = await readVpsSelfUpdateJobTaskSnapshots();
+    return jobSnapshots[0] ?? null;
+}
+
 /**
  * Explains why an archived self-update run has no full installer log anymore.
  *
@@ -251,19 +414,17 @@ function resolveVpsSelfUpdateExitCode(status: VpsSelfUpdateJobSnapshot['status']
 }
 
 /**
- * Creates a subscribe function that live-tails the persisted self-update installer log file.
- *
- * The detached installer process cannot push events into this server process, so the log
- * file is polled and only newly appended text is forwarded to the subscriber.
+ * Creates a subscribe function that live-tails a task-owned terminal log file.
  *
- * @param options - Initial session snapshot and the identity of the streamed run.
+ * @param options - Initial session snapshot, file reader, and lifecycle resolver.
  * @returns Subscribe function compatible with the shared admin terminal SSE helper.
  */
-function createVpsSelfUpdateLogFileSubscribe(options: {
+function createPolledTaskTerminalLogFileSubscribe(options: {
     readonly session: TaskTerminalLogSnapshot;
-    readonly jobIdentity: string;
+    readonly readOutput: () => Promise<string | null>;
+    readonly resolveExitSnapshot: (knownOutput: string) => Promise<TaskTerminalLogSnapshot | null>;
 }): AdminTaskTerminalSubscribe {
-    return (taskId, subscriber) => {
+    return (_taskId, subscriber) => {
         let knownOutput = options.session.output;
         let isStopped = false;
         let isPollInFlight = false;
@@ -275,43 +436,43 @@ function createVpsSelfUpdateLogFileSubscribe(options: {
 
             isPollInFlight = true;
             try {
-                const [logFileContent, latestJob] = await Promise.all([
-                    readVpsSelfUpdateLogFileContent(),
-                    readVpsSelfUpdateJobSnapshot(),
-                ]);
-                const isStillLatestJob = resolveVpsSelfUpdateJobIdentity(latestJob) === options.jobIdentity;
-                const output = isStillLatestJob ? logFileContent || '' : knownOutput;
+                const output = await options.readOutput();
 
                 if (isStopped) {
                     return;
                 }
 
-                if (output.length > knownOutput.length && output.startsWith(knownOutput)) {
-                    subscriber.onOutput({
-                        type: 'output',
-                        chunk: output.slice(knownOutput.length),
-                    });
+                if (output !== null) {
+                    const outputChunk = resolveAppendedTaskTerminalLogFileChunk(knownOutput, output);
+
+                    if (outputChunk !== null) {
+                        subscriber.onOutput({
+                            type: 'output',
+                            chunk: outputChunk,
+                        });
+                    }
+
                     knownOutput = output;
                 }
 
-                if (!isStillLatestJob || latestJob.status !== 'running') {
-                    subscriber.onExit({
-                        type: 'exit',
-                        snapshot: {
-                            ...options.session,
-                            isRunning: false,
-                            output: knownOutput,
-                            finishedAt: latestJob.finishedAt || new Date().toISOString(),
-                            exitCode: resolveVpsSelfUpdateExitCode(latestJob.status) ?? 1,
-                        },
-                    });
+                const exitSnapshot = await options.resolveExitSnapshot(knownOutput);
+
+                if (isStopped || !exitSnapshot) {
+                    return;
                 }
+
+                isStopped = true;
+                clearInterval(pollInterval);
+                subscriber.onExit({
+                    type: 'exit',
+                    snapshot: exitSnapshot,
+                });
             } catch {
                 // Note: Ignore transient log-file read failures and retry on the next poll
             } finally {
                 isPollInFlight = false;
             }
-        }, VPS_SELF_UPDATE_TERMINAL_POLL_INTERVAL_MS);
+        }, TASK_TERMINAL_LOG_FILE_POLL_INTERVAL_MS);
         pollInterval.unref?.();
 
         return () => {
@@ -320,3 +481,55 @@ function createVpsSelfUpdateLogFileSubscribe(options: {
         };
     };
 }
+
+/**
+ * Resolves the output chunk appended since the last file poll.
+ *
+ * @param knownOutput - Output already sent to the browser.
+ * @param nextOutput - Latest complete log file content.
+ * @returns Appended chunk, full replacement content after truncation, or `null` when unchanged.
+ */
+function resolveAppendedTaskTerminalLogFileChunk(knownOutput: string, nextOutput: string): string | null {
+    if (nextOutput === knownOutput) {
+        return null;
+    }
+
+    if (nextOutput.startsWith(knownOutput)) {
+        return nextOutput.slice(knownOutput.length);
+    }
+
+    return nextOutput;
+}
+
+/**
+ * Reads one optional terminal log file.
+ *
+ * @param filePath - Absolute log file path.
+ * @returns File content or `null` when the log file does not exist yet.
+ */
+async function readOptionalTextFile(filePath: string): Promise<string | null> {
+    try {
+        return await readFile(filePath, 'utf-8');
+    } catch (error) {
+        if (isFileNotFoundError(error)) {
+            return null;
+        }
+
+        throw error;
+    }
+}
+
+/**
+ * Returns true when one filesystem error indicates a missing path.
+ *
+ * @param error - Unknown filesystem error.
+ * @returns Whether the error means the file path is absent.
+ */
+function isFileNotFoundError(error: unknown): boolean {
+    return Boolean(
+        error &&
+            typeof error === 'object' &&
+            'code' in error &&
+            ((error as { code?: string }).code === 'ENOENT' || (error as { code?: string }).code === 'ENOTDIR'),
+    );
+}

package/apps/agents-server/src/utils/thinkingMessages.ts

@@ -1,4 +1,8 @@
 import { DEFAULT_THINKING_MESSAGES } from '../../../../src/utils/DEFAULT_THINKING_MESSAGES';
+import {
+    normalizeThinkingMessageVariants,
+    parseThinkingMessageVariants,
+} from '../../../../src/book-components/Chat/utils/thinkingMessageVariants';
 import { getMetadata } from '../database/getMetadata';
 import { parseSlashSeparatedMetadata } from './metadataVariants';
 
@@ -11,8 +15,22 @@ export { DEFAULT_THINKING_MESSAGES };
  * @returns Trimmed, non-empty variants or the shared defaults.
  */
 export function parseThinkingMessages(raw: string | null | undefined): ReadonlyArray<string> {
-    const variants = parseSlashSeparatedMetadata(raw);
-    return variants.length > 0 ? variants : DEFAULT_THINKING_MESSAGES;
+    return normalizeThinkingMessageVariants(parseSlashSeparatedMetadata(raw));
+}
+
+/**
+ * Resolves agent-specific thinking messages with server metadata as fallback.
+ *
+ * @param agentThinkingMessages - Variants parsed from `META THINKING MESSAGE` commitments.
+ * @param serverThinkingMessages - Server-level metadata variants.
+ * @returns Agent variants when present, otherwise server variants/defaults.
+ */
+export function resolveThinkingMessages(
+    agentThinkingMessages: ReadonlyArray<string> | null | undefined,
+    serverThinkingMessages: ReadonlyArray<string>,
+): ReadonlyArray<string> {
+    const agentVariants = parseThinkingMessageVariants(agentThinkingMessages);
+    return agentVariants.length > 0 ? agentVariants : normalizeThinkingMessageVariants(serverThinkingMessages);
 }
 
 /**

package/apps/agents-server/src/utils/userChat/UserChatRecord.ts

@@ -42,6 +42,11 @@ export type UserChatSummary = {
     lastMessageAt: string | null;
     source: UserChatSource;
     isReadOnly: boolean;
+    /**
+     * True when the chat belongs to a different user than the current viewer
+     * (visible only to admins/super-admins browsing external chats).
+     */
+    isExternalUserChat: boolean;
     messagesCount: number;
     title: string;
     preview: string;
@@ -55,6 +60,11 @@ export type UserChatSummary = {
 export type ListUserChatsOptions = {
     userId: number;
     viewerIsAdmin: boolean;
+    /**
+     * True when the viewer is the environment-backed super-admin
+     * who may browse all users' chats on the server.
+     */
+    viewerIsSuperAdmin?: boolean;
     agentPermanentId: string;
     includeExternalChats?: boolean;
 };
@@ -65,6 +75,11 @@ export type ListUserChatsOptions = {
 export type GetUserChatOptions = {
     userId: number;
     viewerIsAdmin?: boolean;
+    /**
+     * True when the viewer is the environment-backed super-admin
+     * who may open other users' chats in a view-only mode.
+     */
+    viewerIsSuperAdmin?: boolean;
     agentPermanentId: string;
     chatId: string;
 };
@@ -77,6 +92,7 @@ export type CreateUserChatOptions = {
     agentPermanentId: string;
     source?: UserChatSource;
     chatId?: string;
+    title?: string | null;
     messages?: ReadonlyArray<ChatMessage>;
 };
 

package/apps/agents-server/src/utils/userChat/UserChatSource.ts

@@ -5,6 +5,7 @@ export const USER_CHAT_SOURCES = {
     WEB_UI: 'WEB_UI',
     OPENAI_API: 'OPENAI_API',
     TEAM_MEMBER: 'TEAM_MEMBER',
+    EMAIL: 'EMAIL',
 } as const;
 
 /**
@@ -31,6 +32,10 @@ export function getUserChatSourceChipLabel(source: UserChatSource): string | nul
         return 'TEAM';
     }
 
+    if (source === USER_CHAT_SOURCES.EMAIL) {
+        return 'EMAIL';
+    }
+
     return null;
 }
 
@@ -46,5 +51,9 @@ export function getUserChatSourceBannerLabel(source: UserChatSource): string | n
         return 'team member';
     }
 
+    if (source === USER_CHAT_SOURCES.EMAIL) {
+        return 'email';
+    }
+
     return null;
 }

package/apps/agents-server/src/utils/userChat/appendQueuedUserChatTurn.ts

@@ -1,8 +1,10 @@
 import type { ChatMessage } from '@promptbook-local/types';
+import type { ChatHistoryActorType, ChatHistorySource } from '../chat/createChatHistoryRecorder';
 import { $randomBase58 } from '../../../../../src/utils/random/$randomBase58';
 import { createUserChatJob } from './createUserChatJob';
 import { deleteUserChatJob } from './deleteUserChatJob';
 import { mutateUserChat } from './mutateUserChat';
+import { recordUserChatMessageInChatHistory } from './recordUserChatMessageInChatHistory';
 import type { UserChatJobRecord } from './UserChatJobRecord';
 import type { UserChatRecord } from './UserChatRecord';
 import { assertValidUserChatMessageReplies } from './userChatReplies';
@@ -30,6 +32,18 @@ export async function appendQueuedUserChatTurn(options: {
     attachments?: ChatMessage['attachments'];
     replyingTo?: ChatMessage['replyingTo'];
     parameters?: Record<string, unknown>;
+    /**
+     * Optional HTTP request used only for chat-history telemetry (ip, user-agent,...).
+     */
+    chatHistoryTelemetryRequest?: Request | null;
+    /**
+     * Source marker mirrored into the administrator chat-history audit.
+     */
+    chatHistorySource?: ChatHistorySource;
+    /**
+     * Actor marker mirrored into the administrator chat-history audit.
+     */
+    chatHistoryActorType?: ChatHistoryActorType;
 }): Promise<{
     chat: UserChatRecord;
     job: UserChatJobRecord;
@@ -85,6 +99,23 @@ export async function appendQueuedUserChatTurn(options: {
             },
         });
 
+        // Note: Recording is best-effort telemetry for `/admin/chat-history` and must never block the chat turn
+        void recordUserChatMessageInChatHistory({
+            agentPermanentId: options.agentPermanentId,
+            chatId: options.chatId,
+            taskId: jobId,
+            userId: options.userId,
+            message: {
+                role: 'USER',
+                sender: 'USER',
+                content: options.messageContent,
+                attachments: options.attachments,
+            },
+            request: options.chatHistoryTelemetryRequest,
+            source: options.chatHistorySource,
+            actorType: options.chatHistoryActorType,
+        });
+
         return { chat, job };
     } catch (error) {
         await deleteUserChatJob(jobId).catch((cleanupError) => {

package/apps/agents-server/src/utils/userChat/createUserChat.ts

@@ -50,7 +50,8 @@ export async function createUserChat(options: CreateUserChatOptions): Promise<Us
             createdAt: now,
             updatedAt: now,
             lastMessageAt: resolveLastMessageAt(messages, now),
-            source,
+            title: options.title,
+            source: source as unknown as UserChatInsert['source'],
             messages: messages as unknown as Json,
         };
 

package/apps/agents-server/src/utils/userChat/createUserChatDetailPayload.ts

@@ -8,10 +8,23 @@ import { getUserChat } from './getUserChat';
 import { listUserChatJobs } from './listUserChatJobs';
 import { reconcileUserChatActiveJobs } from './reconcileUserChatActiveJobs';
 
+/**
+ * Optional viewer context injected while building one chat detail payload.
+ */
+type CreateUserChatDetailPayloadOptions = {
+    /**
+     * Database user id of the current viewer, used to mark other users' chats as view-only.
+     */
+    viewerUserId?: number;
+};
+
 /**
  * Builds the API payload used for one canonical scoped chat detail.
  */
-export async function createUserChatDetailPayload(chat: UserChatRecord): Promise<{
+export async function createUserChatDetailPayload(
+    chat: UserChatRecord,
+    options: CreateUserChatDetailPayloadOptions = {},
+): Promise<{
     chat: ReturnType<typeof createUserChatSummary>;
     messages: UserChatRecord['messages'];
     draftMessage: string | null;
@@ -89,6 +102,7 @@ export async function createUserChatDetailPayload(chat: UserChatRecord): Promise
         chat: createUserChatSummary(currentChat, {
             timeoutActivity: createUserChatTimeoutActivity(activeTimeouts),
             activeJobCount: activeJobs.length,
+            viewerUserId: options.viewerUserId,
         }),
         messages: currentChat.messages,
         draftMessage: currentChat.draftMessage,

package/apps/agents-server/src/utils/userChat/createUserChatSummary.ts

@@ -50,6 +50,10 @@ const SUMMARY_RUNNING_ACTIVITY_MAX_AGE_MS = 6 * 60 * 1_000;
 type CreateUserChatSummaryOptions = {
     timeoutActivity?: UserChatTimeoutActivity;
     activeJobCount?: number;
+    /**
+     * Database user id of the current viewer, used to mark other users' chats as view-only.
+     */
+    viewerUserId?: number;
 };
 
 /**
@@ -64,6 +68,10 @@ export type UserChatSummarySeed = {
     lastMessageAt: string | null;
     title: string | null;
     source: UserChatRecord['source'];
+    /**
+     * Database user id owning the chat, used to mark other users' chats as view-only.
+     */
+    userId?: number;
     messagesCount: number;
     firstUserMessageContent: string;
     lastPreviewMessageContent: string;
@@ -89,6 +97,7 @@ export function createUserChatSummary(
             lastMessageAt: chat.lastMessageAt,
             title: chat.title,
             source: chat.source,
+            userId: chat.userId,
             messagesCount: chat.messages.length,
             firstUserMessageContent: firstUserMessage?.content || '',
             lastPreviewMessageContent: lastMessage?.content || '',
@@ -113,6 +122,8 @@ export function createUserChatSummaryFromSeed(
         options.activeJobCount && options.activeJobCount > 0
             ? options.activeJobCount
             : resolveSummaryPendingActivityCount(chat.updatedAt, chat.pendingAssistantMessageCount);
+    const isExternalUserChat =
+        options.viewerUserId !== undefined && chat.userId !== undefined && chat.userId !== options.viewerUserId;
 
     return {
         id: chat.id,
@@ -120,7 +131,8 @@ export function createUserChatSummaryFromSeed(
         updatedAt: chat.updatedAt,
         lastMessageAt: chat.lastMessageAt,
         source: chat.source,
-        isReadOnly: isFrozenUserChatSource(chat.source),
+        isReadOnly: isFrozenUserChatSource(chat.source) || isExternalUserChat,
+        isExternalUserChat,
         messagesCount: chat.messagesCount,
         title: shortenText(storedTitle || titleSource || DEFAULT_CHAT_TITLE, CHAT_TITLE_MAX_LENGTH),
         preview: shortenText(previewSource, CHAT_PREVIEW_MAX_LENGTH),

package/apps/agents-server/src/utils/userChat/expiredRunningUserChatJobDiagnostics.ts

@@ -39,6 +39,8 @@ export async function loadExpiredRunningUserChatJobRuntimeSnapshot(): Promise<Ex
             pageSize: EXPIRED_USER_CHAT_JOB_DIAGNOSTIC_TASK_LIMIT,
             view: 'active',
             search: '',
+            sortBy: 'default',
+            sortOrder: 'desc',
             timeWindowHours: EXPIRED_USER_CHAT_JOB_DIAGNOSTIC_TIME_WINDOW_HOURS,
         }),
     ]);

package/apps/agents-server/src/utils/userChat/getUserChat.ts

@@ -8,7 +8,7 @@ import { USER_CHAT_SOURCES } from './UserChatSource';
  * Loads one user chat by id.
  */
 export async function getUserChat(options: GetUserChatOptions): Promise<UserChatRecord | null> {
-    const { userId, viewerIsAdmin = false, agentPermanentId, chatId } = options;
+    const { userId, viewerIsAdmin = false, viewerIsSuperAdmin = false, agentPermanentId, chatId } = options;
     const userChatTable = await provideUserChatTable();
 
     const { data, error } = await userChatTable
@@ -28,8 +28,13 @@ export async function getUserChat(options: GetUserChatOptions): Promise<UserChat
     const chat = mapUserChatRow(data as UserChatRow);
 
     if (chat.source === USER_CHAT_SOURCES.WEB_UI) {
-        return chat.userId === userId ? chat : null;
+        if (chat.userId === userId) {
+            return chat;
+        }
+
+        // Note: Super-admins may open other users' chats in a view-only mode
+        return viewerIsSuperAdmin ? chat : null;
     }
 
-    return viewerIsAdmin ? chat : null;
+    return viewerIsAdmin || viewerIsSuperAdmin ? chat : null;
 }

package/apps/agents-server/src/utils/userChat/isUserChatViewOnly.ts

@@ -0,0 +1,16 @@
+import type { UserChatRecord } from './UserChatRecord';
+import { isFrozenUserChatSource } from './UserChatSource';
+
+/**
+ * Returns true when the chat must stay view-only for the given viewer.
+ *
+ * A chat is view-only when it was captured from an external channel (frozen source)
+ * or when it belongs to a different user (super-admins browsing all users' chats).
+ */
+export function isUserChatViewOnly(options: {
+    chat: Pick<UserChatRecord, 'source' | 'userId'>;
+    viewerUserId: number;
+}): boolean {
+    const { chat, viewerUserId } = options;
+    return isFrozenUserChatSource(chat.source) || chat.userId !== viewerUserId;
+}