@promptbook/cli 0.114.0-5 → 0.114.0-50

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

@@ -1,3 +1,4 @@
+import { spaceTrim } from 'spacetrim';
 import { $getTableName } from '@/src/database/$getTableName';
 import { $provideClientSql } from '@/src/database/$provideClientSql';
 import { isAgentsServerSqliteMode } from '@/src/database/agentsServerDatabaseMode';
@@ -97,19 +98,19 @@ export async function listUserChatSummarySeeds(options: ListUserChatsOptions): P
         shouldLoadAllUsersChats || (options.viewerIsAdmin && options.includeExternalChats);
 
     const whereClause = shouldLoadAllUsersChats
-        ? `
+        ? spaceTrim(`
             "agentPermanentId" = $1
-        `
+        `)
         : shouldLoadExternalChats
-        ? `
+        ? spaceTrim(`
             "agentPermanentId" = $1
             AND ("source" <> '${USER_CHAT_SOURCES.WEB_UI}' OR "userId" = $2)
-        `
-        : `
+        `)
+        : spaceTrim(`
             "userId" = $1
             AND "agentPermanentId" = $2
             AND "source" = '${USER_CHAT_SOURCES.WEB_UI}'
-        `;
+        `);
     const queryValues = shouldLoadAllUsersChats
         ? [options.agentPermanentId]
         : shouldLoadExternalChats
@@ -117,53 +118,55 @@ export async function listUserChatSummarySeeds(options: ListUserChatsOptions): P
         : [options.userId, options.agentPermanentId];
     try {
         const summaryRows = await sql.raw<Array<UserChatSummarySeedSqlRow>>(
-            `
-                SELECT
-                    "id",
-                    "createdAt",
-                    "updatedAt",
-                    "lastMessageAt",
-                    "title",
-                    "source",
-                    "userId",
-                    COALESCE(jsonb_array_length("messages"), 0) AS "messagesCount",
-                    COALESCE(
-                        (
-                            SELECT message."value"->>'content'
-                            FROM jsonb_array_elements("messages") WITH ORDINALITY AS message("value", "ordinality")
-                            WHERE UPPER(COALESCE(message."value"->>'sender', '')) = 'USER'
-                            ORDER BY message."ordinality" ASC
-                            LIMIT 1
-                        ),
-                        ''
-                    ) AS "firstUserMessageContent",
-                    COALESCE(
-                        (
-                            SELECT message."value"->>'content'
-                            FROM jsonb_array_elements("messages") WITH ORDINALITY AS message("value", "ordinality")
-                            WHERE LENGTH(BTRIM(COALESCE(message."value"->>'content', ''))) > 0
-                            ORDER BY message."ordinality" DESC
-                            LIMIT 1
-                        ),
-                        ''
-                    ) AS "lastPreviewMessageContent",
-                    COALESCE(
-                        (
-                            SELECT COUNT(*)::INT
-                            FROM jsonb_array_elements("messages") AS message("value")
-                            WHERE
-                                UPPER(COALESCE(message."value"->>'sender', '')) IN ('AGENT', 'MODEL')
-                                AND (
-                                    COALESCE(message."value"->>'isComplete', '') = 'false'
-                                    OR LOWER(COALESCE(message."value"->>'lifecycleState', '')) IN ('queued', 'running')
-                                )
-                        ),
-                        0
-                    ) AS "pendingAssistantMessageCount"
-                FROM ${userChatTableName}
-                WHERE ${whereClause}
-                ORDER BY "createdAt" DESC
-            `,
+            spaceTrim(
+                (block) => `
+                    SELECT
+                        "id",
+                        "createdAt",
+                        "updatedAt",
+                        "lastMessageAt",
+                        "title",
+                        "source",
+                        "userId",
+                        COALESCE(jsonb_array_length("messages"), 0) AS "messagesCount",
+                        COALESCE(
+                            (
+                                SELECT message."value"->>'content'
+                                FROM jsonb_array_elements("messages") WITH ORDINALITY AS message("value", "ordinality")
+                                WHERE UPPER(COALESCE(message."value"->>'sender', '')) = 'USER'
+                                ORDER BY message."ordinality" ASC
+                                LIMIT 1
+                            ),
+                            ''
+                        ) AS "firstUserMessageContent",
+                        COALESCE(
+                            (
+                                SELECT message."value"->>'content'
+                                FROM jsonb_array_elements("messages") WITH ORDINALITY AS message("value", "ordinality")
+                                WHERE LENGTH(BTRIM(COALESCE(message."value"->>'content', ''))) > 0
+                                ORDER BY message."ordinality" DESC
+                                LIMIT 1
+                            ),
+                            ''
+                        ) AS "lastPreviewMessageContent",
+                        COALESCE(
+                            (
+                                SELECT COUNT(*)::INT
+                                FROM jsonb_array_elements("messages") AS message("value")
+                                WHERE
+                                    UPPER(COALESCE(message."value"->>'sender', '')) IN ('AGENT', 'MODEL')
+                                    AND (
+                                        COALESCE(message."value"->>'isComplete', '') = 'false'
+                                        OR LOWER(COALESCE(message."value"->>'lifecycleState', '')) IN ('queued', 'running')
+                                    )
+                            ),
+                            0
+                        ) AS "pendingAssistantMessageCount"
+                    FROM ${userChatTableName}
+                    WHERE ${block(whereClause)}
+                    ORDER BY "createdAt" DESC
+                `,
+            ),
             queryValues,
         );
 
@@ -194,19 +197,19 @@ async function listUserChatSummarySeedsViaSqlite(options: ListUserChatsOptions):
     const shouldLoadExternalChats =
         shouldLoadAllUsersChats || (options.viewerIsAdmin && options.includeExternalChats);
     const whereClause = shouldLoadAllUsersChats
-        ? `
+        ? spaceTrim(`
             chat."agentPermanentId" = ?
-        `
+        `)
         : shouldLoadExternalChats
