@promptbook/cli 0.114.0-13 → 0.114.0-18

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

@@ -0,0 +1,289 @@
+'use client';
+
+import {
+    collectPlannedMessageAgentOptions,
+    type PlannedMessageAgentOption,
+} from '@/src/utils/plannedMessageManager/collectPlannedMessageAgentOptions';
+import {
+    createPlannedMessageManagerCounters,
+    type PlannedMessageManagerCounters,
+} from '@/src/utils/plannedMessageManager/createPlannedMessageManagerCounters';
+import {
+    filterPlannedMessages,
+    type PlannedMessageManagerFilters,
+} from '@/src/utils/plannedMessageManager/filterPlannedMessages';
+import {
+    $cancelAdminPlannedMessage,
+    $updateAdminPlannedMessage,
+    type PlannedMessageManagerLastRunFilter,
+    type PlannedMessageManagerRecord,
+    type PlannedMessageManagerRecurrenceFilter,
+    type PlannedMessageManagerSortField,
+    type PlannedMessageManagerView,
+} from '@/src/utils/plannedMessagesAdmin';
+import { useCallback, useDeferredValue, useEffect, useMemo, useState } from 'react';
+import { useAdminTableSorting } from '../_components/adminTableSorting';
+import { createPlannedMessageUpdatePayload, type PlannedMessageEditForm } from './plannedMessageEditForm';
+import { confirmCancelPlannedMessage, showPlannedMessageActionFailure } from './plannedMessageManagerDialogs';
+import {
+    resolvePlannedMessageManagerDefaultSortOrder,
+    resolvePlannedMessageSortValue,
+} from './resolvePlannedMessageSortValue';
+import { usePlannedMessageManagerData, type PlannedMessageManagerData } from './usePlannedMessageManagerData';
+
+/**
+ * Filter value meaning "every agent".
+ *
+ * @private function of PlannedMessageManagerClient
+ */
+export const ANY_PLANNED_MESSAGE_FILTER_VALUE = 'all';
+
+/**
+ * Row action an administrator can start on one planned message.
+ *
+ * @private function of PlannedMessageManagerClient
+ */
+export type PlannedMessageActionKind = 'cancel' | 'pause' | 'edit';
+
+/**
+ * State driving the whole planned-message manager.
+ *
+ * @private function of PlannedMessageManagerClient
+ */
+export type UsePlannedMessageManagerStateResult = {
+    readonly data: PlannedMessageManagerData;
+    readonly counters: PlannedMessageManagerCounters;
+    readonly agentOptions: Array<PlannedMessageAgentOption>;
+    readonly filters: PlannedMessageManagerFilters;
+    readonly searchInput: string;
+    readonly visiblePlannedMessages: Array<PlannedMessageManagerRecord>;
+    readonly matchedCount: number;
+
+    readonly page: number;
+    readonly pageSize: number;
+    readonly totalPages: number;
+    readonly isPreviousPageDisabled: boolean;
+    readonly isNextPageDisabled: boolean;
+    readonly goToPreviousPage: () => void;
+    readonly goToNextPage: () => void;
+    readonly updatePageSize: (value: string) => void;
+
+    readonly sortBy: PlannedMessageManagerSortField;
+    readonly sortOrder: 'asc' | 'desc';
+    readonly handleSortChange: (sortBy: PlannedMessageManagerSortField) => void;
+
+    readonly selectView: (view: PlannedMessageManagerView) => void;
+    readonly updateAgentPermanentId: (agentPermanentId: string) => void;
+    readonly updateRecurrence: (recurrence: string) => void;
+    readonly updateLastRun: (lastRun: string) => void;
+    readonly updateSearchInput: (search: string) => void;
+
+    readonly busyTimeoutId: string | null;
+    readonly busyAction: PlannedMessageActionKind | null;
+    readonly cancelPlannedMessage: (plannedMessage: PlannedMessageManagerRecord) => Promise<void>;
+    readonly togglePlannedMessagePaused: (plannedMessage: PlannedMessageManagerRecord) => Promise<void>;
+
+    readonly editedPlannedMessage: PlannedMessageManagerRecord | null;
+    readonly openPlannedMessageEditor: (plannedMessage: PlannedMessageManagerRecord) => void;
+    readonly closePlannedMessageEditor: () => void;
+    readonly submitPlannedMessageEdit: (form: PlannedMessageEditForm) => Promise<boolean>;
+};
+
+/**
+ * Manages the filters, the ordering, the paging, and the actions of the planned-message manager.
+ *
+ * @returns Everything the planned-message manager renders and does.
+ *
+ * @private function of PlannedMessageManagerClient
+ */
+export function usePlannedMessageManagerState(): UsePlannedMessageManagerStateResult {
+    const data = usePlannedMessageManagerData();
+    const [view, setView] = useState<PlannedMessageManagerView>('active');
+    const [agentPermanentId, setAgentPermanentId] = useState<string>(ANY_PLANNED_MESSAGE_FILTER_VALUE);
+    const [recurrence, setRecurrence] = useState<PlannedMessageManagerRecurrenceFilter>(
+        ANY_PLANNED_MESSAGE_FILTER_VALUE,
+    );
+    const [lastRun, setLastRun] = useState<PlannedMessageManagerLastRunFilter>(ANY_PLANNED_MESSAGE_FILTER_VALUE);
+    const [searchInput, setSearchInput] = useState('');
+    const search = useDeferredValue(searchInput);
+    const [page, setPage] = useState(1);
+    const [pageSize, setPageSize] = useState(25);
+    const [busyTimeoutId, setBusyTimeoutId] = useState<string | null>(null);
+    const [busyAction, setBusyAction] = useState<PlannedMessageActionKind | null>(null);
+    const [editedPlannedMessage, setEditedPlannedMessage] = useState<PlannedMessageManagerRecord | null>(null);
+
+    const { plannedMessages, generatedAt, refreshNow } = data;
+
+    const filters = useMemo<PlannedMessageManagerFilters>(
+        () => ({ view, agentPermanentId, recurrence, lastRun, search: search.trim() }),
+        [agentPermanentId, lastRun, recurrence, search, view],
+    );
+
+    // Note: The stages were resolved when the listing was read, so the same moment decides the windows
+    const filteredAtDate = useMemo(() => (generatedAt ? new Date(generatedAt) : new Date()), [generatedAt]);
+
+    const counters = useMemo(() => createPlannedMessageManagerCounters(plannedMessages), [plannedMessages]);
+    const agentOptions = useMemo(() => collectPlannedMessageAgentOptions(plannedMessages), [plannedMessages]);
+    const filteredPlannedMessages = useMemo(
+        () => filterPlannedMessages(plannedMessages, filters, filteredAtDate),
+        [filteredAtDate, filters, plannedMessages],
+    );
+
+    const { handleSortChange, sortBy, sortedRows, sortOrder } = useAdminTableSorting<
+        PlannedMessageManagerRecord,
+        PlannedMessageManagerSortField
+    >({
+        defaultSortBy: 'nextRun',
+        resolveDefaultSortOrder: resolvePlannedMessageManagerDefaultSortOrder,
+        resolveSortValue: resolvePlannedMessageSortValue,
+        rows: filteredPlannedMessages,
+    });
+
+    const totalPages = Math.max(1, Math.ceil(sortedRows.length / pageSize));
+
+    useEffect(() => {
+        setPage(1);
+    }, [filters, pageSize]);
+
+    useEffect(() => {
+        if (page > totalPages) {
+            setPage(totalPages);
+        }
+    }, [page, totalPages]);
+
+    const visiblePlannedMessages = useMemo(
+        () => sortedRows.slice((page - 1) * pageSize, page * pageSize),
+        [page, pageSize, sortedRows],
+    );
+
+    const runPlannedMessageAction = useCallback(
+        async (options: {
+            plannedMessage: PlannedMessageManagerRecord;
+            action: PlannedMessageActionKind;
+            failureTitle: string;
+            execute: () => Promise<void>;
+        }): Promise<boolean> => {
+            try {
+                setBusyTimeoutId(options.plannedMessage.timeoutId);
+                setBusyAction(options.action);
+                await options.execute();
+                refreshNow();
+                return true;
+            } catch (actionError) {
+                await showPlannedMessageActionFailure(options.failureTitle, actionError);
+                return false;
+            } finally {
+                setBusyTimeoutId(null);
+                setBusyAction(null);
+            }
+        },
+        [refreshNow],
+    );
+
+    const cancelPlannedMessage = useCallback(
+        async (plannedMessage: PlannedMessageManagerRecord): Promise<void> => {
+            if (!(await confirmCancelPlannedMessage(plannedMessage))) {
+                return;
+            }
+
+            await runPlannedMessageAction({
+                plannedMessage,
+                action: 'cancel',
+                failureTitle: 'Cancellation failed',
+                execute: () => $cancelAdminPlannedMessage(plannedMessage.timeoutId),
+            });
+        },
+        [runPlannedMessageAction],
+    );
+
+    const togglePlannedMessagePaused = useCallback(
+        async (plannedMessage: PlannedMessageManagerRecord): Promise<void> => {
+            await runPlannedMessageAction({
+                plannedMessage,
+                action: 'pause',
+                failureTitle: plannedMessage.pausedAt ? 'Resuming failed' : 'Pausing failed',
+                execute: async () => {
+                    await $updateAdminPlannedMessage(plannedMessage.timeoutId, {
+                        isPaused: plannedMessage.pausedAt === null,
+                    });
+                },
+            });
+        },
+        [runPlannedMessageAction],
+    );
+
+    const submitPlannedMessageEdit = useCallback(
+        async (form: PlannedMessageEditForm): Promise<boolean> => {
+            if (editedPlannedMessage === null) {
+                return false;
+            }
+
+            const isApplied = await runPlannedMessageAction({
+                plannedMessage: editedPlannedMessage,
+                action: 'edit',
+                failureTitle: 'Change failed',
+                execute: async () => {
+                    await $updateAdminPlannedMessage(
+                        editedPlannedMessage.timeoutId,
+                        createPlannedMessageUpdatePayload(form),
+                    );
+                },
+            });
+
+            if (isApplied) {
+                setEditedPlannedMessage(null);
+            }
+
+            return isApplied;
+        },
+        [editedPlannedMessage, runPlannedMessageAction],
+    );
+
+    return {
+        data,
+        counters,
+        agentOptions,
+        filters,
+        searchInput,
+        visiblePlannedMessages,
+        matchedCount: sortedRows.length,
+
+        page,
+        pageSize,
+        totalPages,
+        isPreviousPageDisabled: page <= 1,
+        isNextPageDisabled: page >= totalPages,
+        goToPreviousPage: useCallback(() => setPage((currentPage) => Math.max(1, currentPage - 1)), []),
+        goToNextPage: useCallback(
+            () => setPage((currentPage) => Math.min(totalPages, currentPage + 1)),
+            [totalPages],
+        ),
+        updatePageSize: useCallback((value: string) => setPageSize(Number.parseInt(value, 10) || 25), []),
+
+        sortBy,
+        sortOrder,
+        handleSortChange,
+
+        selectView: useCallback((nextView: PlannedMessageManagerView) => setView(nextView), []),
+        updateAgentPermanentId: useCallback((value: string) => setAgentPermanentId(value), []),
+        updateRecurrence: useCallback(
+            (value: string) => setRecurrence(value as PlannedMessageManagerRecurrenceFilter),
+            [],
+        ),
+        updateLastRun: useCallback((value: string) => setLastRun(value as PlannedMessageManagerLastRunFilter), []),
+        updateSearchInput: useCallback((value: string) => setSearchInput(value), []),
+
+        busyTimeoutId,
+        busyAction,
+        cancelPlannedMessage,
+        togglePlannedMessagePaused,
+
+        editedPlannedMessage,
+        openPlannedMessageEditor: useCallback(
+            (plannedMessage: PlannedMessageManagerRecord) => setEditedPlannedMessage(plannedMessage),
+            [],
+        ),
+        closePlannedMessageEditor: useCallback(() => setEditedPlannedMessage(null), []),
+        submitPlannedMessageEdit,
+    };
+}

