@promptbook/cli 0.114.0-12 → 0.114.0-14

package/apps/agents-server/src/app/agents/[agentName]/AgentChatWrapper.tsx

@@ -6,6 +6,7 @@ import { AgentChat, ChatMessage, useSendMessageToLlmChat } from '@promptbook-loc
 import { RemoteAgent } from '@promptbook-local/core';
 import { ClientVersionMismatchError } from '@promptbook-local/utils';
 import { useCallback, useEffect, useMemo, useState, type CSSProperties } from 'react';
+import { AGENT_PROJECT_TOOL_CALL_NAME } from '../../../../../../src/book-components/Chat/utils/agentProjectToolCall';
 import { string_agent_url } from '../../../../../../src/types/typeAliases';
 import type { AgentProjectItemInfo } from '../../../components/AgentProjects/AgentProjectReferencesList';
 import { useAgentProjectMarkdownReferences } from '../../../components/AgentProjects/useAgentProjectMarkdownReferences';
@@ -144,10 +145,6 @@ export function AgentChatWrapper(props: AgentChatWrapperProps) {
 
     const { value: agent } = usePromise(agentPromise, [agentPromise]);
     const teamAgentProfiles = useTeamAgentProfiles(agent?.capabilities);
-    const markdownInlineReferences = useAgentProjectMarkdownReferences({
-        agentPermanentId: agentName,
-        projects: projectReferences,
-    });
 
     // Error state management
     const [currentError, setCurrentError] = useState<FriendlyErrorMessage | null>(null);
@@ -157,6 +154,11 @@ export function AgentChatWrapper(props: AgentChatWrapperProps) {
     const [githubAppStatus, setGithubAppStatus] = useState<GithubAppStatusResponse | null>(null);
     const [calendarOAuthStatus, setCalendarOAuthStatus] = useState<CalendarOAuthStatusResponse | null>(null);
     const [renderedMessages, setRenderedMessages] = useState<ReadonlyArray<ChatMessage>>([]);
+    const markdownInlineReferences = useAgentProjectMarkdownReferences({
+        agentPermanentId: agentName,
+        projects: projectReferences,
+        messages: renderedMessages,
+    });
     const currentAgentPermanentId = useMemo(() => {
         return typeof (agent as { permanentId?: unknown } | undefined)?.permanentId === 'string'
             ? ((agent as { permanentId?: string }).permanentId as string)
@@ -454,6 +456,7 @@ export function AgentChatWrapper(props: AgentChatWrapperProps) {
                 project_delete_file: t('chat.toolTitle.projectFileDeleter'),
                 project_create_branch: t('chat.toolTitle.projectBranchCreator'),
                 project_create_pull_request: t('chat.toolTitle.projectPullRequestCreator'),
+                [AGENT_PROJECT_TOOL_CALL_NAME]: t('chat.toolTitle.agentProjectTouched'),
             }}
             feedbackMode={toChatComponentFeedbackMode(feedbackMode)}
             onFeedback={shouldEnableFeedback ? handleFeedback : undefined}

package/apps/agents-server/src/app/agents/[agentName]/chat/AgentGoalChatPlannedMessages.tsx

@@ -1,7 +1,8 @@
 'use client';
 
-import { Clock3Icon } from 'lucide-react';
+import { Clock3Icon, RepeatIcon } from 'lucide-react';
 import { useCallback, useEffect, useState } from 'react';
+import { formatTimeoutDurationHuman } from '../../../../../../../src/book-components/Chat/utils/timeoutToolCallPresentation';
 import { useServerLanguage } from '../../../../components/ServerLanguage/ServerLanguageProvider';
 import { cancelAgentUserTimeout, fetchAgentUserTimeouts, type UserChatTimeout } from '../../../../utils/userChatClient';
 import { formatChatTimeoutRemainingTime } from './formatChatTimeoutRemainingTime';
@@ -136,14 +137,28 @@ export function AgentGoalChatPlannedMessages({ agentName, currentTimestamp }: Ag
                                         {plannedMessage.message ||
                                             translateText('goalChat.plannedMessageDefaultLabel')}
                                     </div>
-                                    <div className="mt-1 inline-flex items-center gap-1.5 text-xs font-medium text-amber-700 dark:text-amber-300">
-                                        <Clock3Icon className="h-3.5 w-3.5" />
-                                        <span>
-                                            {formatChatTimeoutRemainingTime(plannedMessage.dueAt, currentTimestamp)}
-                                        </span>
-                                        <span className="text-slate-400 dark:text-slate-500">
-                                            {new Date(plannedMessage.dueAt).toLocaleString()}
+                                    <div className="mt-1 flex flex-wrap items-center gap-x-3 gap-y-1 text-xs font-medium text-amber-700 dark:text-amber-300">
+                                        <span className="inline-flex items-center gap-1.5">
+                                            <Clock3Icon className="h-3.5 w-3.5" />
+                                            <span>
+                                                {formatChatTimeoutRemainingTime(plannedMessage.dueAt, currentTimestamp)}
+                                            </span>
+                                            <span className="text-slate-400 dark:text-slate-500">
+                                                {new Date(plannedMessage.dueAt).toLocaleString()}
+                                            </span>
                                         </span>
+                                        {plannedMessage.recurrenceIntervalMs !== null && (
+                                            <span className="inline-flex items-center gap-1.5 text-slate-500 dark:text-slate-400">
+                                                <RepeatIcon className="h-3.5 w-3.5" />
+                                                <span>
+                                                    {translateText('goalChat.plannedMessageIntervalLabel', {
+                                                        interval: formatTimeoutDurationHuman(
+                                                            plannedMessage.recurrenceIntervalMs,
+                                                        ),
+                                                    })}
+                                                </span>
+                                            </span>
+                                        )}
                                     </div>
                                 </div>
                                 <button

package/apps/agents-server/src/app/agents/[agentName]/chat/CanonicalAgentChatSurface.tsx

@@ -4,6 +4,7 @@ import { Chat } from '@promptbook-local/components';
 import { useCallback, useMemo, type CSSProperties, type ReactNode } from 'react';
 import type { ChatParticipant } from '../../../../../../../src/book-components/Chat/types/ChatParticipant';
 import type { ChatSaveFormatHandlerOptions } from '../../../../../../../src/book-components/Chat/save/_common/ChatSaveFormatHandler';
+import { AGENT_PROJECT_TOOL_CALL_NAME } from '../../../../../../../src/book-components/Chat/utils/agentProjectToolCall';
 import type { AgentProjectItemInfo } from '../../../../components/AgentProjects/AgentProjectReferencesList';
 import { useAgentProjectMarkdownReferences } from '../../../../components/AgentProjects/useAgentProjectMarkdownReferences';
 import { useAgentBackground } from '../../../../components/AgentProfile/useAgentBackground';
@@ -143,6 +144,7 @@ export function CanonicalAgentChatSurface({
     const markdownInlineReferences = useAgentProjectMarkdownReferences({
         agentPermanentId: agentName,
         projects: projectReferences,
+        messages: state.renderedMessages,
     });
     const chatBackgroundStyle = useMemo(
         () =>
@@ -174,7 +176,10 @@ export function CanonicalAgentChatSurface({
         ],
     );
     const { language, t: translateText } = useServerLanguage();
-    const translations = useMemo(() => createCanonicalAgentChatTranslations(translateText), [translateText]);
+    const translations = useMemo(
+        () => createCanonicalAgentChatTranslations(translateText, isAgentGoalChat),
+        [isAgentGoalChat, translateText],
+    );
     const frozenChatBannerLabel = useMemo(() => {
         const sourceBannerLabel = readOnlySource ? getUserChatSourceBannerLabel(readOnlySource) : null;
         if (sourceBannerLabel) {
@@ -431,7 +436,10 @@ function renderCanonicalAgentChatLoadingSkeleton(): ReactNode {
  *
  * @private function of CanonicalAgentChatPanel
  */
-function createCanonicalAgentChatTranslations(translateText: TranslateText): CanonicalAgentChatTranslations {
+function createCanonicalAgentChatTranslations(
+    translateText: TranslateText,
+    isAgentGoalChat: boolean,
+): CanonicalAgentChatTranslations {
     return {
         chatUiTranslations: {
             inputPlaceholder: translateText('chat.inputPlaceholder'),
@@ -520,9 +528,12 @@ function createCanonicalAgentChatTranslations(translateText: TranslateText): Can
             project_delete_file: translateText('chat.toolTitle.projectFileDeleter'),
             project_create_branch: translateText('chat.toolTitle.projectBranchCreator'),
             project_create_pull_request: translateText('chat.toolTitle.projectPullRequestCreator'),
+            [AGENT_PROJECT_TOOL_CALL_NAME]: translateText('chat.toolTitle.agentProjectTouched'),
         },
         timingTranslations: {
-            answerDurationLabel: translateText('chat.answerDurationLabel'),
+            answerDurationLabel: translateText(
+                isAgentGoalChat ? 'goalChat.executionDurationLabel' : 'chat.answerDurationLabel',
+            ),
         },
         feedbackTranslations: {
             reportIssueButtonTitle: translateText('chat.feedback.reportIssueButtonTitle'),

package/apps/agents-server/src/app/agents/[agentName]/chat/page.tsx

@@ -4,8 +4,7 @@ import { ForbiddenPage } from '@/src/components/ForbiddenPage/ForbiddenPage';
 import type { AgentProjectItemInfo } from '@/src/components/AgentProjects/AgentProjectReferencesList';
 import { $provideServer } from '@/src/tools/$provideServer';
 import { resolveAgentAccess } from '@/src/utils/agentAccess';
-import { resolveAgentProjectsAccess } from '@/src/utils/agentProjects/agentProjectAccess';
-import { listAgentProjectChatReferences } from '@/src/utils/agentProjects/listAgentProjectChatReferences';
+import { resolveAgentChatProjectReferences } from '@/src/utils/agentProjects/resolveAgentChatProjectReferences';
 import { loadChatConfiguration } from '@/src/utils/chatConfiguration';
 import { ensureChatHistoryIdentity } from '@/src/utils/currentUserIdentity';
 import { getCurrentUser } from '@/src/utils/getCurrentUser';
@@ -71,23 +70,6 @@ function buildCanonicalAgentChatPath(
     return query ? `${pathname}?${query}` : pathname;
 }
 
-/**
- * Resolves compact project references available to the agent chat surface.
- *
- * @param agentPermanentId - Permanent id of the agent owning the projects.
- * @returns Display-only project references safe to send to the client.
- */
-async function resolveAgentChatProjectReferences(
-    agentPermanentId: string,
-): Promise<ReadonlyArray<AgentProjectItemInfo>> {
-    const projectAccess = await resolveAgentProjectsAccess(agentPermanentId);
-    if (!projectAccess.isProjectOverviewVisible) {
-        return [];
-    }
-
-    return await listAgentProjectChatReferences(agentPermanentId);
-}
-
 /**
  * Handles agent chat page.
  */
@@ -149,7 +131,7 @@ export default async function AgentChatPage({
     const providedServerPromise = $provideServer();
     const agentProjectReferencesPromise = isHeadless
         ? Promise.resolve<ReadonlyArray<AgentProjectItemInfo>>([])
-        : resolveAgentChatProjectReferences(canonicalAgentId);
+        : resolveAgentChatProjectReferences({ agentPermanentId: canonicalAgentId });
     const shareTargetPayloadPromise = shareTarget
         ? peekShareTargetPayload({
               shareTargetId: shareTarget,

package/apps/agents-server/src/app/agents/[agentName]/page.tsx

@@ -6,6 +6,7 @@ import { $provideServer } from '@/src/tools/$provideServer';
 import { resolveAgentProjectsAccess } from '@/src/utils/agentProjects/agentProjectAccess';
 import { buildAgentProjectsDashboardHref } from '@/src/utils/agentProjects/agentProjectHrefs';
 import { listAgentProjectChatReferences } from '@/src/utils/agentProjects/listAgentProjectChatReferences';
+import { resolveAgentChatProjectReferences } from '@/src/utils/agentProjects/resolveAgentChatProjectReferences';
 import { isPublicAgentVisibility } from '@/src/utils/agentVisibility';
 import { ensureChatHistoryIdentity } from '@/src/utils/currentUserIdentity';
 import { createAgentEmailAddress } from '@/src/utils/email/agentEmailAddress';
@@ -689,7 +690,7 @@ export default async function AgentPage(props: AgentPageProps) {
 
     const [pageData, projects] = await Promise.all([
         loadAgentPageData(route.canonicalAgentId, Boolean(access.currentUser)),
-        access.isProjectOverviewVisible ? listAgentProjectChatReferences(route.canonicalAgentId) : Promise.resolve([]),
+        resolveAgentChatProjectReferences({ agentPermanentId: route.canonicalAgentId, projectsAccess: access }),
     ]);
     return renderAgentProfilePage(createAgentPageViewModel(route, pageData, projects));
 }

package/apps/agents-server/src/app/agents/[agentName]/projectReferenceActions.ts

@@ -0,0 +1,61 @@
+'use server';
+
+import { resolveAgentProjectsAccess } from '@/src/utils/agentProjects/agentProjectAccess';
+import type { AgentProjectReferenceInfo } from '@/src/utils/agentProjects/AgentProjectReferenceInfo';
+import { listAgentProjectNames } from '@/src/utils/agentProjects/listAgentProjectNames';
+import { resolveAgentChatProjectReferences } from '@/src/utils/agentProjects/resolveAgentChatProjectReferences';
+
+/**
+ * Reloads the project references of one open chat when the agent's set of projects changed.
+ *
+ * A chat renders every mention of a project as a project chip built from these references, so a project
+ * created while the chat stays open must reach the browser without a page reload. Building the references
+ * walks every project folder, therefore the project names the chat already knows decide whether that work
+ * is done at all.
+ *
+ * @param agentPermanentId - Permanent id of the agent owning the projects.
+ * @param knownProjectNames - Project directory names the open chat already renders.
+ * @returns Fresh project references, or `null` when the agent owns exactly the known projects.
+ */
+export async function $refreshAgentProjectChatReferencesAction(
+    agentPermanentId: string,
+    knownProjectNames: ReadonlyArray<string>,
+): Promise<ReadonlyArray<AgentProjectReferenceInfo> | null> {
+    const projectsAccess = await resolveAgentProjectsAccess(agentPermanentId);
+
+    if (!projectsAccess.isProjectOverviewVisible) {
+        return [];
+    }
+
+    const projectNames = await listAgentProjectNames(agentPermanentId);
+
+    if (areAgentProjectNamesEqual(projectNames, knownProjectNames)) {
+        return null;
+    }
+
+    return await resolveAgentChatProjectReferences({ agentPermanentId, projectsAccess });
+}
+
+/**
+ * Compares two collections of project directory names ignoring their order and letter case.
+ *
+ * @param firstProjectNames - Project names listed on the server.
+ * @param secondProjectNames - Project names reported by the open chat.
+ * @returns Whether both collections describe the same projects.
+ */
+function areAgentProjectNamesEqual(
+    firstProjectNames: ReadonlyArray<string>,
+    secondProjectNames: ReadonlyArray<string>,
+): boolean {
+    if (firstProjectNames.length !== secondProjectNames.length) {
+        return false;
+    }
+
+    const normalizedSecondProjectNames = new Set(
+        secondProjectNames.map((secondProjectName) => secondProjectName.toLowerCase()),
+    );
+
+    return firstProjectNames.every((firstProjectName) =>
+        normalizedSecondProjectNames.has(firstProjectName.toLowerCase()),
+    );
+}

package/apps/agents-server/src/components/AgentProjects/resolveLatestCompletedAgentMessageKey.ts

@@ -0,0 +1,32 @@
+import type { ChatMessage } from '@promptbook-local/types';
+
+/**
+ * Resolves a key identifying the newest finished agent answer in one chat.
+ *
+ * A finished agent turn is the only moment when the agent can have created a project, so this key is the
+ * signal telling the chat to reload its project references. Messages which are still being generated are
+ * ignored on purpose — their content keeps changing while the progress card updates, which says nothing
+ * about the projects on the server.
+ *
+ * @param messages - Messages currently rendered in the chat.
+ * @returns Key of the newest finished agent message, or `null` when the agent has answered nothing yet.
+ */
+export function resolveLatestCompletedAgentMessageKey(messages: ReadonlyArray<ChatMessage> | undefined): string | null {
+    if (!messages) {
+        return null;
+    }
+
+    for (let messageIndex = messages.length - 1; messageIndex >= 0; messageIndex--) {
+        const message = messages[messageIndex];
+
+        if (message === undefined || message.sender === 'USER' || message.isComplete === false) {
+            continue;
+        }
+
+        // Note: Messages of chats which do not persist ids are identified by their position, which still
+        //       moves forward with every new answer
+        return message.id === undefined ? `#${messageIndex}` : String(message.id);
+    }
+
+    return null;
+}

package/apps/agents-server/src/components/AgentProjects/useAgentProjectMarkdownReferences.ts

@@ -1,7 +1,8 @@
 'use client';
 
-import type { MarkdownInlineReference } from '@promptbook-local/types';
+import type { ChatMessage, MarkdownInlineReference } from '@promptbook-local/types';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { $refreshAgentProjectChatReferencesAction } from '../../app/agents/[agentName]/projectReferenceActions';
 import {
     $startAgentProjectRuntimeAction,
     $stopAgentProjectRuntimeAction,
@@ -13,6 +14,7 @@ import {
     type AgentProjectMarkdownReferenceInfo,
 } from '../../utils/agentProjects/createAgentProjectMarkdownReferences';
 import { notifyError } from '../Notifications/notifications';
+import { resolveLatestCompletedAgentMessageKey } from './resolveLatestCompletedAgentMessageKey';
 
 /**
  * Options used to build interactive project references for an Agents Server chat.
@@ -27,6 +29,14 @@ type UseAgentProjectMarkdownReferencesOptions = {
      * Initial browser-safe project references loaded by the server page.
      */
     readonly projects: ReadonlyArray<AgentProjectReferenceInfo>;
+
+    /**
+     * Messages currently rendered in the chat.
+     *
+     * They are watched only to notice that the agent finished an answer, which is when a project it just
+     * created must become a chip without waiting for a page reload.
+     */
+    readonly messages?: ReadonlyArray<ChatMessage>;
 };
 
 /**
@@ -38,7 +48,7 @@ type UseAgentProjectMarkdownReferencesOptions = {
 export function useAgentProjectMarkdownReferences(
     options: UseAgentProjectMarkdownReferencesOptions,
 ): ReadonlyArray<MarkdownInlineReference> {
-    const { agentPermanentId, projects } = options;
+    const { agentPermanentId, projects, messages } = options;
     const [currentProjects, setCurrentProjects] = useState<ReadonlyArray<AgentProjectReferenceInfo>>(projects);
     const previousProjectsRef = useRef(projects);
 
@@ -51,6 +61,13 @@ export function useAgentProjectMarkdownReferences(
         setCurrentProjects(projects);
     }, [projects]);
 
+    useRefreshedAgentProjectReferences({
+        agentPermanentId,
+        currentProjects,
+        messages,
+        setCurrentProjects,
+    });
+
     /**
      * Merges one action result into the local project reference state.
      */
@@ -143,6 +160,111 @@ export function useAgentProjectMarkdownReferences(
     );
 }
 
+/**
+ * Options of the refresh keeping chat project references current while the chat stays open.
+ *
+ * @private type of `useAgentProjectMarkdownReferences`
+ */
+type UseRefreshedAgentProjectReferencesOptions = {
+    /**
+     * Permanent id of the agent owning the projects.
+     */
+    readonly agentPermanentId: string;
+
+    /**
+     * Project references the chat currently renders.
+     */
+    readonly currentProjects: ReadonlyArray<AgentProjectReferenceInfo>;
+
+    /**
+     * Messages currently rendered in the chat.
+     */
+    readonly messages: ReadonlyArray<ChatMessage> | undefined;
+
+    /**
+     * Replaces the project references the chat renders.
+     */
+    readonly setCurrentProjects: (projects: ReadonlyArray<AgentProjectReferenceInfo>) => void;
+};
+
+/**
+ * Reloads the project references after each finished agent answer which could have created a project.
+ *
+ * The server renders a chat with the projects existing at that moment, so an agent creating a project
+ * during the conversation would otherwise reference it as a plain link until the page is reloaded. The
+ * messages already present when the chat thread opens arrive together with their projects and never
+ * trigger a reload, and the server skips rebuilding the references while the agent owns the very same
+ * projects.
+ *
+ * @param options - Owning agent, current references, and the messages the chat renders.
+ *
+ * @private function of `useAgentProjectMarkdownReferences`
+ */
+function useRefreshedAgentProjectReferences({
+    agentPermanentId,
+    currentProjects,
+    messages,
+    setCurrentProjects,
+}: UseRefreshedAgentProjectReferencesOptions): void {
+    const currentProjectsRef = useRef(currentProjects);
+    const isLatestCompletedAgentMessageKeyKnownRef = useRef(false);
+    const refreshedAgentMessageKeyRef = useRef<string | null>(null);
+    const hasRenderedChatMessages = messages !== undefined && messages.length > 0;
+    const latestCompletedAgentMessageKey = resolveLatestCompletedAgentMessageKey(messages);
+
+    useEffect(() => {
+        currentProjectsRef.current = currentProjects;
+    }, [currentProjects]);
+
+    useEffect(() => {
+        if (!hasRenderedChatMessages) {
+            // Note: An empty thread is also the state of a chat whose history is still being loaded
+            return undefined;
+        }
+
+        if (!isLatestCompletedAgentMessageKeyKnownRef.current) {
+            // Note: The messages rendered when the chat opens were listed together with the server projects
+            isLatestCompletedAgentMessageKeyKnownRef.current = true;
+            refreshedAgentMessageKeyRef.current = latestCompletedAgentMessageKey;
+            return undefined;
+        }
+
+        if (refreshedAgentMessageKeyRef.current === latestCompletedAgentMessageKey) {
+            return undefined;
+        }
+
+        refreshedAgentMessageKeyRef.current = latestCompletedAgentMessageKey;
+        let isDisposed = false;
+
+        void (async () => {
+            const knownProjectNames = currentProjectsRef.current.map((project) => project.projectName);
+
+            try {
+                const refreshedProjects = await $refreshAgentProjectChatReferencesAction(
+                    agentPermanentId,
+                    knownProjectNames,
+                );
+
+                if (isDisposed || refreshedProjects === null) {
+                    return;
+                }
+
+                setCurrentProjects(refreshedProjects);
+            } catch (error) {
+                // Note: A chat stays usable without fresh projects, the chip then appears after the next answer
+                console.error('[agents-server:agent-projects] Failed to refresh chat project references', {
+                    agentPermanentId,
+                    error,
+                });
+            }
+        })();
+
+        return () => {
+            isDisposed = true;
+        };
+    }, [agentPermanentId, hasRenderedChatMessages, latestCompletedAgentMessageKey, setCurrentProjects]);
+}
+
 /**
  * Selects a useful server-action error message without assuming a particular serialized error type.
  *

package/apps/agents-server/src/languages/ServerTranslationKeys.ts

@@ -17,10 +17,12 @@ export const SERVER_TRANSLATION_KEYS = [
     'common.goalChat',
     'goalChat.noticeTitle',
     'goalChat.noticeDescription',
+    'goalChat.executionDurationLabel',
     'goalChat.plannedMessagesTitle',
     'goalChat.plannedMessagesEmptyLabel',
     'goalChat.plannedMessagesLoadErrorLabel',
     'goalChat.plannedMessageDefaultLabel',
+    'goalChat.plannedMessageIntervalLabel',
     'goalChat.plannedMessageCancelLabel',
     'goalChat.plannedMessageCancellingLabel',
     'common.projects',
@@ -586,6 +588,7 @@ export const SERVER_TRANSLATION_KEYS = [
     'chat.toolTitle.projectFileDeleter',
     'chat.toolTitle.projectBranchCreator',
     'chat.toolTitle.projectPullRequestCreator',
+    'chat.toolTitle.agentProjectTouched',
     'chatTimeout.defaultLabel',
     'chatTimeout.singleActiveLabel',
     'chatTimeout.multipleActiveLabel',

package/apps/agents-server/src/languages/translations/czech.yaml

@@ -11,10 +11,12 @@ common.book: Book
 common.goalChat: Cíl
 goalChat.noticeTitle: Toto je cílový chat agenta
 goalChat.noticeDescription: Agent si sem píše sám a plánuje práci ke svému cíli, proto je toto vlákno pro lidi jen ke čtení.
+goalChat.executionDurationLabel: 'běželo {duration}'
 goalChat.plannedMessagesTitle: Naplánované zprávy
 goalChat.plannedMessagesEmptyLabel: Žádné naplánované zprávy. Agent se probudí při nové zprávě nebo aktualizaci knihy.
 goalChat.plannedMessagesLoadErrorLabel: Naplánované zprávy se nepodařilo načíst.
 goalChat.plannedMessageDefaultLabel: Naplánované probuzení
+goalChat.plannedMessageIntervalLabel: 'Opakování: {interval}'
 goalChat.plannedMessageCancelLabel: Zrušit
 goalChat.plannedMessageCancellingLabel: Ruším
 common.projects: Projekty
@@ -580,6 +582,7 @@ chat.toolTitle.projectFileWriter: Zápis souboru projektu
 chat.toolTitle.projectFileDeleter: Mazání souboru projektu
 chat.toolTitle.projectBranchCreator: Vytvoření větve projektu
 chat.toolTitle.projectPullRequestCreator: Vytvoření pull requestu
+chat.toolTitle.agentProjectTouched: Projekt
 chatTimeout.defaultLabel: Naplánovaný časovač
 chatTimeout.singleActiveLabel: 1 aktivní časovač
 chatTimeout.multipleActiveLabel: '{count} aktivní časovače'

package/apps/agents-server/src/languages/translations/english.yaml

@@ -11,10 +11,12 @@ common.book: Book
 common.goalChat: Goal
 goalChat.noticeTitle: This is the agent's goal chat
 goalChat.noticeDescription: The agent writes here on its own to plan work towards its goal, so this thread is read-only for people.
+goalChat.executionDurationLabel: 'executed for {duration}'
 goalChat.plannedMessagesTitle: Planned messages
 goalChat.plannedMessagesEmptyLabel: No planned messages. The agent will wake up when invoked by a new message or book update.
 goalChat.plannedMessagesLoadErrorLabel: Failed to load planned messages.
 goalChat.plannedMessageDefaultLabel: Planned wake-up
+goalChat.plannedMessageIntervalLabel: Repeats every {interval}
 goalChat.plannedMessageCancelLabel: Cancel
 goalChat.plannedMessageCancellingLabel: Cancelling
 common.projects: Projects
@@ -584,6 +586,7 @@ chat.toolTitle.projectFileWriter: Writing project file
 chat.toolTitle.projectFileDeleter: Deleting project file
 chat.toolTitle.projectBranchCreator: Creating project branch
 chat.toolTitle.projectPullRequestCreator: Creating pull request
+chat.toolTitle.agentProjectTouched: Project
 chatTimeout.defaultLabel: Scheduled timeout
 chatTimeout.singleActiveLabel: 1 active timeout
 chatTimeout.multipleActiveLabel: '{count} active timeouts'

package/apps/agents-server/src/tools/agentGoalChatTimeoutToolFunctions.ts

@@ -1,4 +1,5 @@
 import { spaceTrim } from 'spacetrim';
+import { formatTimeoutDurationHuman } from '../../../../src/book-components/Chat/utils/timeoutToolCallPresentation';
 import type { string_javascript_name } from '../../../../src/types/string_person_fullname';
 import type { ToolFunction } from '../../../../src/scripting/javascript/JavascriptExecutionToolsOptions';
 import { createToolExecutionEnvelope } from '../../../../src/commitments/_common/toolExecutionEnvelope';
@@ -45,7 +46,9 @@ export function createAgentGoalChatTimeoutToolFunctions(
                 });
 
                 return createToolExecutionEnvelope({
-                    assistantMessage: `Planned message ${JSON.stringify(result.timeoutId)} for ${result.dueAt}.`,
+                    assistantMessage: `Planned message ${JSON.stringify(
+                        result.timeoutId,
+                    )} ${createPlannedMessageScheduleLabel(result)}.`,
                     toolResult: result,
                 });
             } catch (error) {
@@ -147,7 +150,9 @@ function createPlannedMessagesAssistantSummary(
     const visiblePlannedMessages = plannedMessages.slice(0, MAX_ASSISTANT_VISIBLE_PLANNED_MESSAGES);
     const summaryRows = visiblePlannedMessages.map((plannedMessage, index) => {
         const message = plannedMessage.message?.trim() || 'Wake up and continue working towards the current goal.';
-        return `${index + 1}. ${plannedMessage.timeoutId} at ${plannedMessage.dueAt}: ${message}`;
+        return `${index + 1}. ${plannedMessage.timeoutId} ${createPlannedMessageScheduleLabel(
+            plannedMessage,
+        )}: ${message}`;
     });
     const hiddenPlannedMessageCount = plannedMessages.length - visiblePlannedMessages.length;
 
@@ -164,6 +169,23 @@ function createPlannedMessagesAssistantSummary(
     );
 }
 
+/**
+ * Describes when one planned message wakes the agent.
+ *
+ * @param plannedMessage - Planned message with its repeat interval and nearest execution time.
+ * @returns Schedule fragment such as `repeating every 5 minutes (next at ...)`.
+ */
+function createPlannedMessageScheduleLabel(plannedMessage: {
+    readonly dueAt: string;
+    readonly intervalMs: number | null;
+}): string {
+    if (!plannedMessage.intervalMs) {
+        return `at ${plannedMessage.dueAt}`;
+    }
+
+    return `repeating every ${formatTimeoutDurationHuman(plannedMessage.intervalMs)} (next at ${plannedMessage.dueAt})`;
+}
+
 /**
  * Serializes one caught tool failure without crashing the surrounding model run.
  *

package/apps/agents-server/src/tools/agentGoalChatTimeoutTools.ts

@@ -27,13 +27,14 @@ export function createAgentGoalChatTimeoutTools(
         tools.push({
             name: AGENT_GOAL_CHAT_TIMEOUT_TOOL_NAMES.set,
             description:
-                'Plan a message that will wake you in your singleton goal chat after a delay. Use this for useful autonomous follow-up towards your current goal; the wake-up is not tied to the human conversation where you schedule it.',
+                'Plan a message that repeatedly wakes you in your singleton goal chat, like `setInterval`. Use this for useful autonomous follow-up towards your current goal; the wake-up is not tied to the human conversation where you schedule it, and it keeps repeating until you cancel it. Do not plan a message that matches one you already planned.',
             parameters: {
                 type: 'object',
                 properties: {
                     milliseconds: {
                         type: 'number',
-                        description: 'Positive delay in milliseconds before the planned message wakes you.',
+                        description:
+                            'Repeat interval in milliseconds between two wake-ups by this planned message (at least 60000).',
                     },
                     message: {
                         type: 'string',
@@ -51,7 +52,7 @@ export function createAgentGoalChatTimeoutTools(
         tools.push({
             name: AGENT_GOAL_CHAT_TIMEOUT_TOOL_NAMES.list,
             description:
-                'List your planned goal-chat messages, including their identifiers and execution times, across every conversation in which you were invoked.',
+                'List your planned goal-chat messages, including their identifiers, repeat intervals, and next execution times, across every conversation in which you were invoked. Keep the listed messages as they are unless they no longer match your goal.',
             parameters: {
                 type: 'object',
                 properties: {
@@ -73,7 +74,7 @@ export function createAgentGoalChatTimeoutTools(
         tools.push({
             name: AGENT_GOAL_CHAT_TIMEOUT_TOOL_NAMES.cancel,
             description:
-                'Cancel one planned goal-chat message by its timeout identifier. List planned messages first when the identifier is not known.',
+                'Stop one repeating planned goal-chat message by its timeout identifier. List planned messages first when the identifier is not known.',
             parameters: {
                 type: 'object',
                 properties: {