@promptbook/cli 0.113.0-9 → 0.114.0-0

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

@@ -1,13 +1,69 @@
-import type { AdminChatTaskRecord, AdminChatTaskView } from '../../chatTasksAdmin';
+import type {
+    AdminChatTaskRecord,
+    AdminChatTaskSortField,
+    AdminChatTaskSortOrder,
+    AdminChatTaskView,
+} from '../../chatTasksAdmin';
 import type { UserChatJobStatus } from '../../userChat/UserChatJobRecord';
 import { parseIsoTimestamp } from './adminChatTaskTimeUtilities';
 
+/**
+ * Collator used for user-facing task-manager text sorting.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+const ADMIN_CHAT_TASK_STRING_COLLATOR = new Intl.Collator(undefined, {
+    numeric: true,
+    sensitivity: 'base',
+});
+
+/**
+ * Query fields needed for task-manager row comparison.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+type AdminChatTaskSortQuery = {
+    readonly sortBy: AdminChatTaskSortField;
+    readonly sortOrder: AdminChatTaskSortOrder;
+    readonly view: AdminChatTaskView;
+};
+
+/**
+ * Comparable value used by custom task-manager table sorting.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+type AdminChatTaskSortValue = string | number | null;
+
 /**
  * Compares two tasks using the same ordering semantics as the PostgreSQL dashboard query.
  *
  * @private function of `getAdminChatTasks`
  */
 export function compareAdminChatTasks(
+    leftTask: AdminChatTaskRecord,
+    rightTask: AdminChatTaskRecord,
+    query: AdminChatTaskSortQuery,
+): number {
+    if (query.sortBy !== 'default') {
+        return (
+            compareAdminChatTaskSortValues(
+                resolveAdminChatTaskSortValue(leftTask, query.sortBy),
+                resolveAdminChatTaskSortValue(rightTask, query.sortBy),
+                query.sortOrder,
+            ) || compareAdminChatTasksByDefaultView(leftTask, rightTask, query.view)
+        );
+    }
+
+    return compareAdminChatTasksByDefaultView(leftTask, rightTask, query.view);
+}
+
+/**
+ * Compares two tasks using the view-specific operational default order.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+function compareAdminChatTasksByDefaultView(
     leftTask: AdminChatTaskRecord,
     rightTask: AdminChatTaskRecord,
     view: AdminChatTaskView,
@@ -31,7 +87,14 @@ export function compareAdminChatTasks(
                 compareStringsDescending(leftTask.id, rightTask.id)
             );
         case 'all':
+            // The `All` history view is ordered by finished time so the newest finished task is on top;
+            // the shared timeline timestamp resolves to `finishedAt` for terminal tasks while keeping
+            // still-active tasks placed by their start/queue time instead of dropping them to the bottom.
             return (
+                compareNullableNumbersDescending(
+                    resolveAdminChatTaskTimelineTimestamp(leftTask),
+                    resolveAdminChatTaskTimelineTimestamp(rightTask),
+                ) ||
                 compareIsoTimestampsDescending(leftTask.updatedAt, rightTask.updatedAt) ||
                 compareIsoTimestampsDescending(leftTask.createdAt, rightTask.createdAt) ||
                 compareStringsDescending(leftTask.id, rightTask.id)
@@ -57,6 +120,96 @@ export function compareAdminChatTasks(
     }
 }
 
+/**
+ * Resolves the custom sort value for one task-manager row.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+function resolveAdminChatTaskSortValue(
+    task: AdminChatTaskRecord,
+    sortBy: Exclude<AdminChatTaskSortField, 'default'>,
+): AdminChatTaskSortValue {
+    switch (sortBy) {
+        case 'task':
+            return task.id;
+        case 'ownership':
+            return [task.username || `#${task.userId}`, task.agentName || task.agentPermanentId, task.chatId].join(' ');
+        case 'timeline':
+            return resolveAdminChatTaskTimelineTimestamp(task);
+        case 'duration':
+            return resolveAdminChatTaskDurationMs(task);
+        case 'queue':
+            return [task.queueName || '', task.workerId || '', task.leaseExpiresAt || ''].join(' ');
+        case 'lastError':
+            return task.lastErrorSummary;
+    }
+}
+
+/**
+ * Resolves the primary timeline timestamp used by the visible task timeline column.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+function resolveAdminChatTaskTimelineTimestamp(task: AdminChatTaskRecord): number | null {
+    if (task.status === 'RUNNING') {
+        return parseIsoTimestamp(task.startedAt) ?? parseIsoTimestamp(task.createdAt);
+    }
+
+    if (task.status === 'QUEUED') {
+        return parseIsoTimestamp(task.createdAt);
+    }
+
+    return parseIsoTimestamp(task.finishedAt) ?? parseIsoTimestamp(task.updatedAt) ?? parseIsoTimestamp(task.createdAt);
+}
+
+/**
+ * Resolves the total task duration in milliseconds.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+function resolveAdminChatTaskDurationMs(task: AdminChatTaskRecord): number | null {
+    const createdTimestamp = parseIsoTimestamp(task.createdAt);
+    if (createdTimestamp === null) {
+        return null;
+    }
+
+    const endTimestamp =
+        parseIsoTimestamp(task.finishedAt) ?? parseIsoTimestamp(task.updatedAt) ?? Date.now();
+
+    return Math.max(0, endTimestamp - createdTimestamp);
+}
+
+/**
+ * Compares custom task-manager sort values while keeping missing values last.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+function compareAdminChatTaskSortValues(
+    leftValue: AdminChatTaskSortValue,
+    rightValue: AdminChatTaskSortValue,
+    sortOrder: AdminChatTaskSortOrder,
+): number {
+    const isLeftValueMissing = leftValue === null || leftValue === '';
+    const isRightValueMissing = rightValue === null || rightValue === '';
+
+    if (isLeftValueMissing && isRightValueMissing) {
+        return 0;
+    }
+    if (isLeftValueMissing) {
+        return 1;
+    }
+    if (isRightValueMissing) {
+        return -1;
+    }
+
+    const comparison =
+        typeof leftValue === 'number' && typeof rightValue === 'number'
+            ? compareNumbersAscending(leftValue, rightValue)
+            : compareStringsAscending(String(leftValue), String(rightValue));
+
+    return sortOrder === 'asc' ? comparison : -comparison;
+}
+
 /**
  * Resolves the status sort bucket used by the `Active` dashboard view.
  *
@@ -82,20 +235,26 @@ function compareNullableIsoTimestampsDescending(
     leftTimestampIso: string | null,
     rightTimestampIso: string | null,
 ): number {
-    const leftTimestamp = parseIsoTimestamp(leftTimestampIso);
-    const rightTimestamp = parseIsoTimestamp(rightTimestampIso);
+    return compareNullableNumbersDescending(parseIsoTimestamp(leftTimestampIso), parseIsoTimestamp(rightTimestampIso));
+}
 
-    if (leftTimestamp === rightTimestamp) {
+/**
+ * Sorts nullable numbers descending while keeping `null` values last.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+function compareNullableNumbersDescending(leftNumber: number | null, rightNumber: number | null): number {
+    if (leftNumber === rightNumber) {
         return 0;
     }
-    if (leftTimestamp === null) {
+    if (leftNumber === null) {
         return 1;
     }
-    if (rightTimestamp === null) {
+    if (rightNumber === null) {
         return -1;
     }
 
-    return compareNumbersDescending(leftTimestamp, rightTimestamp);
+    return compareNumbersDescending(leftNumber, rightNumber);
 }
 
 /**
@@ -125,6 +284,15 @@ function compareNumbersDescending(leftNumber: number, rightNumber: number): numb
     return rightNumber - leftNumber;
 }
 
+/**
+ * Sorts strings ascending.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+function compareStringsAscending(leftString: string, rightString: string): number {
+    return ADMIN_CHAT_TASK_STRING_COLLATOR.compare(leftString, rightString);
+}
+
 /**
  * Sorts strings descending.
  *

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

@@ -17,7 +17,7 @@ export async function getAdminChatTasksViaSupabaseQuery(
     const allTasks = mapAdminChatTaskFallbackRows(await loadAdminChatTaskFallbackData());
     const nowTimestamp = Date.now();
     const filteredTasks = filterAdminChatTasks(allTasks, query, nowTimestamp).sort((leftTask, rightTask) =>
-        compareAdminChatTasks(leftTask, rightTask, query.view),
+        compareAdminChatTasks(leftTask, rightTask, query),
     );
     const pageOffset = (query.page - 1) * query.pageSize;
 

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

@@ -27,6 +27,7 @@ export type AdminChatTaskJobRow = {
     agentPermanentId: string;
     chatId: string;
     status: UserChatJobStatus;
+    parameters?: unknown;
 };
 
 /**
@@ -109,7 +110,7 @@ export async function loadAdminChatTaskFallbackData(): Promise<AdminChatTaskFall
 async function loadAdminChatTaskJobRows(): Promise<Array<AdminChatTaskJobRow>> {
     const userChatJobTable = await provideUserChatJobTable();
     const { data, error } = await userChatJobTable.select(
-        'id,createdAt,queuedAt,startedAt,updatedAt,completedAt,cancelRequestedAt,lastHeartbeatAt,leaseExpiresAt,attemptCount,failureReason,failureDetails,userId,agentPermanentId,chatId,status',
+        'id,createdAt,queuedAt,startedAt,updatedAt,completedAt,cancelRequestedAt,lastHeartbeatAt,leaseExpiresAt,attemptCount,failureReason,failureDetails,userId,agentPermanentId,chatId,status,parameters',
     );
 
     if (error) {

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

@@ -1,4 +1,5 @@
 import type { AdminChatTaskRecord } from '../../chatTasksAdmin';
+import { getUserChatJobRunReportFromParameters } from '../../userChat/userChatJobRunReport';
 import { resolveNullableSqlNumber } from './adminChatTaskSqlValues';
 import type {
     AdminChatTaskFallbackData,
@@ -56,6 +57,7 @@ function mapAdminChatTaskJobRow(
         chatId: row.chatId,
         workerId: null,
         queueName: 'user-chat-jobs',
+        runReport: getUserChatJobRunReportFromParameters(row.parameters),
     };
 }
 

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

@@ -1,5 +1,6 @@
 import type { AdminChatTaskCounters, AdminChatTaskRecord } from '../../chatTasksAdmin';
 import type { UserChatJobStatus } from '../../userChat/UserChatJobRecord';
+import { getUserChatJobRunReportFromParameters } from '../../userChat/userChatJobRunReport';
 import { resolveNullableSqlNumber, resolveSqlCount } from './adminChatTaskSqlValues';
 
 /**
@@ -29,6 +30,8 @@ export type AdminChatTaskSqlRow = {
     agentPermanentId: string;
     agentName: string | null;
     chatId: string;
+    queueName: string | null;
+    parameters: unknown;
     totalCount: string | number;
 };
 
@@ -75,7 +78,8 @@ export function mapAdminChatTaskSqlRow(row: AdminChatTaskSqlRow): AdminChatTaskR
         agentName: row.agentName,
         chatId: row.chatId,
         workerId: null,
-        queueName: row.kind === 'CHAT_TIMEOUT' ? 'user-chat-timeouts' : 'user-chat-jobs',
+        queueName: row.queueName,
+        runReport: getUserChatJobRunReportFromParameters(row.parameters),
     };
 }
 

package/apps/agents-server/src/utils/getAdminChatTasksResponse/mapVpsSelfUpdateJobToAdminChatTask.ts

@@ -1,3 +1,4 @@
+import { buildVpsSelfUpdateAdminChatTaskId, VPS_SELF_UPDATE_ADMIN_CHAT_TASK_ID_PREFIX } from '../adminChatTaskLinks';
 import type { AdminChatTaskRecord } from '../chatTasksAdmin';
 import type { UserChatJobStatus } from '../userChat/UserChatJobRecord';
 import type { VpsSelfUpdateJobSnapshot } from '../vpsSelfUpdate';
@@ -6,9 +7,12 @@ import { resolveVpsSelfUpdateJobIdentity } from '../vpsSelfUpdate/vpsSelfUpdateJ
 /**
  * Stable synthetic task id prefix used for standalone VPS self-update task rows.
  *
+ * Kept for backward compatibility; the value is single-sourced from the browser-safe
+ * `VPS_SELF_UPDATE_ADMIN_CHAT_TASK_ID_PREFIX` shared with the update page.
+ *
  * @private internal admin utility of Agents Server
  */