-        ? `
+        ? spaceTrim(`
             chat."agentPermanentId" = ?
             AND (chat."source" <> ? OR chat."userId" = ?)
-        `
-        : `
+        `)
+        : spaceTrim(`
             chat."userId" = ?
             AND chat."agentPermanentId" = ?
             AND chat."source" = ?
-        `;
+        `);
     const queryValues = shouldLoadAllUsersChats
         ? [options.agentPermanentId]
         : shouldLoadExternalChats
@@ -216,54 +219,56 @@ async function listUserChatSummarySeedsViaSqlite(options: ListUserChatsOptions):
     try {
         const summaryRows = database
             .prepare(
-                `
-                    SELECT
-                        chat."id",
-                        chat."createdAt",
-                        chat."updatedAt",
-                        chat."lastMessageAt",
-                        chat."title",
-                        chat."source",
-                        chat."userId",
-                        COALESCE(json_array_length(${SQLITE_CHAT_MESSAGES_JSON_EXPRESSION}), 0) AS "messagesCount",
-                        COALESCE(
-                            (
-                                SELECT CAST(json_extract(message.value, '$.content') AS TEXT)
-                                FROM json_each(${SQLITE_CHAT_MESSAGES_JSON_EXPRESSION}) AS message
-                                WHERE UPPER(CAST(COALESCE(json_extract(message.value, '$.sender'), '') AS TEXT)) = 'USER'
-                                ORDER BY CAST(message.key AS INTEGER) ASC
-                                LIMIT 1
-                            ),
-                            ''
-                        ) AS "firstUserMessageContent",
-                        COALESCE(
-                            (
-                                SELECT CAST(json_extract(message.value, '$.content') AS TEXT)
-                                FROM json_each(${SQLITE_CHAT_MESSAGES_JSON_EXPRESSION}) AS message
-                                WHERE LENGTH(TRIM(CAST(COALESCE(json_extract(message.value, '$.content'), '') AS TEXT))) > 0
-                                ORDER BY CAST(message.key AS INTEGER) DESC
-                                LIMIT 1
-                            ),
-                            ''
-                        ) AS "lastPreviewMessageContent",
-                        COALESCE(
-                            (
-                                SELECT COUNT(*)
-                                FROM json_each(${SQLITE_CHAT_MESSAGES_JSON_EXPRESSION}) AS message
-                                WHERE
-                                    UPPER(CAST(COALESCE(json_extract(message.value, '$.sender'), '') AS TEXT)) IN ('AGENT', 'MODEL')
-                                    AND (
-                                        json_extract(message.value, '$.isComplete') = 0
-                                        OR LOWER(CAST(COALESCE(json_extract(message.value, '$.isComplete'), '') AS TEXT)) = 'false'
-                                        OR LOWER(CAST(COALESCE(json_extract(message.value, '$.lifecycleState'), '') AS TEXT)) IN ('queued', 'running')
-                                    )
-                            ),
-                            0
-                        ) AS "pendingAssistantMessageCount"
-                    FROM ${userChatTableName} AS chat
-                    WHERE ${whereClause}
-                    ORDER BY chat."createdAt" DESC
-                `,
+                spaceTrim(
+                    (block) => `
+                        SELECT
+                            chat."id",
+                            chat."createdAt",
+                            chat."updatedAt",
+                            chat."lastMessageAt",
+                            chat."title",
+                            chat."source",
+                            chat."userId",
+                            COALESCE(json_array_length(${SQLITE_CHAT_MESSAGES_JSON_EXPRESSION}), 0) AS "messagesCount",
+                            COALESCE(
+                                (
+                                    SELECT CAST(json_extract(message.value, '$.content') AS TEXT)
+                                    FROM json_each(${SQLITE_CHAT_MESSAGES_JSON_EXPRESSION}) AS message
+                                    WHERE UPPER(CAST(COALESCE(json_extract(message.value, '$.sender'), '') AS TEXT)) = 'USER'
+                                    ORDER BY CAST(message.key AS INTEGER) ASC
+                                    LIMIT 1
+                                ),
+                                ''
+                            ) AS "firstUserMessageContent",
+                            COALESCE(
+                                (
+                                    SELECT CAST(json_extract(message.value, '$.content') AS TEXT)
+                                    FROM json_each(${SQLITE_CHAT_MESSAGES_JSON_EXPRESSION}) AS message
+                                    WHERE LENGTH(TRIM(CAST(COALESCE(json_extract(message.value, '$.content'), '') AS TEXT))) > 0
+                                    ORDER BY CAST(message.key AS INTEGER) DESC
+                                    LIMIT 1
+                                ),
+                                ''
+                            ) AS "lastPreviewMessageContent",
+                            COALESCE(
+                                (
+                                    SELECT COUNT(*)
+                                    FROM json_each(${SQLITE_CHAT_MESSAGES_JSON_EXPRESSION}) AS message
+                                    WHERE
+                                        UPPER(CAST(COALESCE(json_extract(message.value, '$.sender'), '') AS TEXT)) IN ('AGENT', 'MODEL')
+                                        AND (
+                                            json_extract(message.value, '$.isComplete') = 0
+                                            OR LOWER(CAST(COALESCE(json_extract(message.value, '$.isComplete'), '') AS TEXT)) = 'false'
+                                            OR LOWER(CAST(COALESCE(json_extract(message.value, '$.lifecycleState'), '') AS TEXT)) IN ('queued', 'running')
+                                        )
+                                ),
+                                0
+                            ) AS "pendingAssistantMessageCount"
+                        FROM ${userChatTableName} AS chat
+                        WHERE ${block(whereClause)}
+                        ORDER BY chat."createdAt" DESC
+                    `,
+                ),
             )
             .all(...queryValues) as Array<UserChatSummarySeedSqlRow>;
 
@@ -410,10 +415,8 @@ async function listUserChatSummarySeedsViaSupabase(options: ListUserChatsOptions
 
 /**
  * Maps one full chat record into a lightweight summary seed.
- *
- * @private function of `userChat`
  */
-function createUserChatSummarySeedFromChatRecord(chat: UserChatRecord): UserChatSummarySeed {
+export function createUserChatSummarySeedFromChatRecord(chat: UserChatRecord): UserChatSummarySeed {
     return {
         id: chat.id,
         createdAt: chat.createdAt,

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

@@ -3,6 +3,7 @@ import type { UserChatRecord } from './UserChatRecord';
 import { createUserChat } from './createUserChat';
 import { updateUserChatMessages } from './updateUserChatMessages';
 import { isFrozenUserChatSource, type UserChatSource } from './UserChatSource';
+import { isUserChatNotFoundScopeError } from './UserChatScopeError';
 
 /**
  * Input payload for persisting one frozen external chat snapshot.
@@ -24,12 +25,26 @@ export async function persistFrozenUserChat(options: PersistFrozenUserChatOption
     }
 
     if (options.chatId) {
-        return updateUserChatMessages({
-            userId: options.userId,
-            agentPermanentId: options.agentPermanentId,
-            chatId: options.chatId,
-            messages: options.messages,
-        });
+        try {
+            return await updateUserChatMessages({
+                userId: options.userId,
+                agentPermanentId: options.agentPermanentId,
+                chatId: options.chatId,
+                messages: options.messages,
+            });
+        } catch (error) {
+            if (!isUserChatNotFoundScopeError(error)) {
+                throw error;
+            }
+
+            return createUserChat({
+                userId: options.userId,
+                agentPermanentId: options.agentPermanentId,
+                source: options.source,
+                chatId: options.chatId,
+                messages: options.messages,
+            });
+        }
     }
 
     return createUserChat({

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

@@ -28,6 +28,10 @@ export async function persistUserChatJobTerminalState(options: {
     provider?: string | null;
     failureReason?: string | null;
     failureDetails?: string | null;
+    /**
+     * Actual time at which an out-of-process runner finished this assistant message.
+     */
+    executedAt?: NonNullable<ChatMessage['createdAt']>;
     generationDurationMs?: number;
 }): Promise<void> {
     let updatedChat: Awaited<ReturnType<typeof updateUserChatAssistantMessage>> | null = null;
@@ -47,6 +51,7 @@ export async function persistUserChatJobTerminalState(options: {
                 ongoingToolCalls: undefined,
                 toolCalls: options.toolCalls ?? message.toolCalls,
                 completedToolCalls: options.toolCalls ?? message.completedToolCalls,
+                createdAt: options.executedAt ?? message.createdAt,
                 generationDurationMs: options.generationDurationMs ?? message.generationDurationMs,
                 progressCard: undefined,
                 availableTools: options.availableTools ?? message.availableTools,

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

@@ -13,7 +13,7 @@ import { EnvironmentMismatchError } from '../../../../../src/errors/EnvironmentM
 let resolvedUserChatWorkerInternalToken: string | null = null;
 
 /**
- * Resolves the shared internal token used to protect background worker routes.
+ * Resolves the shared internal token used to protect managed-agent and background worker routes.
  *
  * In production, `PTBK_AGENTS_SERVER_USER_CHAT_WORKER_TOKEN` must be configured
  * explicitly — falling back to any shared credential (in particular
@@ -44,11 +44,12 @@ export function resolveUserChatWorkerInternalToken(): string {
             spaceTrim(`
                 Missing required \`PTBK_AGENTS_SERVER_USER_CHAT_WORKER_TOKEN\` environment variable in production.
 
-                The Agents Server protects its internal worker routes
+                The Agents Server protects its internal managed-agent and worker routes
                 (\`/api/internal/user-chat-jobs/run\`,
                 \`/api/internal/user-chat-timeouts/run\`,
-                \`/api/internal/agent-runner-limits\`, and
-                \`/api/internal/agent-project-runtimes\`) with this shared token.
+                \`/api/internal/agent-runner-limits\`,
+                \`/api/internal/agent-project-runtimes\`, and
+                \`/api/internal/agent-goal-chat-planned-messages\`) with this shared token.
                 Reusing \`ADMIN_PASSWORD\`, \`SUPABASE_SERVICE_ROLE_KEY\`, or a
                 hardcoded fallback would let anyone who learns that value drive
                 background jobs at will.

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

@@ -9,7 +9,7 @@ import type { ChatMessage, ChatPrompt } from '@promptbook-local/types';
 import type { string_book } from '../../../../../src/book-2.0/agent-source/string_book';
 import type { ChatPromptResult } from '../../../../../src/execution/PromptResult';
 import { createImmediateUserChatAnswerModelRequirements } from './createImmediateUserChatAnswerModelRequirements';
-import { getUserChat } from './getUserChat';
+import { getUserChatForJobRunner } from './getUserChatForJobRunner';
 import { getUserChatJobById } from './getUserChatJobById';
 import { mutateUserChat } from './mutateUserChat';
 import type { UserChatJobParameters, UserChatJobRecord } from './UserChatJobRecord';
@@ -109,11 +109,7 @@ async function resolveImmediateUserChatAnswerContext(
         return null;
     }
 
-    const chat = await getUserChat({
-        userId: job.userId,
-        agentPermanentId: job.agentPermanentId,
-        chatId: job.chatId,
-    });
+    const chat = await getUserChatForJobRunner(job);
 
     if (!chat) {
         return null;

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

@@ -17,7 +17,7 @@ import {
     DEFAULT_USER_CHAT_JOB_HEARTBEAT_MAX_CONSECUTIVE_FAILURES,
 } from './createUserChatJobHeartbeatController';
 import { finalizeUserChatJob } from './finalizeUserChatJob';
-import { getUserChat } from './getUserChat';
+import { getUserChatForJobRunner } from './getUserChatForJobRunner';
 import { heartbeatUserChatJob } from './heartbeatUserChatJob';
 import { persistUserChatJobTerminalState } from './persistUserChatJobTerminalState';
 import { persistUserChatJobProgressCard } from './persistUserChatJobProgressCard';
@@ -159,11 +159,7 @@ function createRunUserChatJobProgressReporter(
  */
 async function resolveRunUserChatJobStartContext(job: UserChatJobRecord): Promise<RunUserChatJobStartContext | null> {
     const [chat, userRow] = await Promise.all([
-        getUserChat({
-            userId: job.userId,
-            agentPermanentId: job.agentPermanentId,
-            chatId: job.chatId,
-        }),
+        getUserChatForJobRunner(job),
         getUserById(job.userId),
     ]);
 

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

@@ -0,0 +1,63 @@
+import type { ChatMessage } from '@promptbook-local/types';
+
+/**
+ * JSON property stored on the first message of a frozen TEAM conversation.
+ *
+ * A message-level property keeps the relation backwards-compatible without changing the UserChat table.
+ */
+const TEAM_MEMBER_USER_CHAT_CONTEXT_KEY = '__promptbookTeamMemberChat';
+
+/**
+ * Primary chat information attached to a frozen teammate conversation.
+ */
+export type TeamMemberUserChatContext = {
+    readonly version: 1;
+    readonly primaryAgentPermanentId: string;
+    readonly primaryAgentName: string;
+    readonly primaryChatId: string;
+};
+
+/**
+ * Adds the primary-chat relation to the first message of a frozen teammate transcript.
+ */
+export function attachTeamMemberUserChatContext(
+    messages: ReadonlyArray<ChatMessage>,
+    context: TeamMemberUserChatContext,
+): Array<ChatMessage> {
+    const firstMessage = messages[0];
+    if (!firstMessage) {
+        return [...messages];
+    }
+
+    return [
+        {
+            ...firstMessage,
+            [TEAM_MEMBER_USER_CHAT_CONTEXT_KEY]: context,
+        } as ChatMessage,
+        ...messages.slice(1),
+    ];
+}
+
+/**
+ * Reads the optional primary-chat relation from a frozen teammate transcript.
+ */
+export function getTeamMemberUserChatContext(messages: ReadonlyArray<ChatMessage>): TeamMemberUserChatContext | null {
+    const firstMessage = messages[0] as (ChatMessage & Record<string, unknown>) | undefined;
+    const value = firstMessage?.[TEAM_MEMBER_USER_CHAT_CONTEXT_KEY];
+
+    return isTeamMemberUserChatContext(value) ? value : null;
+}
+
+/**
+ * Validates the compact context stored in untrusted persisted message JSON.
+ */
+function isTeamMemberUserChatContext(value: unknown): value is TeamMemberUserChatContext {
+    return Boolean(
+        value &&
+            typeof value === 'object' &&
+            (value as TeamMemberUserChatContext).version === 1 &&
+            typeof (value as TeamMemberUserChatContext).primaryAgentPermanentId === 'string' &&
+            typeof (value as TeamMemberUserChatContext).primaryAgentName === 'string' &&
+            typeof (value as TeamMemberUserChatContext).primaryChatId === 'string',
+    );
+}

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

@@ -1,4 +1,5 @@
 import type { Json } from '@/src/database/schema';
+import type { ChatMessage } from '@promptbook-local/types';
 import {
     normalizeAgentMessageRunReport,
     type AgentMessageRunReport,
@@ -42,6 +43,35 @@ export function withUserChatJobRunReport(
     };
 }
 
+/**
+ * Resolves display-ready execution timing from one runner-produced message report.
+ *
+ * The runner's timestamps describe only active harness work, unlike durable job timestamps which also include time
+ * waiting for the out-of-process runner to pick up a queued message.
+ *
+ * @returns The completed message timestamp and actual execution duration, or `null` for older reports without timing.
+ */
+export function resolveUserChatJobExecutionTiming(report: AgentMessageRunReport | null): {
+    readonly executedAt: NonNullable<ChatMessage['createdAt']>;
+    readonly generationDurationMs: number;
+} | null {
+    const executionTiming = report?.executionTiming;
+    if (!executionTiming) {
+        return null;
+    }
+
+    const startedAtMilliseconds = Date.parse(executionTiming.startedAt);
+    const finishedAtMilliseconds = Date.parse(executionTiming.finishedAt);
+    if (!Number.isFinite(startedAtMilliseconds) || !Number.isFinite(finishedAtMilliseconds)) {
+        return null;
+    }
+
+    return {
+        executedAt: executionTiming.finishedAt as NonNullable<ChatMessage['createdAt']>,
+        generationDurationMs: Math.max(0, finishedAtMilliseconds - startedAtMilliseconds),
+    };
+}
+
 /**
  * Persists one runner-produced run report into the job parameters so task details can show it.
  */

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

@@ -20,13 +20,18 @@ export function createQueuedUserChatUserMessage(options: {
     messageId: string;
     clientMessageId: string;
     content: string;
+    /**
+     * Sender persisted for the input turn. Agent-owned goal-chat wake-ups use `AGENT` because
+     * no human authored them, while ordinary durable turns keep the default `USER` sender.
+     */
+    sender?: 'USER' | 'AGENT';
     attachments?: ChatMessage['attachments'];
     replyingTo?: ChatMessage['replyingTo'];
     createdAt: NonNullable<ChatMessage['createdAt']>;
 }): ChatMessage {
     return {
         id: options.messageId,
-        sender: 'USER',
+        sender: options.sender || 'USER',
         content: options.content,
         attachments: options.attachments,
         replyingTo: options.replyingTo,

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

@@ -16,7 +16,11 @@ export { getUserChatJobByClientMessageId } from './userChat/getUserChatJobByClie
 export { heartbeatUserChatJob } from './userChat/heartbeatUserChatJob';
 export { isUserChatViewOnly } from './userChat/isUserChatViewOnly';
 export { listExpiredRunningUserChatJobs } from './userChat/listExpiredRunningUserChatJobs';
-export { listUserChats, listUserChatSummarySeeds } from './userChat/listUserChats';
+export {
+    createUserChatSummarySeedFromChatRecord,
+    listUserChats,
+    listUserChatSummarySeeds,
+} from './userChat/listUserChats';
 export { listUserChatJobActivityCounts, listUserChatJobs } from './userChat/listUserChatJobs';
 export { mutateUserChat } from './userChat/mutateUserChat';
 export { persistUserChatJobTerminalState } from './userChat/persistUserChatJobTerminalState';

package/apps/agents-server/src/utils/userChatClient/cancelAgentUserTimeout.ts

@@ -4,7 +4,7 @@ import type { UserChatTimeout } from '../userChatClient';
 import { requestUserChatApi } from './requestUserChatApi';
 
 /**
- * Cancels one durable timeout in the agent-wide timeout manager.
+ * Cancels one planned message of the agent from its goal chat.
  *
  * @private shared helper for the Agents Server browser client
  */
@@ -14,6 +14,6 @@ export async function cancelAgentUserTimeout(agentName: string, timeoutId: strin
         {
             method: 'DELETE',
         },
-        'Failed to cancel agent timeout.',
+        'Failed to cancel the planned message.',
     );
 }

package/apps/agents-server/src/utils/userChatClient/fetchAgentUserTimeouts.ts

@@ -4,7 +4,7 @@ import type { AgentUserTimeoutListResponse } from '../userChatClient';
 import { requestUserChatApi } from './requestUserChatApi';
 
 /**
- * Loads all durable timeouts for one user+agent across chats.
+ * Loads every planned message of one agent, as listed in its goal chat.
  *
  * @private shared helper for the Agents Server browser client
  */
@@ -15,6 +15,6 @@ export async function fetchAgentUserTimeouts(agentName: string): Promise<AgentUs
             method: 'GET',
             cache: 'no-store',
         },
-        'Failed to load agent timeouts.',
+        'Failed to load planned messages.',
     );
 }