package/apps/agents-server/src/app/admin/task-manager/TaskManagerClient.tsx

@@ -4,7 +4,12 @@ import { $fetchVpsAdminChatTasks } from '@/src/utils/chatTasksAdmin';
 import { Card } from '../../../components/Homepage/Card';
 import { useServerLanguage } from '../../../components/ServerLanguage/ServerLanguageProvider';
 import { TaskManagerFiltersCard } from './TaskManagerFiltersCard';
-import { SERVER_TASK_MANAGER_PATH, TaskManagerScopeTabs, VPS_TASK_MANAGER_PATH, type TaskManagerScope } from './TaskManagerScopeTabs';
+import {
+    AdminTaskManagerTabs,
+    SERVER_TASK_MANAGER_PATH,
+    VPS_TASK_MANAGER_PATH,
+    type TaskManagerScope,
+} from '../_components/AdminTaskManagerTabs';
 import { TaskManagerSummaryMetrics } from './TaskManagerSummaryMetrics';
 import { TaskManagerTasksCard } from './TaskManagerTasksCard';
 import { useTaskManagerState } from './useTaskManagerState';
@@ -42,7 +47,7 @@ export function TaskManagerClient({ isSuperAdmin, scope = 'server' }: TaskManage
     return (
         <div className="container mx-auto space-y-6 px-4 py-8">
             <div className="mt-20">
-                <TaskManagerScopeTabs activeScope={scope} isSuperAdmin={isSuperAdmin} />
+                <AdminTaskManagerTabs activeTabId={scope} isSuperAdmin={isSuperAdmin} />
             </div>
 
             <div className="flex flex-col gap-4 md:flex-row md:items-end md:justify-between">

package/apps/agents-server/src/app/admin/task-manager/TaskManagerFiltersCard.tsx

@@ -1,6 +1,6 @@
 import type { AdminChatTaskView } from '@/src/utils/chatTasksAdmin';
-import type { ReactNode } from 'react';
 import { Card } from '../../../components/Homepage/Card';
+import { AdminFilterField, AdminFilterSelectField } from '../_components/AdminFilterFields';
 import type { useTaskManagerState } from './useTaskManagerState';
 
 /**
@@ -23,31 +23,6 @@ type TaskManagerFiltersCardProps = {
     state: ReturnType<typeof useTaskManagerState>;
 };
 
-/**
- * Props for the shared field wrapper.
- *
- * @private function of TaskManagerFiltersCard
- */
-type FieldProps = {
-    children: ReactNode;
-    htmlFor: string;
-    label: string;
-};
-
-/**
- * Props for the shared select field.
- *
- * @private function of TaskManagerFiltersCard
- */
-type SelectFieldProps = {
-    disabled?: boolean;
-    id: string;
-    label: string;
-    onChange: (value: string) => void;
-    options: Array<{ label: string; value: string }>;
-    value: string;
-};
-
 /**
  * Available dashboard tabs.
  *
@@ -108,47 +83,6 @@ const TASK_TIME_WINDOW_OPTIONS = [
     { value: '168', label: '7 days' },
 ];
 
-/**
- * Shared field wrapper for compact filter controls.
- *
- * @private function of TaskManagerFiltersCard
- */
-function Field({ children, htmlFor, label }: FieldProps) {
-    return (
-        <div className="flex flex-col gap-1">
-            <label htmlFor={htmlFor} className="text-sm font-medium text-gray-700">
-                {label}
-            </label>
-            {children}
-        </div>
-    );
-}
-
-/**
- * Shared select field used in the filter panel.
- *
- * @private function of TaskManagerFiltersCard
- */
-function SelectField({ disabled, id, label, onChange, options, value }: SelectFieldProps) {
-    return (
-        <Field label={label} htmlFor={id}>
-            <select
-                id={id}
-                value={value}
-                disabled={disabled}
-                onChange={(event) => onChange(event.target.value)}
-                className="rounded-md border border-gray-300 px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-blue-500 disabled:cursor-not-allowed disabled:bg-gray-100 disabled:text-gray-400"
-            >
-                {options.map((option) => (
-                    <option key={option.value} value={option.value}>
-                        {option.label}
-                    </option>
-                ))}
-            </select>
-        </Field>
-    );
-}
-
 /**
  * Resolves the current explanatory text for the selected task view.
  *
@@ -196,7 +130,7 @@ export function TaskManagerFiltersCard({ state }: TaskManagerFiltersCardProps) {
                 </div>
 
                 <div className="grid gap-4 lg:grid-cols-[minmax(0,2fr)_repeat(4,minmax(0,1fr))]">
-                    <Field label="Search" htmlFor="task-search">
+                    <AdminFilterField label="Search" htmlFor="task-search">
                         <input
                             id="task-search"
                             type="text"
@@ -205,9 +139,9 @@ export function TaskManagerFiltersCard({ state }: TaskManagerFiltersCardProps) {
                             placeholder="Task id / chat id / user id / agent id"
                             className="w-full rounded-md border border-gray-300 px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-blue-500"
                         />
-                    </Field>
+                    </AdminFilterField>
 
-                    <SelectField
+                    <AdminFilterSelectField
                         id="task-page-size"
                         label="Page size"
                         value={String(state.pageSize)}
@@ -215,7 +149,7 @@ export function TaskManagerFiltersCard({ state }: TaskManagerFiltersCardProps) {
                         options={TASK_PAGE_SIZE_OPTIONS}
                     />
 
-                    <SelectField
+                    <AdminFilterSelectField
                         id="task-poll-interval"
                         label="Auto-refresh"
                         value={String(state.pollIntervalMs)}
@@ -223,7 +157,7 @@ export function TaskManagerFiltersCard({ state }: TaskManagerFiltersCardProps) {
                         options={TASK_POLL_INTERVAL_OPTIONS}
                     />
 
-                    <SelectField
+                    <AdminFilterSelectField
                         id="task-stuck-threshold"
                         label="Stuck after"
                         value={String(state.stuckThresholdMinutes)}
@@ -231,7 +165,7 @@ export function TaskManagerFiltersCard({ state }: TaskManagerFiltersCardProps) {
                         options={TASK_STUCK_THRESHOLD_OPTIONS}
                     />
 
-                    <SelectField
+                    <AdminFilterSelectField
                         id="task-time-window"
                         label="All window"
                         value={String(state.timeWindowHours)}

package/apps/agents-server/src/app/admin/task-manager/TaskManagerSummaryMetrics.tsx

@@ -1,3 +1,4 @@
+import { AdminMetricCard } from '../_components/AdminMetricCard';
 import type { useTaskManagerState } from './useTaskManagerState';
 
 /**
@@ -7,32 +8,6 @@ import type { useTaskManagerState } from './useTaskManagerState';
  */
 type TaskManagerSummaryMetricsProps = Pick<ReturnType<typeof useTaskManagerState>, 'counters' | 'oldestQueuedAgeLabel'>;
 
-/**
- * Props for one summary metric card.
- *
- * @private function of TaskManagerSummaryMetrics
- */
-type MetricCardProps = {
-    caption: string;
-    label: string;
-    value: string;
-};
-
-/**
- * Small metric card used in the task-manager summary header.
- *
- * @private function of TaskManagerSummaryMetrics
- */
-function MetricCard({ caption, label, value }: MetricCardProps) {
-    return (
-        <div className="rounded-2xl border border-gray-200 bg-white p-5 shadow-sm">
-            <div className="text-xs font-semibold uppercase tracking-wide text-gray-400">{label}</div>
-            <div className="mt-2 text-3xl font-light text-gray-900">{value}</div>
-            <div className="mt-1 text-sm text-gray-500">{caption}</div>
-        </div>
-    );
-}
-
 /**
  * Renders the summary counters above the task table.
  *
@@ -41,22 +16,22 @@ function MetricCard({ caption, label, value }: MetricCardProps) {
 export function TaskManagerSummaryMetrics({ counters, oldestQueuedAgeLabel }: TaskManagerSummaryMetricsProps) {
     return (
         <div className="grid gap-4 md:grid-cols-2 xl:grid-cols-4">
-            <MetricCard
+            <AdminMetricCard
                 label="Running"
                 value={counters ? counters.runningCount.toLocaleString() : '...'}
                 caption="Workers in flight"
             />
-            <MetricCard
+            <AdminMetricCard
                 label="Queued"
                 value={counters ? counters.queuedCount.toLocaleString() : '...'}
                 caption="Tasks waiting to start"
             />
-            <MetricCard
+            <AdminMetricCard
                 label="Failed 24h"
                 value={counters ? counters.failedLast24hCount.toLocaleString() : '...'}
                 caption="Recent failures"
             />
-            <MetricCard label="Oldest queued" value={oldestQueuedAgeLabel} caption="Backlog age" />
+            <AdminMetricCard label="Oldest queued" value={oldestQueuedAgeLabel} caption="Backlog age" />
         </div>
     );
 }

package/apps/agents-server/src/app/admin/task-manager/[taskId]/TaskManagerTaskDetailClient.tsx

@@ -16,7 +16,7 @@ import {
 import { TaskManagerTaskLogActions } from '../TaskManagerTaskLogActions';
 import { TaskManagerTaskTargetLink } from '../TaskManagerTaskTargetLink';
 import { TaskManagerTaskTerminalDialog } from '../TaskManagerTaskTerminalDialog';
-import { SERVER_TASK_MANAGER_PATH, VPS_TASK_MANAGER_PATH } from '../TaskManagerScopeTabs';
+import { SERVER_TASK_MANAGER_PATH, VPS_TASK_MANAGER_PATH } from '../../_components/AdminTaskManagerTabs';
 import {
     buildTaskRunReportRows,
     formatTaskDateTime,

package/apps/agents-server/src/app/agents/[agentName]/api/book/reference-diagnostics/route.ts

@@ -1,9 +1,12 @@
 import { $provideAgentReferenceResolver } from '@/src/utils/agentReferenceResolver/$provideAgentReferenceResolver';
 import { $provideAgentCollectionForServer } from '@/src/tools/$provideAgentCollectionForServer';
 import { createBookScopedAgentReferenceResolver } from '@/src/utils/agentReferenceResolver/bookScopedAgentReferences';
+import { createAgentInheritanceDiagnostics } from '@/src/utils/agentReferenceResolver/createAgentInheritanceDiagnostics';
 import { createUnresolvedAgentReferenceDiagnostics } from '@/src/utils/agentReferenceResolver/createUnresolvedAgentReferenceDiagnostics';
 import { createAgentNameCollisionDiagnostics } from '@/src/utils/agentReferenceResolver/createAgentNameCollisionDiagnostics';
+import { resolveCoreAgentAwareMissingReferences } from '@/src/utils/agentReferenceResolver/resolveCoreAgentAwareMissingReferences';
 import { getCurrentUser } from '@/src/utils/getCurrentUser';
+import { isUserAdmin } from '@/src/utils/isUserAdmin';
 import { string_book } from '@promptbook-local/types';
 import { serializeError } from '@promptbook-local/utils';
 import { assertsError } from '../../../../../../../../../src/errors/assertsError';
@@ -38,17 +41,35 @@ export async function POST(request: Request, { params }: { params: Promise<{ age
             fallbackResolver: baseAgentReferenceResolver,
         });
 
-        const [referenceDiagnostics, nameCollisionDiagnostics] = await Promise.all([
-            createUnresolvedAgentReferenceDiagnostics(agentSource, agentReferenceResolver),
-            createAgentNameCollisionDiagnostics(agentSource, parentAgentPermanentId, collection),
-        ]);
+        const localServerUrl = new URL(request.url).origin;
+        const [referenceDiagnostics, nameCollisionDiagnostics, inheritanceDiagnostics, isReinstateAllowed] =
+            await Promise.all([
+                createUnresolvedAgentReferenceDiagnostics(agentSource, agentReferenceResolver),
+                createAgentNameCollisionDiagnostics(agentSource, parentAgentPermanentId, collection),
+                createAgentInheritanceDiagnostics({
+                    agentSource,
+                    agentPermanentId: parentAgentPermanentId,
+                    collection,
+                    localServerUrl,
+                }),
+                isUserAdmin(),
+            ]);
+        const missingAgentReferences = await resolveCoreAgentAwareMissingReferences({
+            agentSource,
+            missingAgentReferences: referenceDiagnostics.missingAgentReferences,
+            isReinstateAllowed,
+        });
 
         return new Response(
             JSON.stringify({
                 isSuccessful: true,
                 agentName,
-                diagnostics: [...referenceDiagnostics.diagnostics, ...nameCollisionDiagnostics],
-                missingAgentReferences: referenceDiagnostics.missingAgentReferences,
+                diagnostics: [
+                    ...referenceDiagnostics.diagnostics,
+                    ...nameCollisionDiagnostics,
+                    ...inheritanceDiagnostics,
+                ],
+                missingAgentReferences,
             }),
             {
                 status: 200,
@@ -79,5 +100,7 @@ function isTruthySearchParam(value: string | null): boolean {
     }
 
     const normalizedValue = value.trim().toLowerCase();
-    return normalizedValue === '1' || normalizedValue === 'true' || normalizedValue === 'yes' || normalizedValue === 'on';
+    return (
+        normalizedValue === '1' || normalizedValue === 'true' || normalizedValue === 'yes' || normalizedValue === 'on'
+    );
 }

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

@@ -113,6 +113,7 @@ export async function GET(request: Request, { params }: { params: Promise<{ agen
             adamAgentUrl,
             recursionLevel,
             currentAgentUrl: resolvedAgentContext.canonicalAgentUrl,
+            currentAgentAliases: resolvedAgentContext.currentAgentAliases,
             inheritancePath: inheritancePath as Array<string_agent_url>,
             agentReferenceResolver,
             federatedAgentImportConfiguration,

package/apps/agents-server/src/app/agents/[agentName]/api/book/test.http

@@ -16,7 +16,7 @@ Content-Type: text/plain
 Gabriel Gray
 
 META COLOR #c9c9c9
-PERSONA Friendly and helpful AI agent.
+GOAL Help users as a friendly AI agent.
 RULE Be kind and respectful.
 
 
@@ -33,5 +33,5 @@ Content-Type: text/plain
 Gabriel Gray
 
 META COLOR #242424
-PERSONA Strict and professional AI agent.
-RULE Be strict and professional.
+GOAL Help users as a strict and professional AI agent.
+RULE Be strict and professional.