-export const VPS_SELF_UPDATE_ADMIN_CHAT_TASK_ID = 'vps-self-update';
+export const VPS_SELF_UPDATE_ADMIN_CHAT_TASK_ID = VPS_SELF_UPDATE_ADMIN_CHAT_TASK_ID_PREFIX;
 
 /**
  * Synthetic queue name used for the standalone VPS self-update task row.
@@ -31,12 +35,14 @@ export function mapVpsSelfUpdateJobToAdminChatTask(job: VpsSelfUpdateJobSnapshot
 
     const isTerminalStatus = status === 'COMPLETED' || status === 'FAILED';
     const startedAt = job.startedAt;
-    const finishedAt = isTerminalStatus ? job.finishedAt || startedAt : null;
+    // Report the real recorded finish time only; falling back to `startedAt` would render a
+    // misleading zero-second total duration for a self-update whose finish time is unknown.
+    const finishedAt = isTerminalStatus ? job.finishedAt : null;
     const updatedAt = finishedAt || startedAt || new Date().toISOString();
     const errorSummary = job.errorMessage || null;
     const currentStepDetails = job.currentStep || null;
     const triggerLabel = formatVpsSelfUpdateTrigger(job.trigger);
-    const taskId = `${VPS_SELF_UPDATE_ADMIN_CHAT_TASK_ID}:${resolveVpsSelfUpdateJobIdentity(job)}`;
+    const taskId = buildVpsSelfUpdateAdminChatTaskId(resolveVpsSelfUpdateJobIdentity(job));
 
     return {
         id: taskId,

package/apps/agents-server/src/utils/getAdminChatTasksResponse/parseAdminChatTaskQuery.ts

@@ -1,4 +1,4 @@
-import type { AdminChatTaskView } from '../chatTasksAdmin';
+import type { AdminChatTaskSortField, AdminChatTaskSortOrder, AdminChatTaskView } from '../chatTasksAdmin';
 
 /**
  * Default number of task rows returned per page.
@@ -38,6 +38,8 @@ export type ParsedAdminChatTaskQuery = {
     pageSize: number;
     view: AdminChatTaskView;
     search: string;
+    sortBy: AdminChatTaskSortField;
+    sortOrder: AdminChatTaskSortOrder;
     timeWindowHours: number;
 };
 
@@ -60,6 +62,8 @@ export function parseAdminChatTaskQuery(searchParams: URLSearchParams): ParsedAd
         ),
         view,
         search: searchParams.get('search')?.trim() || '',
+        sortBy: parseAdminChatTaskSortField(searchParams.get('sortBy')),
+        sortOrder: parseAdminChatTaskSortOrder(searchParams.get('sortOrder')),
         timeWindowHours: parsePositiveInteger(
             searchParams.get('timeWindowHours'),
             DEFAULT_ADMIN_CHAT_TASK_TIME_WINDOW_HOURS,
@@ -68,6 +72,35 @@ export function parseAdminChatTaskQuery(searchParams: URLSearchParams): ParsedAd
     };
 }
 
+/**
+ * Parses the requested admin task-manager sort field.
+ *
+ * @private function of `getAdminChatTasksResponse`
+ */
+function parseAdminChatTaskSortField(value: string | null): AdminChatTaskSortField {
+    if (
+        value === 'task' ||
+        value === 'ownership' ||
+        value === 'timeline' ||
+        value === 'duration' ||
+        value === 'queue' ||
+        value === 'lastError'
+    ) {
+        return value;
+    }
+
+    return 'default';
+}
+
+/**
+ * Parses the requested admin task-manager sort order.
+ *
+ * @private function of `getAdminChatTasksResponse`
+ */
+function parseAdminChatTaskSortOrder(value: string | null): AdminChatTaskSortOrder {
+    return value === 'asc' ? 'asc' : 'desc';
+}
+
 /**
  * Parses one positive integer query parameter with fallback and upper bound.
  *

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

@@ -1,19 +1,15 @@
 import { ensureUserChatTimeoutWorkerBootstrapped } from '@/src/utils/userChatTimeout/ensureUserChatTimeoutWorkerBootstrapped';
-import type { AdminChatTaskCounters, AdminChatTaskListResponse, AdminChatTaskRecord } from './chatTasksAdmin';
+import type { AdminChatTaskListResponse } from './chatTasksAdmin';
+import {
+    collectAdminChatTasksToInject,
+    createInjectedAwareAdminChatTaskQuery,
+    loadInjectableAdminChatTasks,
+    mergeInjectedAdminChatTaskCounters,
+    mergeInjectedAdminChatTasks,
+} from './getAdminChatTasksResponse/adminChatTaskInjection';
 import { getAdminChatTasks } from './getAdminChatTasksResponse/getAdminChatTasks';
-import { compareAdminChatTasks } from './getAdminChatTasksResponse/getAdminChatTasks/compareAdminChatTasks';
-import { mapVpsSelfUpdateJobToAdminChatTask } from './getAdminChatTasksResponse/mapVpsSelfUpdateJobToAdminChatTask';
-import { parseAdminChatTaskQuery, type ParsedAdminChatTaskQuery } from './getAdminChatTasksResponse/parseAdminChatTaskQuery';
+import { parseAdminChatTaskQuery } from './getAdminChatTasksResponse/parseAdminChatTaskQuery';
 import { throttledAdminRecovery } from './getAdminChatTasksResponse/throttledAdminRecovery';
-import { listPagePreviewBrowserAdminTasks } from './pagePreviewBrowserSessions';
-import { readVpsSelfUpdateJobTaskSnapshots } from './vpsSelfUpdate';
-
-/**
- * Milliseconds in one hour.
- *
- * @private internal constant of `getAdminChatTasksResponse`
- */
-const HOUR_IN_MILLISECONDS = 60 * 60 * 1000;
 
 /**
  * Successful task-manager response envelope.
@@ -45,6 +41,10 @@ export type GetAdminChatTasksResponseResult = GetAdminChatTasksResponseSuccess |
 /**
  * Builds the paginated admin task-manager payload from live durable worker state.
  *
+ * This is the per-server view: it reports durable jobs for the current request's server plus the
+ * process-local VPS tasks injected on top. The VPS-wide superadmin view lives in
+ * `getVpsAdminChatTasksResponse`.
+ *
  * @private internal admin utility of Agents Server
  */
 export async function getAdminChatTasksResponse(
@@ -63,9 +63,7 @@ export async function getAdminChatTasksResponse(
     // [🧠] Recovery operations are throttled to avoid hammering the DB on every admin poll
     await throttledAdminRecovery();
 
-    const vpsSelfUpdateTasks = await loadVpsSelfUpdateAdminChatTasks();
-    const pagePreviewBrowserTasks = listPagePreviewBrowserAdminTasks();
-    const injectableTasks = [...vpsSelfUpdateTasks, ...pagePreviewBrowserTasks];
+    const injectableTasks = await loadInjectableAdminChatTasks();
     const injectedTasks = collectAdminChatTasksToInject(injectableTasks, parsedQuery);
     const databaseQuery = createInjectedAwareAdminChatTaskQuery(parsedQuery, injectedTasks.length);
     const adminChatTasks = await getAdminChatTasks(databaseQuery);
@@ -75,6 +73,7 @@ export async function getAdminChatTasksResponse(
         injectedTasks,
         page: parsedQuery.page,
         pageSize: parsedQuery.pageSize,
+        query: parsedQuery,
     });
     const counters = mergeInjectedAdminChatTaskCounters(adminChatTasks.counters, injectableTasks);
 
@@ -88,236 +87,10 @@ export async function getAdminChatTasksResponse(
             pageSize: parsedQuery.pageSize,
             view: parsedQuery.view,
             search: parsedQuery.search,
+            sortBy: parsedQuery.sortBy,
+            sortOrder: parsedQuery.sortOrder,
             timeWindowHours: parsedQuery.timeWindowHours,
             generatedAt: new Date().toISOString(),
         },
     };
 }
