@promptbook/cli 0.114.0-3 → 0.114.0-30

package/apps/agents-server/src/utils/dnsRecords/createServerDnsRecordsSections.ts

@@ -0,0 +1,58 @@
+import type { ManagedServerDnsDiagnostic } from '../../app/superadmin/servers/ServersRegistryDnsTypes';
+import { createAgentProjectsDnsRecordsSection } from '../agentProjects/createAgentProjectsDnsRecordsSection';
+import { createEmailDnsRecordsSection } from '../stalwart/createEmailDnsRecordsSection';
+import type { DnsRecordsSection } from './DnsRecordsSection';
+import { createServerDomainDnsRecordsSection } from './createServerDomainDnsRecordsSection';
+
+/**
+ * Creates every DNS section which one Agents Server needs to be fully configured.
+ *
+ * This is the single source of truth of the complete DNS setup of one server, so that `/superadmin/servers` can show
+ * the server domain, the generated project domains, and the email records in one manual and one Cloudflare wizard.
+ *
+ * @param options - Server domain, its DNS diagnostic, and the generated project domain state.
+ * @returns All DNS sections of one server.
+ *
+ * @private shared by the Agents Server DNS instruction views
+ */
+export function createServerDnsRecordsSections(options: {
+    /**
+     * Public domain of the Agents Server.
+     */
+    readonly serverDomain: string;
+
+    /**
+     * DNS verification details of the server domain, when the deployment provides them.
+     */
+    readonly dnsDiagnostic: ManagedServerDnsDiagnostic | null | undefined;
+
+    /**
+     * Whether at least one generated project domain currently fails DNS verification.
+     */
+    readonly isProjectDnsIssue?: boolean;
+
+    /**
+     * Example generated project domain, when one is already assigned.
+     */
+    readonly projectDomain?: string | null;
+}): ReadonlyArray<DnsRecordsSection> {
+    const publicIpAddress = options.dnsDiagnostic?.publicIpAddress ?? null;
+    const serverDomainSection = createServerDomainDnsRecordsSection({
+        serverDomain: options.serverDomain,
+        dnsDiagnostic: options.dnsDiagnostic,
+    });
+
+    return [
+        ...(serverDomainSection ? [serverDomainSection] : []),
+        createAgentProjectsDnsRecordsSection({
+            isDnsIssue: options.isProjectDnsIssue,
+            projectDomain: options.projectDomain,
+            publicIpAddress,
+            serverDomain: options.serverDomain,
+        }),
+        createEmailDnsRecordsSection({
+            domain: options.serverDomain,
+            publicIpAddress,
+        }),
+    ];
+}

package/apps/agents-server/src/utils/dnsRecords/createServerDomainDnsRecordsSection.ts

@@ -0,0 +1,48 @@
+import {
+    isManagedServerDnsDiagnosticIssue,
+    type ManagedServerDnsDiagnostic,
+} from '../../app/superadmin/servers/ServersRegistryDnsTypes';
+import type { DnsRecordsSection } from './DnsRecordsSection';
+
+/**
+ * Creates the DNS section which makes the Agents Server itself reachable on its own domain.
+ *
+ * @param options - Server domain and its DNS diagnostic.
+ * @returns Server domain section, or `null` when the deployment does not verify server domains.
+ *
+ * @private shared by the Agents Server DNS instruction views
+ */
+export function createServerDomainDnsRecordsSection(options: {
+    /**
+     * Public domain of the Agents Server.
+     */
+    readonly serverDomain: string;
+
+    /**
+     * DNS verification details of the server domain, when the deployment provides them.
+     */
+    readonly dnsDiagnostic: ManagedServerDnsDiagnostic | null | undefined;
+}): DnsRecordsSection | null {
+    const { dnsDiagnostic, serverDomain } = options;
+
+    if (!dnsDiagnostic || dnsDiagnostic.expectedRecords.length === 0) {
+        return null;
+    }
+
+    return {
+        id: 'server-domain',
+        title: `Server domain ${serverDomain}`,
+        description: `Makes the Agents Server reachable on ${serverDomain} and lets it issue its HTTPS certificate.`,
+        variants: [
+            {
+                id: 'server-domain',
+                label: 'Server domain',
+                recordSelection: 'one',
+                records: dnsDiagnostic.expectedRecords,
+            },
+        ],
+        statusSummary: dnsDiagnostic.summary,
+        resolvedAddresses: dnsDiagnostic.resolvedAddresses,
+        isDnsIssue: isManagedServerDnsDiagnosticIssue(dnsDiagnostic),
+    };
+}

