@agent-native/core 0.187.0-nightly-20260924172231 → 0.187.0

package/corpus/README.md

@@ -31,4 +31,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- template files: 9884
+- template files: 9886

package/corpus/templates/analytics/CHANGELOG.md

@@ -3,10 +3,21 @@
 All notable user-facing changes to Agent-Native Analytics are documented here. Open it any
 time from the command menu (Cmd+K → "What's new") or from Settings.
 
+## 2026-09-24
+
+### Improved
+
+- The Sessions list hides 0m recordings by default, with a filter to include them.
+
+### Fixed
+
+- Session recordings no longer cut off partway through when the daily recording budget runs low; new recordings wait for room instead.
+
 ## 2026-09-23
 
 ### Improved
 
+- Transient HTTP 5xx checks now need confirmation before alerting
 - Analytics opens faster by loading translation catalogs and rarely used surfaces only when needed.
 
 ## 2026-09-22

package/corpus/templates/analytics/app/i18n/en-US.ts

@@ -1389,6 +1389,7 @@ export default {
     app: "App",
     unknownApp: "Unknown app",
     lastSeen: "Last seen",
+    includeZeroMinuteSessions: "Include 0m sessions",
     duration: "Duration",
     events: "Events",
     chunks: "Chunks",

package/corpus/templates/analytics/app/pages/sessions/SessionsPage.tsx

@@ -29,6 +29,7 @@ import { toast } from "sonner";
 import { Badge } from "@/components/ui/badge";
 import { Button } from "@/components/ui/button";
 import { Card, CardContent } from "@/components/ui/card";
+import { Checkbox } from "@/components/ui/checkbox";
 import {
   Collapsible,
   CollapsibleContent,
@@ -170,8 +171,19 @@ type SessionRecordingIdentity = Pick<
 type SessionRecordingDevice = Pick<SessionRecordingSummary, "metadata">;
 
 const RANGE_OPTIONS: ReplayRange[] = ["24h", "7d", "30d", "90d", "all"];
+const MIN_DURATION_FOR_ONE_MINUTE_LABEL_MS = 59_500;
 const SESSION_QUERY_DEBOUNCE_MS = 250;
 
+export function shouldShowZeroMinuteRecoveryAction(
+  includeZeroMinuteSessions: boolean,
+  filteredCount: number,
+  unfilteredCount: number,
+): boolean {
+  return (
+    !includeZeroMinuteSessions && filteredCount === 0 && unfilteredCount > 0
+  );
+}
+
 /**
  * Local input state for a URL-backed filter, debounced into the URL.
  *
@@ -212,6 +224,8 @@ export default function SessionsPage() {
   const range = readRange(searchParams.get("range"));
   const app = searchParams.get("app") ?? "";
   const query = searchParams.get("q") ?? "";
+  const includeZeroMinuteSessions =
+    searchParams.get("includeZeroMinuteSessions") === "true";
   const from = useMemo(() => rangeToFrom(range), [range]);
 
   const updateFilter = useCallback(
@@ -243,21 +257,55 @@ export default function SessionsPage() {
   );
   const [appInput, setAppInput] = useDebouncedUrlFilter(app, commitApp);
 
+  const sessionListFilters = {
+    from: from ?? undefined,
+    app: app || undefined,
+    query: query || undefined,
+  };
   const { data, isLoading, isFetching, refetch, error } = useActionQuery<
     SessionRecordingSummary[]
   >(
     "list-session-recordings",
     {
-      from: from ?? undefined,
-      app: app || undefined,
-      query: query || undefined,
+      ...sessionListFilters,
+      minDurationMs: includeZeroMinuteSessions
+        ? undefined
+        : MIN_DURATION_FOR_ONE_MINUTE_LABEL_MS,
       limit: 100,
     },
     { staleTime: 30_000 },
   );
 
   const recordings = data ?? [];
-  const popoverFiltered = range !== "30d" || app !== "";
+  const shouldCheckForHiddenSessions =
+    !includeZeroMinuteSessions &&
+    !isLoading &&
+    !error &&
+    recordings.length === 0;
+  const {
+    data: unfilteredRecordings,
+    isLoading: isCheckingForHiddenSessions,
+    isFetching: isFetchingHiddenSessions,
+    error: hiddenSessionsError,
+    refetch: refetchHiddenSessions,
+  } = useActionQuery<SessionRecordingSummary[]>(
+    "list-session-recordings",
+    { ...sessionListFilters, limit: 1 },
+    { enabled: shouldCheckForHiddenSessions, staleTime: 30_000 },
+  );
+  const showZeroMinuteRecoveryAction = shouldShowZeroMinuteRecoveryAction(
+    includeZeroMinuteSessions,
+    recordings.length,
+    unfilteredRecordings?.length ?? 0,
+  );
+  const loadError =
+    error ?? (shouldCheckForHiddenSessions ? hiddenSessionsError : null);
+  const isCheckingEmptyState =
+    shouldCheckForHiddenSessions && isCheckingForHiddenSessions;
+  const isRefreshing =
+    isFetching || (shouldCheckForHiddenSessions && isFetchingHiddenSessions);
+  const popoverFiltered =
+    range !== "30d" || app !== "" || includeZeroMinuteSessions;
 
   return (
     <div className="analytics-sessions-page mx-auto flex w-full max-w-7xl flex-col gap-4 px-4 py-5">
@@ -328,6 +376,18 @@ export default function SessionsPage() {
                       </SelectContent>
                     </Select>
                   </div>
+                  <label className="flex cursor-pointer items-center gap-2 border-t pt-3 text-sm">
+                    <Checkbox
+                      checked={includeZeroMinuteSessions}
+                      onCheckedChange={(checked) =>
+                        updateFilter(
+                          "includeZeroMinuteSessions",
+                          checked === true ? "true" : "",
+                        )
+                      }
+                    />
+                    {t("sessions.includeZeroMinuteSessions")}
+                  </label>
                   <div className="grid gap-1.5 border-t pt-3">
                     <div className="text-xs font-medium text-muted-foreground">
                       {t("sessions.userFilters")}
@@ -355,12 +415,17 @@ export default function SessionsPage() {
               variant="ghost"
               size="icon"
               className="h-9 w-9"
-              onClick={() => void refetch()}
-              disabled={isFetching}
+              onClick={() => {
+                void refetch();
+                if (shouldCheckForHiddenSessions) {
+                  void refetchHiddenSessions();
+                }
+              }}
+              disabled={isRefreshing}
               aria-label={t("sessions.refresh")}
             >
               <IconRefresh
-                className={cn("h-4 w-4", isFetching && "animate-spin")}
+                className={cn("h-4 w-4", isRefreshing && "animate-spin")}
               />
             </Button>
           </div>
@@ -369,14 +434,22 @@ export default function SessionsPage() {
 
       <Card>
         <CardContent className="p-0">
-          {error ? (
+          {loadError ? (
             <div className="p-6 text-sm text-destructive">
-              {t("sessions.loadFailed", { message: error.message })}
+              {t("sessions.loadFailed", { message: loadError.message })}
             </div>
-          ) : isLoading ? (
+          ) : isLoading || isCheckingEmptyState ? (
             <SessionSkeleton />
           ) : recordings.length === 0 ? (
-            <EmptySessionsState />
+            showZeroMinuteRecoveryAction ? (
+              <FilteredEmptySessionsState
+                onIncludeZeroMinuteSessions={() =>
+                  updateFilter("includeZeroMinuteSessions", "true")
+                }
+              />
+            ) : (
+              <EmptySessionsState />
+            )
           ) : (
             <div>
               <div className="flex items-center justify-between border-b px-4 py-3">
@@ -525,6 +598,22 @@ function EmptySessionsState() {
   );
 }
 
+function FilteredEmptySessionsState({
+  onIncludeZeroMinuteSessions,
+}: {
+  onIncludeZeroMinuteSessions: () => void;
+}) {
+  const t = useT();
+  return (
+    <div className="flex min-h-[380px] flex-col items-center justify-center gap-4 p-6">
+      <h2 className="text-lg font-semibold">{t("sessions.noSessions")}</h2>
+      <Button variant="outline" onClick={onIncludeZeroMinuteSessions}>
+        {t("sessions.includeZeroMinuteSessions")}
+      </Button>
+    </div>
+  );
+}
+
 export function ReplayStorageHint({
   embedded = false,
 }: {
@@ -862,6 +951,7 @@ function formatDateTime(value: string): string {
 
 export function formatSessionDuration(ms: number | null): string {
   if (!ms || !Number.isFinite(ms) || ms <= 0) return "0m";
+  if (ms < MIN_DURATION_FOR_ONE_MINUTE_LABEL_MS) return "0m";
   const seconds = Math.round(ms / 1000);
   const minutes = Math.floor(seconds / 60);
   if (minutes < 60) return `${minutes}m`;

package/corpus/templates/analytics/changelog/2026-09-24-session-list-hides-0m-recordings-by-default.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-09-24
+---
+
+The Sessions list hides 0m recordings by default, with a filter to include them.

package/corpus/templates/assets/CHANGELOG.md

@@ -3,6 +3,12 @@
 All notable user-facing changes to Assets are documented here. Open it any
 time from the command menu (Cmd+K → "What's new") or from Settings.
 
+## 2026-09-23
+
+### Fixed
+
+- Stale image candidates stop showing as generating when their generation run is missing.
+
 ## 2026-09-01
 
 ### Improved

package/corpus/templates/brain/actions/backfill-search-embeddings.ts

@@ -0,0 +1,337 @@
+import { defineAction } from "@agent-native/core/action";
+import { runWithRequestContext } from "@agent-native/core/server/request-context";
+import { assertAccess } from "@agent-native/core/sharing";
+import { and, asc, eq, gt, inArray, isNotNull, lte, or } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import { nowIso } from "../server/lib/brain.js";
+import { enqueueBrainOperation } from "../server/lib/ingest-queue.js";
+import { BRAIN_SEARCH_INDEX_VERSION } from "../server/lib/search-index-contracts.js";
+import {
+  readCaptureEmbeddingCoverage,
+  readEmbeddingReadiness,
+} from "../server/lib/search-index.js";
+import { redactSensitiveText } from "../server/lib/search.js";
+import {
+  booleanishSchema,
+  idSchema,
+  stringArrayCliSchema,
+} from "./_schemas.js";
+
+export const backfillSearchEmbeddingsSchema = z
+  .object({
+    sourceId: idSchema,
+    dryRun: booleanishSchema.default(true),
+    force: booleanishSchema.default(false),
+    captureIds: stringArrayCliSchema({ min: 1, max: 50 }).optional(),
+    afterUpdatedAt: z.string().datetime().optional(),
+    afterCaptureId: idSchema.optional(),
+    throughUpdatedAt: z.string().datetime().optional(),
+    limit: z.coerce.number().int().min(1).max(50).default(25),
+  })
+  .refine(
+    (args) => Boolean(args.afterUpdatedAt) === Boolean(args.afterCaptureId),
+    {
+      message: "Provide afterUpdatedAt and afterCaptureId together.",
+    },
+  )
+  .refine(
+    (args) =>
+      !args.captureIds?.length ||
+      (!args.afterUpdatedAt && !args.afterCaptureId && !args.throughUpdatedAt),
+    {
+      message: "captureIds cannot be combined with pagination cursors.",
+    },
+  );
+
+type CandidateRow = Awaited<
+  ReturnType<typeof findCandidatePage>
+>["rows"][number];
+
+async function findCandidatePage(args: {
+  sourceId: string;
+  embeddingSetId: string | null;
+  captureIds?: string[];
+  afterUpdatedAt?: string;
+  afterCaptureId?: string;
+  throughUpdatedAt: string;
+  limit: number;
+}) {
+  const rows = await getDb()
+    .select({
+      id: schema.brainRawCaptures.id,
+      sourceId: schema.brainRawCaptures.sourceId,
+      title: schema.brainRawCaptures.title,
+      content: schema.brainRawCaptures.content,
+      contentHash: schema.brainRawCaptures.contentHash,
+      sensitivityDisposition: schema.brainRawCaptures.sensitivityDisposition,
+      sensitivityPolicyVersion:
+        schema.brainRawCaptures.sensitivityPolicyVersion,
+      audienceAclHash: schema.brainRawCaptures.audienceAclHash,
+      capturedAt: schema.brainRawCaptures.capturedAt,
+      updatedAt: schema.brainRawCaptures.updatedAt,
+      artifactId: schema.brainSearchArtifacts.id,
+      artifactAudienceId: schema.brainSearchArtifacts.audienceId,
+      artifactAclHash: schema.brainSearchArtifacts.aclHash,
+      artifactTitle: schema.brainSearchArtifacts.title,
+      artifactQuestion: schema.brainSearchArtifacts.question,
+      artifactSummary: schema.brainSearchArtifacts.summary,
+      artifactResolution: schema.brainSearchArtifacts.resolution,
+      artifactSystemsJson: schema.brainSearchArtifacts.systemsJson,
+      artifactCodeRefsJson: schema.brainSearchArtifacts.codeRefsJson,
+      embeddingId: schema.brainSearchEmbeddings.id,
+    })
+    .from(schema.brainRawCaptures)
+    .leftJoin(
+      schema.brainSearchArtifacts,
+      and(
+        eq(schema.brainSearchArtifacts.captureId, schema.brainRawCaptures.id),
+        eq(schema.brainSearchArtifacts.status, "active"),
+        eq(
+          schema.brainSearchArtifacts.contentHash,
+          schema.brainRawCaptures.contentHash,
+        ),
+        eq(
+          schema.brainSearchArtifacts.sensitivityPolicyVersion,
+          schema.brainRawCaptures.sensitivityPolicyVersion,
+        ),
+        eq(
+          schema.brainSearchArtifacts.aclHash,
+          schema.brainRawCaptures.audienceAclHash,
+        ),
+        eq(
+          schema.brainSearchArtifacts.indexVersion,
+          BRAIN_SEARCH_INDEX_VERSION,
+        ),
+      ),
+    )
+    .leftJoin(
+      schema.brainSearchEmbeddings,
+      and(
+        eq(schema.brainSearchEmbeddings.targetType, "artifact"),
+        eq(
+          schema.brainSearchEmbeddings.targetId,
+          schema.brainSearchArtifacts.id,
+        ),
+        eq(schema.brainSearchEmbeddings.status, "active"),
+        eq(
+          schema.brainSearchEmbeddings.embeddingSetId,
+          args.embeddingSetId ?? "__unconfigured__",
+        ),
+        eq(
+          schema.brainSearchEmbeddings.contentHash,
+          schema.brainRawCaptures.contentHash,
+        ),
+        eq(
+          schema.brainSearchEmbeddings.sensitivityPolicyVersion,
+          schema.brainRawCaptures.sensitivityPolicyVersion,
+        ),
+        eq(
+          schema.brainSearchEmbeddings.aclHash,
+          schema.brainRawCaptures.audienceAclHash,
+        ),
+        eq(
+          schema.brainSearchEmbeddings.indexVersion,
+          BRAIN_SEARCH_INDEX_VERSION,
+        ),
+      ),
+    )
+    .where(
+      and(
+        eq(schema.brainRawCaptures.sourceId, args.sourceId),
+        eq(schema.brainRawCaptures.sensitivityDisposition, "allowed"),
+        isNotNull(schema.brainRawCaptures.contentHash),
+        isNotNull(schema.brainRawCaptures.sensitivityPolicyVersion),
+        isNotNull(schema.brainRawCaptures.audienceAclHash),
+        args.captureIds?.length
+          ? inArray(schema.brainRawCaptures.id, args.captureIds)
+          : lte(schema.brainRawCaptures.updatedAt, args.throughUpdatedAt),
+        args.afterUpdatedAt && args.afterCaptureId
+          ? or(
+              gt(schema.brainRawCaptures.updatedAt, args.afterUpdatedAt),
+              and(
+                eq(schema.brainRawCaptures.updatedAt, args.afterUpdatedAt),
+                gt(schema.brainRawCaptures.id, args.afterCaptureId),
+              ),
+            )
+          : undefined,
+      ),
+    )
+    .orderBy(
+      asc(schema.brainRawCaptures.updatedAt),
+      asc(schema.brainRawCaptures.id),
+    )
+    .limit(
+      args.captureIds?.length
+        ? Math.min(50, args.captureIds.length)
+        : args.limit + 1,
+    );
+
+  return {
+    rows: rows.slice(0, args.captureIds?.length ?? args.limit),
+    hasMore: !args.captureIds?.length && rows.length > args.limit,
+  };
+}
+
+async function candidateReason(
+  row: CandidateRow,
+  force: boolean,
+  embeddingSetId: string | null,
+) {
+  if (force) return "forced";
+  if (!row.artifactId) return "missing-artifact";
+  if (!row.embeddingId || !embeddingSetId) return "missing-embedding";
+  const coverage = await readCaptureEmbeddingCoverage(row.id, embeddingSetId);
+  return coverage.complete ? null : "partial-embedding";
+}
+
+async function enqueueCandidate(row: CandidateRow, embeddingSetId: string) {
+  try {
+    const queue = await enqueueBrainOperation({
+      operation: "search-index",
+      dedupeKey: `search-index-backfill:${row.id}:${row.contentHash}:${embeddingSetId}`,
+      sourceId: row.sourceId,
+      captureId: row.id,
+      priority: 40,
+      payload: { requiredEmbeddingSetId: embeddingSetId },
+    });
+    return {
+      captureId: row.id,
+      outcome: "queued" as const,
+      queueId: queue?.id ?? null,
+      reason: null,
+    };
+  } catch (error) {
+    return {
+      captureId: row.id,
+      outcome: "failed" as const,
+      queueId: null,
+      reason: redactSensitiveText(
+        error instanceof Error ? error.message : String(error),
+      ),
+    };
+  }
+}
+
+async function readSourceEmbeddingReadiness(sourceId: string) {
+  const [source] = await getDb()
+    .select({
+      ownerEmail: schema.brainSources.ownerEmail,
+      orgId: schema.brainSources.orgId,
+    })
+    .from(schema.brainSources)
+    .where(eq(schema.brainSources.id, sourceId))
+    .limit(1);
+  if (!source) throw new Error("Brain source was not found.");
+  return runWithRequestContext(
+    {
+      userEmail: source.ownerEmail,
+      orgId: source.orgId ?? undefined,
+    },
+    readEmbeddingReadiness,
+  );
+}
+
+export function backfillSearchEmbeddingsNeedsApproval(args: {
+  dryRun?: unknown;
+}) {
+  return !booleanishSchema.default(true).parse(args.dryRun);
+}
+
+export default defineAction({
+  description:
+    "Dry-run or durably queue semantic embedding backfills for a bounded page of allowed captures from one accessible Brain source.",
+  schema: backfillSearchEmbeddingsSchema,
+  needsApproval: backfillSearchEmbeddingsNeedsApproval,
+  toolCallable: false,
+  run: async (args) => {
+    await assertAccess("brain-source", args.sourceId, "admin");
+    const readiness = await readSourceEmbeddingReadiness(args.sourceId);
+    if (!args.dryRun && !readiness.ready) {
+      throw new Error(
+        readiness.warning ??
+          "Configure exactly one embedding provider before backfilling.",
+      );
+    }
+
+    const throughUpdatedAt = args.throughUpdatedAt ?? nowIso();
+    const page = await findCandidatePage({
+      sourceId: args.sourceId,
+      embeddingSetId: readiness.embeddingSetId,
+      captureIds: args.captureIds,
+      afterUpdatedAt: args.afterUpdatedAt,
+      afterCaptureId: args.afterCaptureId,
+      throughUpdatedAt,
+      limit: args.limit,
+    });
+    const candidateRows = await Promise.all(
+      page.rows.map(async (row) => ({
+        row,
+        reason: await candidateReason(
+          row,
+          args.force,
+          readiness.embeddingSetId,
+        ),
+      })),
+    );
+    const candidates = candidateRows.filter(
+      (candidate): candidate is typeof candidate & { reason: string } =>
+        candidate.reason !== null,
+    );
+    const lastRow = page.rows[page.rows.length - 1];
+    const nextCursor =
+      page.hasMore && lastRow
+        ? {
+            afterUpdatedAt: lastRow.updatedAt,
+            afterCaptureId: lastRow.id,
+            throughUpdatedAt,
+          }
+        : null;
+
+    if (args.dryRun) {
+      return {
+        dryRun: true,
+        sourceId: args.sourceId,
+        readiness,
+        scanned: page.rows.length,
+        matched: candidates.length,
+        queued: 0,
+        failed: 0,
+        failedCaptureIds: [],
+        hasMore: page.hasMore,
+        nextCursor,
+        candidates: candidates.map(({ row, reason }) => ({
+          captureId: row.id,
+          reason,
+        })),
+        results: [],
+      };
+    }
+
+    const results = await Promise.all(
+      candidates.map(({ row }) =>
+        enqueueCandidate(row, readiness.embeddingSetId!),
+      ),
+    );
+    return {
+      dryRun: false,
+      sourceId: args.sourceId,
+      readiness,
+      scanned: page.rows.length,
+      matched: candidates.length,
+      queued: results.filter((result) => result.outcome === "queued").length,
+      failed: results.filter((result) => result.outcome === "failed").length,
+      failedCaptureIds: results
+        .filter((result) => result.outcome === "failed")
+        .map((result) => result.captureId),
+      hasMore: page.hasMore,
+      nextCursor,
+      candidates: candidates.map(({ row, reason }) => ({
+        captureId: row.id,
+        reason,
+      })),
+      results,
+    };
+  },
+});

package/corpus/templates/brain/actions/get-brain-health.ts

@@ -7,7 +7,7 @@ export { readBrainHealth };
 
 export default defineAction({
   description:
-    "Summarize Brain setup and source health, including configured sources, sync freshness, pending proposals, queue issues, last eval score, and suggested next setup steps.",
+    "Summarize Brain setup and source health, including embedding provider readiness and coverage, sync freshness, pending proposals, queue issues, last eval score, and suggested next setup steps.",
   schema: z.object({}),
   http: { method: "GET" },
   readOnly: true,

package/corpus/templates/brain/app/lib/brain.ts

@@ -401,6 +401,24 @@ export interface BrainHealthResponse {
       counts?: Record<string, number>;
     };
     embeddings: {
+      readiness: {
+        status: "ready" | "not-configured" | "ambiguous" | "unavailable";
+        ready: boolean;
+        configuredProviders: string[];
+        unavailableProviders: string[];
+        configuredFamilies: number;
+        provider: string | null;
+        model: string | null;
+        embeddingSetId: string | null;
+        dimensions: number | null;
+        warning: string | null;
+      };
+      coverage: {
+        eligibleArtifacts: number;
+        embeddedArtifacts: number;
+        missingArtifacts: number;
+        percent: number;
+      };
       total: number;
       active: number;
       stale: number;

package/corpus/templates/brain/jobs/process-ingest-queue.ts

@@ -179,10 +179,32 @@ export async function claimForHeadlessRunner(row: QueueRow, payload: object) {
 async function runDeterministicOperation(
   row: QueueRow,
   context: NonNullable<Awaited<ReturnType<typeof loadCaptureAndSource>>>,
+  payload: Record<string, unknown>,
 ) {
   if (row.operation === "search-index") {
-    const { indexBrainCapture } = await import("../server/lib/search-index.js");
-    await indexBrainCapture(context.capture.id);
+    const { indexBrainCapture, readCaptureEmbeddingCoverage } =
+      await import("../server/lib/search-index.js");
+    const result = await indexBrainCapture(context.capture.id);
+    const requiredEmbeddingSetId =
+      typeof payload.requiredEmbeddingSetId === "string"
+        ? payload.requiredEmbeddingSetId
+        : null;
+    if (requiredEmbeddingSetId) {
+      if (!result.indexed) {
+        throw new Error(
+          `Embedding backfill indexing failed: ${result.reason ?? "unknown"}.`,
+        );
+      }
+      const coverage = await readCaptureEmbeddingCoverage(
+        context.capture.id,
+        requiredEmbeddingSetId,
+      );
+      if (!coverage.complete) {
+        throw new Error(
+          `Embedding backfill incomplete: artifact=${coverage.artifactEmbedded}, bursts=${coverage.embeddedBursts}/${coverage.expectedBursts}.`,
+        );
+      }
+    }
     return;
   }
   if (row.operation === "search-unindex") {
@@ -579,7 +601,7 @@ export async function processBrainIngestQueueOnce(
             userEmail: contextRows.source.ownerEmail,
             orgId: contextRows.source.orgId ?? undefined,
           },
-          () => runDeterministicOperation(row, contextRows),
+          () => runDeterministicOperation(row, contextRows, payload),
         );
         await markOperationDone(row, claimToken);
         processed.push(row.id);