-
-/**
- * Loads persisted standalone VPS self-update tasks, if any.
- *
- * The read is defensive so a corrupt status file cannot block the admin task manager from rendering.
- *
- * @returns Injectable task records.
- */
-async function loadVpsSelfUpdateAdminChatTasks(): Promise<Array<AdminChatTaskRecord>> {
-    try {
-        const jobSnapshots = await readVpsSelfUpdateJobTaskSnapshots();
-        return jobSnapshots
-            .map(mapVpsSelfUpdateJobToAdminChatTask)
-            .filter((task): task is AdminChatTaskRecord => task !== null);
-    } catch (error) {
-        console.error('[admin-chat-task] failed to load VPS self-update task snapshots', error);
-        return [];
-    }
-}
-
-/**
- * Filters out injected tasks that do not belong to the requested admin task-manager view or search.
- *
- * @param injectableTasks - Synthetic task rows collected from process-local state.
- * @param query - Parsed admin task-manager query.
- * @returns Tasks to inject on top of the database-backed items.
- */
-function collectAdminChatTasksToInject(
-    injectableTasks: ReadonlyArray<AdminChatTaskRecord>,
-    query: ParsedAdminChatTaskQuery,
-): ReadonlyArray<AdminChatTaskRecord> {
-    const nowTimestamp = Date.now();
-    return injectableTasks
-        .filter(
-            (task) =>
-                matchesAdminChatTaskView(task, query, nowTimestamp) &&
-                matchesAdminChatTaskSearch(task, query.search),
-        )
-        .sort((leftTask, rightTask) => compareAdminChatTasks(leftTask, rightTask, query.view));
-}
-
-/**
- * Builds the database query needed to merge injected task rows into the requested page.
- *
- * @param query - Parsed admin task-manager query.
- * @param injectedTaskCount - Number of injected rows that appear before database-backed rows.
- * @returns Query used for loading enough database-backed rows to fill the final page.
- */
-function createInjectedAwareAdminChatTaskQuery(
-    query: ParsedAdminChatTaskQuery,
-    injectedTaskCount: number,
-): ParsedAdminChatTaskQuery {
-    if (injectedTaskCount === 0) {
-        return query;
-    }
-
-    const pageOffset = (query.page - 1) * query.pageSize;
-    const databaseEndOffset = Math.max(0, pageOffset + query.pageSize - injectedTaskCount);
-
-    return {
-        ...query,
-        page: 1,
-        pageSize: Math.max(1, databaseEndOffset),
-    };
-}
-
-/**
- * Prepends injected task rows to the database-backed items and returns the requested combined page.
- *
- * @param options - Merge inputs.
- * @returns Merged items for the current page and the updated total row count.
- */
-function mergeInjectedAdminChatTasks(options: {
-    readonly databaseItems: ReadonlyArray<AdminChatTaskRecord>;
-    readonly databaseTotal: number;
-    readonly injectedTasks: ReadonlyArray<AdminChatTaskRecord>;
-    readonly page: number;
-    readonly pageSize: number;
-}): { items: Array<AdminChatTaskRecord>; total: number } {
-    const total = options.databaseTotal + options.injectedTasks.length;
-    if (options.injectedTasks.length === 0) {
-        return { items: [...options.databaseItems], total };
-    }
-
-    const pageOffset = (options.page - 1) * options.pageSize;
-    const injectedItems = options.injectedTasks.slice(pageOffset, pageOffset + options.pageSize);
-    const remainingPageSize = options.pageSize - injectedItems.length;
-
-    if (remainingPageSize <= 0) {
-        return { items: [...injectedItems], total };
-    }
-
-    const databaseOffset = Math.max(0, pageOffset - options.injectedTasks.length);
-    const databaseItems = options.databaseItems.slice(databaseOffset, databaseOffset + remainingPageSize);
-    const items = [...injectedItems, ...databaseItems];
-    return { items, total };
-}
-
-/**
- * Adds injected tasks to the summary counters so the header metrics stay accurate.
- *
- * @param databaseCounters - Counters computed from durable database rows.
- * @param injectedTasks - Synthetic task rows collected from process-local state.
- * @returns Merged counters including the injected tasks.
- */
-function mergeInjectedAdminChatTaskCounters(
-    databaseCounters: AdminChatTaskCounters,
-    injectedTasks: ReadonlyArray<AdminChatTaskRecord>,
-): AdminChatTaskCounters {
-    if (injectedTasks.length === 0) {
-        return databaseCounters;
-    }
-
-    const nowTimestamp = Date.now();
-    const injectedQueuedTimestamps = injectedTasks
-        .filter((task) => task.status === 'QUEUED')
-        .map((task) => Date.parse(task.queuedAt))
-        .filter((timestamp) => Number.isFinite(timestamp));
-    const oldestInjectedQueuedAgeMs =
-        injectedQueuedTimestamps.length === 0 ? null : nowTimestamp - Math.min(...injectedQueuedTimestamps);
-
-    return {
-        runningCount: databaseCounters.runningCount + injectedTasks.filter((task) => task.status === 'RUNNING').length,
-        queuedCount: databaseCounters.queuedCount + injectedTasks.filter((task) => task.status === 'QUEUED').length,
-        failedLast24hCount:
-            databaseCounters.failedLast24hCount +
-            injectedTasks.filter(
-                (task) =>
-                    task.status === 'FAILED' &&
-                    isIsoTimestampAtOrAfter(task.finishedAt, nowTimestamp - 24 * HOUR_IN_MILLISECONDS),
-            ).length,
-        oldestQueuedAgeMs: mergeOldestQueuedAge(databaseCounters.oldestQueuedAgeMs, oldestInjectedQueuedAgeMs),
-    };
-}
-
-/**
- * Merges durable and injected queued-task ages.
- *
- * @param databaseOldestQueuedAgeMs - Oldest durable queued-task age.
- * @param injectedOldestQueuedAgeMs - Oldest injected queued-task age.
- * @returns Oldest queued age across both sources.
- */
-function mergeOldestQueuedAge(
-    databaseOldestQueuedAgeMs: number | null,
-    injectedOldestQueuedAgeMs: number | null,
-): number | null {
-    if (databaseOldestQueuedAgeMs === null) {
-        return injectedOldestQueuedAgeMs;
-    }
-
-    if (injectedOldestQueuedAgeMs === null) {
-        return databaseOldestQueuedAgeMs;
-    }
-
-    return Math.max(databaseOldestQueuedAgeMs, injectedOldestQueuedAgeMs);
-}
-
-/**
- * Returns whether the injected task belongs in the requested admin task-manager view.
- *
- * @param task - Injected task.
- * @param query - Parsed admin task-manager query.
- * @param nowTimestamp - Current epoch used for time-window filtering.
- * @returns `true` when the task should be included.
- */
-function matchesAdminChatTaskView(
-    task: AdminChatTaskRecord,
-    query: ParsedAdminChatTaskQuery,
-    nowTimestamp: number,
-): boolean {
-    switch (query.view) {
-        case 'running':
-            return task.status === 'RUNNING';
-        case 'queued':
-            return task.status === 'QUEUED';
-        case 'failed':
-            return (
-                task.status === 'FAILED' &&
-                isIsoTimestampAtOrAfter(task.finishedAt, nowTimestamp - 24 * HOUR_IN_MILLISECONDS)
-            );
-        case 'all':
-            return isIsoTimestampAtOrAfter(task.updatedAt, nowTimestamp - query.timeWindowHours * HOUR_IN_MILLISECONDS);
-        case 'active':
-        default:
-            return task.status === 'QUEUED' || task.status === 'RUNNING';
-    }
-}
-
-/**
- * Returns whether the injected task matches the free-text admin search input.
- *
- * @param task - Injected task.
- * @param search - Trimmed search text from the parsed query.
- * @returns `true` when the task should be included.
- */
-function matchesAdminChatTaskSearch(task: AdminChatTaskRecord, search: string): boolean {
-    if (!search) {
-        return true;
-    }
-
-    const normalizedSearch = search.toLowerCase();
-    if (task.id.toLowerCase().includes(normalizedSearch)) {
-        return true;
-    }
-    if (task.agentPermanentId.toLowerCase().includes(normalizedSearch)) {
-        return true;
-    }
-    if ((task.agentName || '').toLowerCase().includes(normalizedSearch)) {
-        return true;
-    }
-    return task.chatId.toLowerCase().includes(normalizedSearch);
-}
-
-/**
- * Returns whether one ISO timestamp is at or after the given cutoff.
- *
- * @param timestampIso - Optional ISO timestamp.
- * @param cutoffTimestamp - Epoch cutoff in milliseconds.
- * @returns `true` when the timestamp is at or after the cutoff.
- */
-function isIsoTimestampAtOrAfter(timestampIso: string | null, cutoffTimestamp: number): boolean {
-    if (!timestampIso) {
-        return false;
-    }
-
-    const timestamp = Date.parse(timestampIso);
-    return Number.isFinite(timestamp) && timestamp >= cutoffTimestamp;
-}