package/apps/agents-server/src/utils/dnsRecords/dnsRecordGroups.ts

@@ -0,0 +1,52 @@
+import type { DnsRecordGroup } from './DnsRecordInstruction';
+
+/**
+ * Determines whether every record of every shown group has to be configured.
+ *
+ * @param recordGroups - Groups shown in one DNS manual.
+ * @returns `true` when no group offers alternatives.
+ *
+ * @private shared by the Agents Server DNS instruction views
+ */
+export function isEveryDnsRecordGroupRequired(recordGroups: ReadonlyArray<DnsRecordGroup>): boolean {
+    return recordGroups.every((recordGroup) => recordGroup.recordSelection === 'all');
+}
+
+/**
+ * Determines whether every shown group offers alternatives out of which only one may be configured.
+ *
+ * @param recordGroups - Groups shown in one DNS manual.
+ * @returns `true` when no group requires all of its records.
+ *
+ * @private shared by the Agents Server DNS instruction views
+ */
+export function isEveryDnsRecordGroupAlternative(recordGroups: ReadonlyArray<DnsRecordGroup>): boolean {
+    return recordGroups.every((recordGroup) => recordGroup.recordSelection === 'one');
+}
+
+/**
+ * Determines whether at least one shown group offers alternatives.
+ *
+ * Such a group can conflict with already configured records on the same hostname, so the manual has to mention
+ * removing them.
+ *
+ * @param recordGroups - Groups shown in one DNS manual.
+ * @returns `true` when at least one group offers alternatives.
+ *
+ * @private shared by the Agents Server DNS instruction views
+ */
+export function hasAlternativeDnsRecordGroup(recordGroups: ReadonlyArray<DnsRecordGroup>): boolean {
+    return recordGroups.some((recordGroup) => recordGroup.recordSelection === 'one');
+}
+
+/**
+ * Counts all records shown in the given groups.
+ *
+ * @param recordGroups - Groups shown in one DNS manual.
+ * @returns Number of shown records.
+ *
+ * @private shared by the Agents Server DNS instruction views
+ */
+export function countDnsRecordGroupRecords(recordGroups: ReadonlyArray<DnsRecordGroup>): number {
+    return recordGroups.reduce((recordCount, recordGroup) => recordCount + recordGroup.records.length, 0);
+}

package/apps/agents-server/src/utils/dnsRecords/resolveDnsRecordBatchPlan.ts

@@ -1,4 +1,4 @@
-import type { DnsRecordInstruction, DnsRecordSelection } from './DnsRecordInstruction';
+import type { DnsRecordGroup, DnsRecordInstruction, DnsRecordSelection } from './DnsRecordInstruction';
 
 /**
  * Placeholder values like `<VPS_PUBLIC_IP>` have to be filled in by a human before the record can be created.
@@ -79,3 +79,49 @@ export function resolveDnsRecordBatchPlan(options: {
 
     return { applicableRecords, excludedRecords };
 }
+
+/**
+ * Resolves one batch plan for all groups shown in one DNS manual.
+ *
+ * Every group keeps its own all-or-one rule, so a manual which shows the server domain, the generated project
+ * domains, and the email records at once still writes exactly the records which each of these parts needs.
+ *
+ * @param recordGroups - Groups shown in one DNS manual.
+ * @returns One batch plan covering all groups without duplicated records.
+ */
+export function resolveDnsRecordBatchPlanForGroups(recordGroups: ReadonlyArray<DnsRecordGroup>): DnsRecordBatchPlan {
+    const applicableRecords: Array<DnsRecordInstruction> = [];
+    const excludedRecords: Array<ExcludedDnsRecordInstruction> = [];
+    const alreadyPlannedRecordKeys = new Set<string>();
+
+    for (const recordGroup of recordGroups) {
+        const groupBatchPlan = resolveDnsRecordBatchPlan(recordGroup);
+
+        for (const record of groupBatchPlan.applicableRecords) {
+            const recordKey = createDnsRecordKey(record);
+
+            if (alreadyPlannedRecordKeys.has(recordKey)) {
+                continue;
+            }
+
+            alreadyPlannedRecordKeys.add(recordKey);
+            applicableRecords.push(record);
+        }
+
+        excludedRecords.push(...groupBatchPlan.excludedRecords);
+    }
+
+    return { applicableRecords, excludedRecords };
+}
+
+/**
+ * Creates the identity of one DNS record used to keep the batch free of duplicates.
+ *
+ * @param record - DNS record shown in the DNS manual.
+ * @returns Case-insensitive record key.
+ *
+ * @private function of `resolveDnsRecordBatchPlanForGroups`
+ */
+function createDnsRecordKey(record: DnsRecordInstruction): string {
+    return [record.type.toUpperCase(), record.name.toLowerCase(), record.value].join('\t');
+}

