@promptbook/cli 0.114.0-13 → 0.114.0-18

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

@@ -1,6 +1,10 @@
 'use client';
 
+import Link from 'next/link';
+import { CORE_AGENTS_ADMIN_HREF } from '../../../../components/DefaultAgents/coreAgentsAdminRoute';
+import { ReinstateBundledAgentsButton } from '../../../../components/DefaultAgents/ReinstateBundledAgentsButton';
 import type { MissingAgentReference } from '../../../../utils/agentReferenceResolver/createUnresolvedAgentReferenceDiagnostics';
+import type { MissingCoreAgentRecovery } from '../../../../utils/agentReferenceResolver/MissingCoreAgentRecovery';
 
 /**
  * Props for `BookEditorMissingReferences`.
@@ -20,6 +24,10 @@ type BookEditorMissingReferencesProps = {
      * Handles creating one referenced agent.
      */
     readonly onCreateReferencedAgent: (reference: MissingAgentReference) => void;
+    /**
+     * Handles refreshing the panel once the missing core agents were reinstated.
+     */
+    readonly onCoreAgentsReinstated: () => void;
     /**
      * Additional classes applied to the root panel.
      */
@@ -35,6 +43,7 @@ export function BookEditorMissingReferences({
     missingAgentReferences,
     creatingReference,
     onCreateReferencedAgent,
+    onCoreAgentsReinstated,
     className,
 }: BookEditorMissingReferencesProps) {
     if (missingAgentReferences.length === 0) {
@@ -53,6 +62,7 @@ export function BookEditorMissingReferences({
                         member={reference}
                         isCreating={creatingReference === reference.reference}
                         onCreate={() => onCreateReferencedAgent(reference)}
+                        onCoreAgentsReinstated={onCoreAgentsReinstated}
                     />
                 ))}
             </div>
@@ -76,12 +86,24 @@ type MissingAgentReferenceCardProps = {
      * Invoked when the user wants to create the referenced agent.
      */
     readonly onCreate: () => void;
+    /**
+     * Invoked once the missing core agents were reinstated.
+     */
+    readonly onCoreAgentsReinstated: () => void;
 };
 
 /**
- * Renders one unresolved-agent card with a create action.
+ * Renders one unresolved-agent card with the action that can bring the agent back.
+ *
+ * An ordinary agent is created from scratch, while a bundled core agent is reinstated from its repository book, so
+ * the card offers whichever of the two actually applies.
  */
-function MissingAgentReferenceCard({ member, isCreating, onCreate }: MissingAgentReferenceCardProps) {
+function MissingAgentReferenceCard({
+    member,
+    isCreating,
+    onCreate,
+    onCoreAgentsReinstated,
+}: MissingAgentReferenceCardProps) {
     const displayToken = member.token || member.reference;
     const commitmentLabel = formatCommitmentLabel(member.commitmentType);
 
@@ -89,23 +111,95 @@ function MissingAgentReferenceCard({ member, isCreating, onCreate }: MissingAgen
         <div className="rounded-xl border border-slate-200 bg-slate-50/80 p-4 dark:border-slate-700 dark:bg-slate-900/88">
             <p className="text-sm text-slate-700 dark:text-slate-300">
                 Referenced agent <span className="font-semibold text-slate-900 dark:text-slate-100">{displayToken}</span>{' '}
-                is not found. Do you want to create it?
+                is not found.
+                {!member.coreAgentRecovery && ' Do you want to create it?'}
             </p>
             <p className="mt-1 text-xs uppercase tracking-wide text-slate-500 dark:text-slate-400">
-                Missing in the {commitmentLabel} commitment
+                {member.isImplicit
+                    ? `Implicitly inherited through ${commitmentLabel}`
+                    : `Missing in the ${commitmentLabel} commitment`}
             </p>
-            <button
-                type="button"
-                className="mt-3 inline-flex w-full items-center justify-center rounded-md bg-blue-600 px-3 py-2 text-sm font-semibold text-white transition hover:bg-blue-500 focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-blue-600 disabled:cursor-not-allowed disabled:bg-slate-300 disabled:text-slate-100 disabled:opacity-70 dark:disabled:bg-slate-700 dark:disabled:text-slate-300"
-                onClick={onCreate}
-                disabled={isCreating}
-            >
-                {isCreating ? `Creating ${displayToken}...` : `Create ${displayToken}`}
-            </button>
+            {member.coreAgentRecovery ? (
+                <MissingCoreAgentRecoveryActions
+                    displayToken={displayToken}
+                    coreAgentRecovery={member.coreAgentRecovery}
+                    onCoreAgentsReinstated={onCoreAgentsReinstated}
+                />
+            ) : (
+                <button
+                    type="button"
+                    className="mt-3 inline-flex w-full items-center justify-center rounded-md bg-blue-600 px-3 py-2 text-sm font-semibold text-white transition hover:bg-blue-500 focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-blue-600 disabled:cursor-not-allowed disabled:bg-slate-300 disabled:text-slate-100 disabled:opacity-70 dark:disabled:bg-slate-700 dark:disabled:text-slate-300"
+                    onClick={onCreate}
+                    disabled={isCreating}
+                >
+                    {isCreating ? `Creating ${displayToken}...` : `Create ${displayToken}`}
+                </button>
+            )}
         </div>
     );
 }
 
+/**
+ * Props for the core-agent recovery block of one missing-reference card.
+ */
+type MissingCoreAgentRecoveryActionsProps = {
+    /**
+     * Token of the missing core agent as shown in the card headline.
+     */
+    readonly displayToken: string;
+    /**
+     * Reinstatement offered for the missing core agents.
+     */
+    readonly coreAgentRecovery: MissingCoreAgentRecovery;
+    /**
+     * Invoked once the missing core agents were reinstated.
+     */
+    readonly onCoreAgentsReinstated: () => void;
+};
+
+/**
+ * Renders the reinstate action and the Core Agents page link for a missing bundled core agent.
+ *
+ * Reinstating always restores every missing core agent at once, so the block also names the other ones that are gone.
+ */
+function MissingCoreAgentRecoveryActions({
+    displayToken,
+    coreAgentRecovery,
+    onCoreAgentsReinstated,
+}: MissingCoreAgentRecoveryActionsProps) {
+    const { missingCoreAgentTitles, isReinstateAllowed } = coreAgentRecovery;
+
+    return (
+        <>
+            <p className="mt-2 text-sm text-slate-700 dark:text-slate-300">
+                {displayToken} is a core agent bundled with this server, so it is reinstated from its repository book
+                instead of being created from scratch.
+            </p>
+            {missingCoreAgentTitles.length > 1 && (
+                <p className="mt-1 text-sm text-slate-600 dark:text-slate-400">
+                    Missing core agents: {missingCoreAgentTitles.join(', ')}. Reinstating brings back all of them.
+                </p>
+            )}
+            {isReinstateAllowed && (
+                <ReinstateBundledAgentsButton
+                    scope="core"
+                    label="Reinstate core agents"
+                    pendingLabel="Reinstating…"
+                    confirmMessage="Recreate the missing core agents from the bundled repository books?"
+                    className="mt-3 inline-flex w-full items-center justify-center rounded-md bg-amber-600 px-3 py-2 text-sm font-semibold text-white transition hover:bg-amber-500 focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-amber-600 disabled:cursor-not-allowed disabled:opacity-60"
+                    onReinstated={onCoreAgentsReinstated}
+                />
+            )}
+            <Link
+                href={CORE_AGENTS_ADMIN_HREF}
+                className="mt-3 inline-block text-sm font-medium text-blue-600 underline underline-offset-2 hover:text-blue-700 dark:text-blue-400"
+            >
+                Open Core Agents page
+            </Link>
+        </>
+    );
+}
+
 /**
  * Formats one commitment type into a human-readable label.
  */

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

@@ -39,6 +39,7 @@ export function BookEditorWrapper({ agentName, initialAgentSource }: BookEditorW
         missingAgentReferences,
         creatingReference,
         handleCreateReferencedAgent,
+        handleCoreAgentsReinstated,
         historyPanelProps,
     } = useBookEditorWrapper({ agentName, initialAgentSource });
 
@@ -77,6 +78,7 @@ export function BookEditorWrapper({ agentName, initialAgentSource }: BookEditorW
                         missingAgentReferences={missingAgentReferences}
                         creatingReference={creatingReference}
                         onCreateReferencedAgent={handleCreateReferencedAgent}
+                        onCoreAgentsReinstated={handleCoreAgentsReinstated}
                     />
                 </div>
 
@@ -88,6 +90,7 @@ export function BookEditorWrapper({ agentName, initialAgentSource }: BookEditorW
                 missingAgentReferences={missingAgentReferences}
                 creatingReference={creatingReference}
                 onCreateReferencedAgent={handleCreateReferencedAgent}
+                onCoreAgentsReinstated={handleCoreAgentsReinstated}
             />
         </div>
     );

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

@@ -234,6 +234,17 @@ export function useBookEditorDiagnostics({
         [agentName, agentSource, requestDiagnostics],
     );
 
+    /**
+     * Reloads diagnostics after the missing core agents were reinstated.
+     *
+     * The resolver is cached per server, so the refresh has to be forced for the reinstated agents to be visible.
+     *
+     * @private function of useBookEditorWrapper
+     */
+    const handleCoreAgentsReinstated = useCallback(() => {
+        void requestDiagnostics(agentSource, { forceRefresh: true });
+    }, [agentSource, requestDiagnostics]);
+
     useEffect(() => {
         void requestDiagnostics(initialAgentSource);
     }, [initialAgentSource, requestDiagnostics]);
@@ -257,5 +268,6 @@ export function useBookEditorDiagnostics({
         requestDiagnostics,
         scheduleDiagnostics,
         handleCreateReferencedAgent,
+        handleCoreAgentsReinstated,
     };
 }

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

@@ -113,6 +113,7 @@ export function useBookEditorWrapper({ agentName, initialAgentSource }: UseBookE
         requestDiagnostics,
         scheduleDiagnostics,
         handleCreateReferencedAgent,
+        handleCoreAgentsReinstated,
     } = useBookEditorDiagnostics({
         agentName,
         initialAgentSource,
@@ -212,6 +213,7 @@ export function useBookEditorWrapper({ agentName, initialAgentSource }: UseBookE
         missingAgentReferences,
         creatingReference,
         handleCreateReferencedAgent,
+        handleCoreAgentsReinstated,
         historyPanelProps,
     };
 }

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

@@ -1,6 +1,6 @@
 'use client';
 
-import { Clock3Icon, RepeatIcon } from 'lucide-react';
+import { CalendarRangeIcon, 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';
@@ -37,6 +37,18 @@ type AgentGoalChatPlannedMessagesProps = {
     readonly currentTimestamp: number;
 };
 
+/**
+ * Renders one boundary of the window in which a planned message may wake the agent.
+ *
+ * @param boundary - Starting or ending date of the planned message.
+ * @returns Local date-time text, or `∞` for a side of the window which is not bounded.
+ *
+ * @private function of AgentGoalChatPlannedMessages
+ */
+function formatPlannedMessageBoundary(boundary: string | null): string {
+    return boundary === null ? '∞' : new Date(boundary).toLocaleString();
+}
+
 /**
  * Keeps only the planned messages that can still wake the agent up.
  *
@@ -134,8 +146,7 @@ export function AgentGoalChatPlannedMessages({ agentName, currentTimestamp }: Ag
                             >
                                 <div className="min-w-0 flex-1">
                                     <div className="truncate text-sm font-medium text-slate-800 dark:text-slate-100">
-                                        {plannedMessage.message ||
-                                            translateText('goalChat.plannedMessageDefaultLabel')}
+                                        {plannedMessage.message || translateText('goalChat.plannedMessageDefaultLabel')}
                                     </div>
                                     <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">
@@ -159,6 +170,38 @@ export function AgentGoalChatPlannedMessages({ agentName, currentTimestamp }: Ag
                                                 </span>
                                             </span>
                                         )}
+                                        {plannedMessage.cronExpression !== 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.plannedMessageCronLabel', {
+                                                        cron: plannedMessage.cronExpression,
+                                                    })}
+                                                </span>
+                                            </span>
+                                        )}
+                                        {plannedMessage.maxRunCount !== 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.plannedMessageRunCountLabel', {
+                                                        runCount: String(plannedMessage.runCount),
+                                                        maxRunCount: String(plannedMessage.maxRunCount),
+                                                    })}
+                                                </span>
+                                            </span>
+                                        )}
+                                        {(plannedMessage.startsAt !== null || plannedMessage.endsAt !== null) && (
+                                            <span className="inline-flex items-center gap-1.5 text-slate-500 dark:text-slate-400">
+                                                <CalendarRangeIcon className="h-3.5 w-3.5" />
+                                                <span>
+                                                    {translateText('goalChat.plannedMessageWindowLabel', {
+                                                        from: formatPlannedMessageBoundary(plannedMessage.startsAt),
+                                                        to: formatPlannedMessageBoundary(plannedMessage.endsAt),
+                                                    })}
+                                                </span>
+                                            </span>
+                                        )}
                                     </div>
                                 </div>
                                 <button

package/apps/agents-server/src/app/api/admin/default-agents/reinstate/route.ts

@@ -2,7 +2,9 @@ import { NextResponse } from 'next/server';
 import { seedCoreAgents } from '../../../../../database/seedCoreAgents';
 import { reinstateDefaultAgents } from '../../../../../database/reinstateDefaultAgents';
 import { $provideServer } from '../../../../../tools/$provideServer';
+import { $invalidateProvidedAgentReferenceResolverCache } from '../../../../../utils/agentReferenceResolver/$provideAgentReferenceResolver';
 import { invalidateCachedActiveOrganizationSnapshots } from '../../../../../utils/agentOrganization/loadAgentOrganizationState';
+import { invalidateCachedServerAgentRuntime } from '../../../../../utils/cachedServerAgentRuntime';
 import { isUserAdmin } from '../../../../../utils/isUserAdmin';
 
 /**
@@ -47,7 +49,9 @@ export async function POST(request: Request) {
                 ? (await seedCoreAgents({ tablePrefix })).createdAgentNames
                 : (await reinstateDefaultAgents({ tablePrefix })).createdAgentNames;
 
-        // Note: Drop the short-lived organization snapshot cache so the newly created agents appear immediately.
+        // Note: These direct collection writes bypass the normal collection decoration that invalidates these caches.
+        $invalidateProvidedAgentReferenceResolverCache();
+        invalidateCachedServerAgentRuntime();
         invalidateCachedActiveOrganizationSnapshots();
 
         return NextResponse.json({ scope, createdAgentNames });

package/apps/agents-server/src/app/api/admin/planned-messages/[timeoutId]/route.ts

@@ -0,0 +1,80 @@
+import { NextResponse } from 'next/server';
+import { ParseError } from '../../../../../../../../src/errors/ParseError';
+import { isUserAdmin } from '@/src/utils/isUserAdmin';
+import { cancelManagedPlannedMessage } from '@/src/utils/plannedMessageManager/cancelManagedPlannedMessage';
+import { parsePlannedMessageManagerUpdateRequest } from '@/src/utils/plannedMessageManager/parsePlannedMessageManagerUpdateRequest';
+import { updateManagedPlannedMessage } from '@/src/utils/plannedMessageManager/updateManagedPlannedMessage';
+
+/**
+ * Keeps planned-message persistence on the Node.js runtime.
+ */
+export const runtime = 'nodejs';
+
+/**
+ * Changes the schedule, the text, or the paused state of one planned message of any agent.
+ */
+export async function PATCH(request: Request, { params }: { params: Promise<{ timeoutId: string }> }) {
+    if (!(await isUserAdmin())) {
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    const timeoutId = decodeURIComponent((await params).timeoutId);
+
+    try {
+        const updateRequest = parsePlannedMessageManagerUpdateRequest(await request.json().catch(() => null));
+        const updateResult = await updateManagedPlannedMessage(timeoutId, updateRequest);
+
+        if (updateResult.status === 'not_found') {
+            return NextResponse.json({ error: 'Planned message not found.' }, { status: 404 });
+        }
+
+        if (updateResult.status === 'busy') {
+            return NextResponse.json(
+                { error: 'This planned message is waking its agent right now, so its plan cannot be changed.' },
+                { status: 409 },
+            );
+        }
+
+        return NextResponse.json({ plannedMessage: updateResult.plannedMessage });
+    } catch (error) {
+        if (error instanceof ParseError) {
+            return NextResponse.json({ error: error.message }, { status: 400 });
+        }
+
+        console.error('[admin-planned-message] update failed', { timeoutId, error });
+        return NextResponse.json(
+            { error: error instanceof Error ? error.message : 'Failed to update the planned message.' },
+            { status: 500 },
+        );
+    }
+}
+
+/**
+ * Cancels one planned message of any agent, so it never wakes that agent again.
+ */
+export async function DELETE(request: Request, { params }: { params: Promise<{ timeoutId: string }> }) {
+    if (!(await isUserAdmin())) {
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    const timeoutId = decodeURIComponent((await params).timeoutId);
+
+    try {
+        const cancelResult = await cancelManagedPlannedMessage(timeoutId);
+
+        if (cancelResult === 'not_found') {
+            return NextResponse.json(
+                { error: 'There is no planned message to cancel under this id.' },
+                { status: 404 },
+            );
+        }
+
+        return NextResponse.json({ ok: true });
+    } catch (error) {
+        console.error('[admin-planned-message] cancel failed', { timeoutId, error });
+        return NextResponse.json(
+            { error: error instanceof Error ? error.message : 'Failed to cancel the planned message.' },
+            { status: 500 },
+        );
+    }
+}

package/apps/agents-server/src/app/api/admin/planned-messages/route.ts

@@ -0,0 +1,19 @@
+import { NextResponse } from 'next/server';
+import { isUserAdmin } from '@/src/utils/isUserAdmin';
+import { getPlannedMessageManagerResponse } from '@/src/utils/plannedMessageManager/getPlannedMessageManagerResponse';
+
+/**
+ * Lists every planned message of every agent for the admin planned-message manager.
+ */
+export async function GET() {
+    if (!(await isUserAdmin())) {
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    try {
+        return NextResponse.json(await getPlannedMessageManagerResponse());
+    } catch (error) {
+        console.error('[admin-planned-message] listing failed', error);
+        return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+    }
+}

package/apps/agents-server/src/app/api/internal/agent-goal-chat-planned-messages/route.ts

@@ -12,7 +12,7 @@ import { resolveUserChatWorkerInternalToken } from '@/src/utils/userChat';
 /**
  * Actions accepted by the internal planned-message runtime route.
  */
-const AGENT_GOAL_CHAT_PLANNED_MESSAGE_REQUEST_ACTIONS = ['set', 'list', 'cancel'] as const;
+const AGENT_GOAL_CHAT_PLANNED_MESSAGE_REQUEST_ACTIONS = ['set', 'update', 'list', 'cancel'] as const;
 
 /**
  * Supported planned-message runtime action.
@@ -93,11 +93,20 @@ async function executeAgentGoalChatPlannedMessageRequest(request: AgentGoalChatP
     if (request.action === 'set') {
         return await AGENT_GOAL_CHAT_PLANNED_MESSAGE_ACTIONS.set({
             agentPermanentId,
-            milliseconds: request.body.milliseconds,
+            ...createPlannedMessageScheduleRequest(request.body),
             message: request.body.message,
         });
     }
 
+    if (request.action === 'update') {
+        return await AGENT_GOAL_CHAT_PLANNED_MESSAGE_ACTIONS.update({
+            agentPermanentId,
+            timeoutId: request.body.timeoutId,
+            ...createPlannedMessageScheduleRequest(request.body),
+            ...(request.body.message === undefined ? {} : { message: request.body.message }),
+        });
+    }
+
     if (request.action === 'list') {
         return await AGENT_GOAL_CHAT_PLANNED_MESSAGE_ACTIONS.list({
             agentPermanentId,
@@ -112,6 +121,25 @@ async function executeAgentGoalChatPlannedMessageRequest(request: AgentGoalChatP
     });
 }
 
+/**
+ * Collects the schedule fields of one internal planned-message request.
+ *
+ * A field which is not part of the request body stays absent, so one update changes only what it
+ * really names and everything else keeps its stored value.
+ *
+ * @param body - Parsed request body.
+ * @returns Schedule fields passed to the shared planned-message actions.
+ */
+function createPlannedMessageScheduleRequest(body: Record<string, unknown>): Record<string, unknown> {
+    return {
+        ...(body.milliseconds === undefined ? {} : { milliseconds: body.milliseconds }),
+        ...(body.cronExpression === undefined ? {} : { cronExpression: body.cronExpression }),
+        ...(body.startsAt === undefined ? {} : { startsAt: body.startsAt }),
+        ...(body.endsAt === undefined ? {} : { endsAt: body.endsAt }),
+        ...(body.maxRunCount === undefined ? {} : { maxRunCount: body.maxRunCount }),
+    };
+}
+
 /**
  * Validates one planned-message action value.
  */

package/apps/agents-server/src/components/DefaultAgents/ReinstateBundledAgentsButton.tsx

@@ -48,6 +48,11 @@ type ReinstateBundledAgentsButtonProps = {
      * Tailwind classes controlling the button appearance.
      */
     readonly className: string;
+
+    /**
+     * Invoked after a successful reinstatement, for client state that a server re-render does not refresh.
+     */
+    readonly onReinstated?: () => void;
 };
 
 /**
@@ -67,6 +72,7 @@ export function ReinstateBundledAgentsButton({
     pendingLabel,
     confirmMessage,
     className,
+    onReinstated,
 }: ReinstateBundledAgentsButtonProps) {
     const router = useRouter();
     const [isReinstating, setIsReinstating] = useState(false);
@@ -101,6 +107,7 @@ export function ReinstateBundledAgentsButton({
             }
 
             router.refresh();
+            onReinstated?.();
         } catch (reinstateError) {
             await showAlert({
                 title: 'Reinstate agents',

package/apps/agents-server/src/components/DefaultAgents/coreAgentsAdminRoute.ts

@@ -0,0 +1,6 @@
+/**
+ * Path of the admin page that tracks the presence of the bundled core agents and explains why each one exists.
+ *
+ * @private constant shared by every place offering to reinstate the core agents
+ */
+export const CORE_AGENTS_ADMIN_HREF = '/admin/core-agents';

package/apps/agents-server/src/components/Header/buildHeaderSystemMenuItems.ts

@@ -1,5 +1,6 @@
 import {
     Activity,
+    AlarmClock,
     Archive,
     BadgeInfo,
     BarChart3,
@@ -137,6 +138,7 @@ type SystemMenuItemHref =
     | '/admin/usage'
     | '/admin/task-manager'
     | '/superadmin/task-manager'
+    | '/admin/planned-messages'
     | '/admin/chat-history'
     | '/admin/chat-feedback'
     | '/admin/api-tokens'
@@ -239,6 +241,7 @@ const SYSTEM_MENU_ICON_BY_HREF: Record<SystemMenuItemHref, LucideIcon> = {
     '/admin/usage': ChartNoAxesColumn,
     '/admin/task-manager': ClipboardList,
     '/superadmin/task-manager': ServerCog,
+    '/admin/planned-messages': AlarmClock,
     '/admin/chat-history': History,
     '/admin/chat-feedback': MessageCircle,
     '/admin/api-tokens': KeyRound,
@@ -647,6 +650,10 @@ export function buildHeaderSystemMenuItems({
                   } as SubMenuItem,
               ]
             : []),
+        {
+            label: translate('header.plannedMessageManager'),
+            href: '/admin/planned-messages',
+        },
         {
             label: translate('header.chatHistory'),
             href: '/admin/chat-history',

package/apps/agents-server/src/components/Homepage/DefaultAgentsStatusNotice.tsx

@@ -1,13 +1,7 @@
 import Link from 'next/link';
+import { CORE_AGENTS_ADMIN_HREF } from '../DefaultAgents/coreAgentsAdminRoute';
 import { ReinstateBundledAgentsButton } from '../DefaultAgents/ReinstateBundledAgentsButton';
 
-/**
- * Admin page tracking the presence of the core agents.
- *
- * @private constant of <DefaultAgentsStatusNotice/>
- */
-const CORE_AGENTS_ADMIN_HREF = '/admin/core-agents';
-
 /**
  * Props for the admin-only home page notice about missing bundled agents.
  *

package/apps/agents-server/src/database/migrations/2026-08-1800-user-chat-timeout-schedule.sql

@@ -0,0 +1,11 @@
+-- Planned messages can repeat on a cron, for a bounded number of runs, and inside a date window.
+-- Existing rows keep their `recurrenceIntervalMs` behaviour, because every added column is optional.
+ALTER TABLE "prefix_UserChatTimeout"
+    ADD COLUMN IF NOT EXISTS "cronExpression" TEXT NULL,
+    ADD COLUMN IF NOT EXISTS "startsAt" TIMESTAMP WITH TIME ZONE NULL,
+    ADD COLUMN IF NOT EXISTS "endsAt" TIMESTAMP WITH TIME ZONE NULL,
+    ADD COLUMN IF NOT EXISTS "maxRunCount" INTEGER NULL;
+
+CREATE INDEX IF NOT EXISTS "prefix_UserChatTimeout_endsAt_idx"
+    ON "prefix_UserChatTimeout" ("endsAt")
+    WHERE "endsAt" IS NOT NULL;

package/apps/agents-server/src/instrumentation-node.ts

@@ -70,6 +70,24 @@ export async function registerNodeRuntimeInstrumentation(): Promise<void> {
         });
     }
 
+    try {
+        // Note: Running is the default state of an agent project, so every project which was not
+        //       explicitly stopped is started again right after the server was restarted, and is
+        //       kept running by later passes.
+        const { ensureAgentProjectRuntimeAutostartBootstrapped } = await import(
+            './utils/agentProjects/agentProjectRuntimeAutostartScheduler'
+        );
+        ensureAgentProjectRuntimeAutostartBootstrapped();
+    } catch (error) {
+        console.error('❌ Automatic agent project start failed during Agents Server instrumentation.', {
+            nextRuntime: process.env.NEXT_RUNTIME,
+            nodeEnv: process.env.NODE_ENV,
+            errorName: error instanceof Error ? error.name : undefined,
+            errorMessage: error instanceof Error ? error.message : String(error),
+            errorStack: error instanceof Error ? error.stack : undefined,
+        });
+    }
+
     try {
         // Note: Keeps Let's Encrypt certificates for every assigned server and project
         //       domain obtained and renewed automatically. A domain whose DNS was not

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

@@ -23,6 +23,9 @@ export const SERVER_TRANSLATION_KEYS = [
     'goalChat.plannedMessagesLoadErrorLabel',
     'goalChat.plannedMessageDefaultLabel',
     'goalChat.plannedMessageIntervalLabel',
+    'goalChat.plannedMessageCronLabel',
+    'goalChat.plannedMessageRunCountLabel',
+    'goalChat.plannedMessageWindowLabel',
     'goalChat.plannedMessageCancelLabel',
     'goalChat.plannedMessageCancellingLabel',
     'common.projects',
@@ -174,6 +177,7 @@ export const SERVER_TRANSLATION_KEYS = [
     'header.usageAnalytics',
     'header.taskManager',
     'header.vpsTaskManager',
+    'header.plannedMessageManager',
     'header.messagesEmails',
     'header.emailServer',
     'header.backups',

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

@@ -17,6 +17,9 @@ goalChat.plannedMessagesEmptyLabel: Žádné naplánované zprávy. Agent se pro
 goalChat.plannedMessagesLoadErrorLabel: Naplánované zprávy se nepodařilo načíst.
 goalChat.plannedMessageDefaultLabel: Naplánované probuzení
 goalChat.plannedMessageIntervalLabel: 'Opakování: {interval}'
+goalChat.plannedMessageCronLabel: 'Opakování podle cronu {cron}'
+goalChat.plannedMessageRunCountLabel: 'Proběhlo {runCount} z {maxRunCount} spuštění'
+goalChat.plannedMessageWindowLabel: 'Od {from} do {to}'
 goalChat.plannedMessageCancelLabel: Zrušit
 goalChat.plannedMessageCancellingLabel: Ruším
 common.projects: Projekty
@@ -168,6 +171,7 @@ header.chatHistory: Historie chatů
 header.usageAnalytics: Analytika využití
 header.taskManager: Správa úloh
 header.vpsTaskManager: Správa úloh (všechny servery)
+header.plannedMessageManager: Naplánované zprávy
 header.messagesEmails: Zprávy a e-maily
 header.emailServer: E-mailový server
 header.backups: Zálohy