package/apps/agents-server/src/utils/email/agentEmailAddress.ts

@@ -82,6 +82,20 @@ export function extractEmailAddress(value: string): string {
     return value.match(/<\s*([^>]+?)\s*>/)?.[1]?.trim() || value.trim();
 }
 
+/**
+ * Extracts and normalizes the domain of an email address.
+ */
+export function getEmailAddressDomain(value: string): string {
+    const emailAddress = extractEmailAddress(value);
+    const separatorIndex = emailAddress.lastIndexOf('@');
+
+    if (separatorIndex === -1) {
+        return '';
+    }
+
+    return normalizeEmailDomain(emailAddress.slice(separatorIndex + 1));
+}
+
 /**
  * Normalizes a mail domain for comparisons and generated addresses.
  */

package/apps/agents-server/src/utils/email/sendEmailThroughStalwart.ts

@@ -4,6 +4,7 @@ import { parseEmailAddress } from '../../message-providers/email/_common/utils/p
 import { createStalwartMessageProviderFromEnvironment } from '../../message-providers/email/stalwart/StalwartMessageProvider';
 import { sendMessage } from '../messages/sendMessage';
 import { synchronizeStalwartEmailDomain } from '../stalwart/synchronizeStalwartEmailDomain';
+import { getEmailAddressDomain } from './agentEmailAddress';
 
 /**
  * Stable provider name stored with outbound Stalwart delivery attempts.
@@ -20,7 +21,7 @@ export async function sendEmailThroughStalwart(message: OutboundEmail): Promise<
     }
 
     const senderAddress = parseEmailAddress(message.sender).fullEmail;
-    const senderDomain = senderAddress.slice(senderAddress.lastIndexOf('@') + 1).toLowerCase();
+    const senderDomain = getEmailAddressDomain(senderAddress);
     await synchronizeStalwartEmailDomain(senderDomain).catch((error) => {
         console.error('[stalwart-email]', 'pre_delivery_domain_synchronization_failed', {
             senderDomain,

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

@@ -0,0 +1,130 @@
+import type { string_book } from '../../../../src/_packages/types.index'; // <- [🚾]
+
+/**
+ * Commitment keyword that declares the parent agent of one book.
+ *
+ * @private utility of Agents Server inheritance resolution
+ */
+const FROM_COMMITMENT_TYPE = 'FROM';
+
+/**
+ * Matches one standalone `FROM` commitment line and captures its inline content.
+ *
+ * The Book parser accepts horizontal whitespace between a commitment keyword and its value, so inheritance resolution
+ * must do the same. Keeping this pattern here makes every server-side consumer agree on which `FROM` lines are real.
+ *
+ * @private utility of Agents Server inheritance resolution
+ */
+const FROM_COMMITMENT_LINE_PATTERN = new RegExp(`^${FROM_COMMITMENT_TYPE}(?:\\s+(.*))?$`);
+
+/**
+ * One explicit `FROM` commitment written in a book.
+ *
+ * @private utility of Agents Server inheritance resolution
+ */
+export type ExplicitFromCommitment = {
+    /**
+     * Zero-based index of the line the commitment was found on, within the scanned lines.
+     */
+    readonly lineIndex: number;
+
+    /**
+     * Trimmed commitment content, empty string for a blank `FROM`.
+     */
+    readonly content: string;
+};
+
+/**
+ * Collects every explicit single-line `FROM` commitment of one book.
+ *
+ * This lightweight parser is intentionally limited to the subset needed by inheritance
+ * resolution so it stays safe to bundle into the Next.js proxy path.
+ *
+ * @param sourceLines - Book source already split into lines.
+ * @returns Found `FROM` commitments in source order, empty when the book declares no parent.
+ *
+ * @private utility of Agents Server inheritance resolution
+ */
+export function collectExplicitFromCommitments(
+    sourceLines: ReadonlyArray<string>,
+): ReadonlyArray<ExplicitFromCommitment> {
+    const explicitFromCommitments: Array<ExplicitFromCommitment> = [];
+    let hasSeenTitle = false;
+    let isInsideCodeBlock = false;
+
+    for (let lineIndex = 0; lineIndex < sourceLines.length; lineIndex++) {
+        const trimmedLine = (sourceLines[lineIndex] || '').trim();
+
+        if (!hasSeenTitle) {
+            if (!trimmedLine) {
+                continue;
+            }
+
+            hasSeenTitle = true;
+            continue;
+        }
+
+        if (trimmedLine.startsWith('```')) {
+            isInsideCodeBlock = !isInsideCodeBlock;
+            continue;
+        }
+
+        if (isInsideCodeBlock) {
+            continue;
+        }
+
+        const fromCommitmentMatch = FROM_COMMITMENT_LINE_PATTERN.exec(trimmedLine);
+        if (fromCommitmentMatch) {
+            explicitFromCommitments.push({
+                lineIndex,
+                content: (fromCommitmentMatch[1] || '').trim(),
+            });
+        }
+    }
+
+    return explicitFromCommitments;
+}
+
+/**
+ * Returns the effective explicit `FROM` commitment of one book.
+ *
+ * A book may repeat `FROM`, in which case the last one wins and overrides every earlier one.
+ *
+ * @param agentSource - Raw book source.
+ * @returns The last explicit `FROM` commitment, or `undefined` when the book declares no parent.
+ *
+ * @private utility of Agents Server inheritance resolution
+ */
+export function getEffectiveExplicitFromCommitment(agentSource: string_book): ExplicitFromCommitment | undefined {
+    const explicitFromCommitments = collectExplicitFromCommitments(agentSource.split(/\r?\n/));
+    return explicitFromCommitments[explicitFromCommitments.length - 1];
+}
+
+/**
+ * Returns the effective explicit `FROM` commitment content of one book.
+ *
+ * A book may repeat `FROM`, in which case the last one wins and overrides every earlier one.
+ *
+ * @param agentSource - Raw book source.
+ * @returns Trimmed commitment content, empty string for a blank explicit `FROM`, or `undefined` when `FROM` is absent.
+ *
+ * @private utility of Agents Server inheritance resolution
+ */
+export function getExplicitFromCommitmentContent(agentSource: string_book): string | undefined {
+    return getEffectiveExplicitFromCommitment(agentSource)?.content;
+}
+
+/**
+ * Returns true when one book declares no parent at all and therefore implicitly inherits from `@Adam`.
+ *
+ * Writing no `FROM` commitment is equivalent to writing `FROM @Adam`, so only an explicit
+ * `FROM @Null` / `FROM {Void}` turns the inheritance off.
+ *
+ * @param agentSource - Raw book source.
+ * @returns True when the implicit `@Adam` ancestor applies to this book.
+ *
+ * @private utility of Agents Server inheritance resolution
+ */
+export function isImplicitAdamInheritance(agentSource: string_book): boolean {
+    return getExplicitFromCommitmentContent(agentSource) === undefined;
+}

package/apps/agents-server/src/utils/getAdminChatTasksResponse/getAdminChatTasks/adminChatTaskSqlQuery.ts

@@ -1,3 +1,4 @@
+import { spaceTrim } from 'spacetrim';
 import type { AdminChatTaskSortField, AdminChatTaskSortOrder, AdminChatTaskView } from '../../chatTasksAdmin';
 import type { ParsedAdminChatTaskQuery } from '../parseAdminChatTaskQuery';
 
@@ -12,7 +13,7 @@ export function createAdminChatTaskBaseQuery(options: {
     userTable: string;
     agentTable: string;
 }): string {
-    return `
+    return spaceTrim(`
         SELECT
             job."id" AS "id",
             'CHAT_COMPLETION'::text AS "kind",
@@ -70,7 +71,7 @@ export function createAdminChatTaskBaseQuery(options: {
         FROM ${options.userChatTimeoutTable} timeout
         LEFT JOIN ${options.userTable} "user" ON "user"."id" = timeout."userId"
         LEFT JOIN ${options.agentTable} agent ON agent."permanentId" = timeout."agentPermanentId"
-    `;
+    `);
 }
 
 /**
@@ -85,19 +86,21 @@ export function createAdminChatTaskListQuery(options: { baseTaskQuery: string; q
     const listQueryParts = createAdminChatTaskListQueryParts(options.query);
 
     return {
-        sql: `
-            WITH tasks AS (
-                ${options.baseTaskQuery}
-            )
-            SELECT
-                task.*,
-                COUNT(*) OVER() AS "totalCount"
-            FROM tasks task
-            ${listQueryParts.whereClause}
-            ORDER BY ${createAdminChatTaskOrderBySql(options.query, 'task')}
-            LIMIT $${listQueryParts.limitPlaceholder}
-            OFFSET $${listQueryParts.offsetPlaceholder}
-        `,
+        sql: spaceTrim(
+            (block) => `
+                WITH tasks AS (
+                    ${block(options.baseTaskQuery)}
+                )
+                SELECT
+                    task.*,
+                    COUNT(*) OVER() AS "totalCount"
+                FROM tasks task
+                ${block(listQueryParts.whereClause)}
+                ORDER BY ${block(createAdminChatTaskOrderBySql(options.query, 'task'))}
+                LIMIT $${listQueryParts.limitPlaceholder}
+                OFFSET $${listQueryParts.offsetPlaceholder}
+            `,
+        ),
         values: listQueryParts.values,
     };
 }
@@ -108,23 +111,25 @@ export function createAdminChatTaskListQuery(options: { baseTaskQuery: string; q
  * @private function of `getAdminChatTasks`
  */
 export function createAdminChatTaskCountersQuery(options: { baseTaskQuery: string }): string {
-    return `
-        WITH tasks AS (
-            ${options.baseTaskQuery}
-        )
-        SELECT
-            COUNT(*) FILTER (WHERE "status" = 'RUNNING') AS "runningCount",
-            COUNT(*) FILTER (WHERE "status" = 'QUEUED') AS "queuedCount",
-            COUNT(*) FILTER (
-                WHERE "status" = 'FAILED'
-                  AND "finishedAt" >= CURRENT_TIMESTAMP - INTERVAL '24 hours'
-            ) AS "failedLast24hCount",
-            CASE
-                WHEN MIN("queuedAt") FILTER (WHERE "status" = 'QUEUED') IS NULL THEN NULL
-                ELSE EXTRACT(EPOCH FROM (CURRENT_TIMESTAMP - MIN("queuedAt") FILTER (WHERE "status" = 'QUEUED'))) * 1000
-            END AS "oldestQueuedAgeMs"
-        FROM tasks
-    `;
+    return spaceTrim(
+        (block) => `
+            WITH tasks AS (
+                ${block(options.baseTaskQuery)}
+            )
+            SELECT
+                COUNT(*) FILTER (WHERE "status" = 'RUNNING') AS "runningCount",
+                COUNT(*) FILTER (WHERE "status" = 'QUEUED') AS "queuedCount",
+                COUNT(*) FILTER (
+                    WHERE "status" = 'FAILED'
+                      AND "finishedAt" >= CURRENT_TIMESTAMP - INTERVAL '24 hours'
+                ) AS "failedLast24hCount",
+                CASE
+                    WHEN MIN("queuedAt") FILTER (WHERE "status" = 'QUEUED') IS NULL THEN NULL
+                    ELSE EXTRACT(EPOCH FROM (CURRENT_TIMESTAMP - MIN("queuedAt") FILTER (WHERE "status" = 'QUEUED'))) * 1000
+                END AS "oldestQueuedAgeMs"
+            FROM tasks
+        `,
+    );
 }
 
 /**
@@ -265,7 +270,7 @@ function createAdminChatTaskDefaultOrderBySql(view: AdminChatTaskView, alias: st
             return `${createAdminChatTaskTimelineExpressionSql(alias)} DESC NULLS LAST, ${alias}."updatedAt" DESC, ${alias}."createdAt" DESC, ${alias}."id" DESC`;
         case 'active':
         default:
-            return `
+            return spaceTrim(`
                 CASE
                     WHEN ${alias}."status" = 'RUNNING' THEN 0
                     WHEN ${alias}."status" = 'QUEUED' THEN 1
@@ -281,7 +286,7 @@ function createAdminChatTaskDefaultOrderBySql(view: AdminChatTaskView, alias: st
                 END DESC NULLS LAST,
                 ${alias}."updatedAt" DESC,
                 ${alias}."id" DESC
-            `;
+            `);
     }
 }
 
@@ -328,13 +333,13 @@ function createAdminChatTaskCustomOrderBySql(
  * @private function of `getAdminChatTasks`
  */
 function createAdminChatTaskTimelineExpressionSql(alias: string): string {
-    return `
+    return spaceTrim(`
         CASE
             WHEN ${alias}."status" = 'RUNNING' THEN COALESCE(${alias}."startedAt", ${alias}."createdAt")
             WHEN ${alias}."status" = 'QUEUED' THEN ${alias}."createdAt"
             ELSE COALESCE(${alias}."finishedAt", ${alias}."updatedAt", ${alias}."createdAt")
         END
-    `;
+    `);
 }
 
 /**

package/apps/agents-server/src/utils/getAdminChatTasksResponse/getAdminChatTasks/loadAdminChatTaskFallbackData.ts

@@ -1,6 +1,4 @@
-import { $getTableName } from '@/src/database/$getTableName';
-import { $provideSupabaseForServer } from '@/src/database/$provideSupabaseForServer';
-import type { AgentsServerDatabase } from '@/src/database/schema';
+import { loadAgentNamesByPermanentId, loadUsernamesByUserId } from '../../adminEntityLookups';
 import { provideUserChatJobTable } from '../../userChat/provideUserChatJobTable';
 import type { UserChatJobStatus } from '../../userChat/UserChatJobRecord';
 import { provideUserChatTimeoutTable } from '../../userChatTimeout/userChatTimeoutStore/provideUserChatTimeoutTable';
@@ -54,23 +52,6 @@ export type AdminChatTaskTimeoutRow = {
     status: UserChatJobStatus;
 };
 
-/**
- * Minimal user lookup row needed by the admin task-manager fallback.
- *
- * @private type of `getAdminChatTasks`
- */
-type AdminChatTaskUserLookupRow = Pick<AgentsServerDatabase['public']['Tables']['User']['Row'], 'id' | 'username'>;
-
-/**
- * Minimal agent lookup row needed by the admin task-manager fallback.
- *
- * @private type of `getAdminChatTasks`
- */
-type AdminChatTaskAgentLookupRow = Pick<
-    AgentsServerDatabase['public']['Tables']['Agent']['Row'],
-    'permanentId' | 'agentName'
->;
-
 /**
  * Raw admin task-manager rows and lookup maps loaded through the Supabase-shaped adapters used by SQLite mode.
  *
@@ -95,8 +76,8 @@ export async function loadAdminChatTaskFallbackData(): Promise<AdminChatTaskFall
         ...new Set([...jobRows, ...timeoutRows].map((task) => task.agentPermanentId).filter(Boolean)),
     ];
     const [usernamesById, agentNamesByPermanentId] = await Promise.all([
-        loadAdminChatTaskUsernames(allUserIds),
-        loadAdminChatTaskAgentNames(allAgentPermanentIds),
+        loadUsernamesByUserId(allUserIds),
+        loadAgentNamesByPermanentId(allAgentPermanentIds),
     ]);
 
     return { jobRows, timeoutRows, usernamesById, agentNamesByPermanentId };
@@ -137,58 +118,3 @@ async function loadAdminChatTaskTimeoutRows(): Promise<Array<AdminChatTaskTimeou
 
     return (data || []) as unknown as Array<AdminChatTaskTimeoutRow>;
 }
-
-/**
- * Loads usernames keyed by user id for admin task rendering and search.
- *
- * @private function of `getAdminChatTasks`
- */
-async function loadAdminChatTaskUsernames(userIds: ReadonlyArray<number>): Promise<Map<number, string>> {
-    if (userIds.length === 0) {
-        return new Map();
-    }
-
-    const supabase = $provideSupabaseForServer();
-    const userTable = await $getTableName('User');
-    const { data, error } = await supabase.from(userTable).select('id,username').in('id', [...new Set(userIds)]);
-
-    if (error) {
-        throw new Error(`Failed to load admin task-manager users: ${error.message}`);
-    }
-
-    return new Map(
-        ((data || []) as Array<AdminChatTaskUserLookupRow>).map((userRow) => [userRow.id, userRow.username] as const),
-    );
-}
-
-/**
- * Loads agent names keyed by permanent id for admin task rendering and search.
- *
- * @private function of `getAdminChatTasks`
- */
-async function loadAdminChatTaskAgentNames(
-    agentPermanentIds: ReadonlyArray<string>,
-): Promise<Map<string, string | null>> {
-    if (agentPermanentIds.length === 0) {
-        return new Map();
-    }
-
-    const supabase = $provideSupabaseForServer();
-    const agentTable = await $getTableName('Agent');
-    const { data, error } = await supabase
-        .from(agentTable)
-        .select('permanentId,agentName')
-        .in('permanentId', [...new Set(agentPermanentIds)]);
-
-    if (error) {
-        throw new Error(`Failed to load admin task-manager agents: ${error.message}`);
-    }
-
-    return new Map(
-        ((data || []) as Array<AdminChatTaskAgentLookupRow>)
-            .filter((agentRow): agentRow is AdminChatTaskAgentLookupRow & { permanentId: string } =>
-                Boolean(agentRow.permanentId),
-            )
-            .map((agentRow) => [agentRow.permanentId, agentRow.agentName] as const),
-    );
-}

package/apps/agents-server/src/utils/getAdminChatTasksResponse/getAdminChatTasks/mapAdminChatTaskFallbackRows.ts

@@ -1,3 +1,4 @@
+import { isAgentGoalChatId } from '../../agentGoalChat/agentGoalChatIdentity';
 import type { AdminChatTaskRecord } from '../../chatTasksAdmin';
 import { getUserChatJobRunReportFromParameters } from '../../userChat/userChatJobRunReport';
 import { resolveNullableSqlNumber } from './adminChatTaskSqlValues';
@@ -57,6 +58,7 @@ function mapAdminChatTaskJobRow(
         chatId: row.chatId,
         workerId: null,
         queueName: 'user-chat-jobs',
+        isAgentGoalTask: isAgentGoalChatId(row.chatId),
         runReport: getUserChatJobRunReportFromParameters(row.parameters),
     };
 }
@@ -97,5 +99,6 @@ function mapAdminChatTaskTimeoutRow(
         chatId: row.chatId,
         workerId: null,
         queueName: 'user-chat-timeouts',
+        isAgentGoalTask: isAgentGoalChatId(row.chatId),
     };
 }

package/apps/agents-server/src/utils/getAdminChatTasksResponse/getAdminChatTasks/mapAdminChatTaskSqlRows.ts

@@ -1,3 +1,4 @@
+import { isAgentGoalChatId } from '../../agentGoalChat/agentGoalChatIdentity';
 import type { AdminChatTaskCounters, AdminChatTaskRecord } from '../../chatTasksAdmin';
 import type { UserChatJobStatus } from '../../userChat/UserChatJobRecord';
 import { getUserChatJobRunReportFromParameters } from '../../userChat/userChatJobRunReport';
@@ -79,6 +80,7 @@ export function mapAdminChatTaskSqlRow(row: AdminChatTaskSqlRow): AdminChatTaskR
         chatId: row.chatId,
         workerId: null,
         queueName: row.queueName,
+        isAgentGoalTask: isAgentGoalChatId(row.chatId),
         runReport: getUserChatJobRunReportFromParameters(row.parameters),
     };
 }