fix(enrichment): store manual attempts in execution metadata

Author: TheodoreSpeaks

apps/sim/app/api/table/[tableId]/rows/[rowId]/enrichment/[groupId]/route.test.ts

@@ -50,6 +50,7 @@ function makeRequest(tableId = 'tbl_1', rowId = 'row_1', groupId = 'grp_1') {
 }
 
 const detail: EnrichmentRunDetail = {
+  isManualRun: true,
   startedAt: '2026-06-18T00:00:00.000Z',
   completedAt: '2026-06-18T00:00:01.000Z',
   durationMs: 1000,

apps/sim/app/api/tools/enrichment/run/route.ts

@@ -48,6 +48,7 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
 
   const { result, cost, error, provider } = await runEnrichment(enrichment, inputs, {
     workspaceId,
+    isManualRun: false,
     signal: request.signal,
   })
 

apps/sim/background/workflow-column-execution.ts

@@ -6,7 +6,7 @@ import { sleep } from '@sim/utils/helpers'
 import { generateId } from '@sim/utils/id'
 import { backoffWithJitter } from '@sim/utils/retry'
 import { task, timeout } from '@trigger.dev/sdk'
-import { and, eq, isNull, or } from 'drizzle-orm'
+import { and, eq, isNull, or, sql } from 'drizzle-orm'
 import {
   assertBillingAttributionSnapshot,
   type BillingAttributionSnapshot,
@@ -134,9 +134,9 @@ export async function terminalizeAbortedQueuedCarrierMarker(
       executionId: executionState.executionId,
       jobId: executionState.jobId,
       workflowId: executionState.workflowId,
-      isManualRun: payload.isManualRun,
       error: executionState.error,
       runningBlockIds: executionState.runningBlockIds,
+      enrichmentDetails: sql`coalesce(${tableRowExecutions.enrichmentDetails}, '{}'::jsonb) || jsonb_build_object('isManualRun', ${payload.isManualRun})`,
       updatedAt: new Date(),
     })
     .where(
@@ -555,7 +555,9 @@ async function runWorkflowAndWriteTerminal(
               jobId: null,
               workflowId: statusId,
               error: null,
-              enrichmentDetails: skippedEnrichmentDetail(enrichment),
+              enrichmentDetails: skippedEnrichmentDetail(enrichment, {
+                isManualRun: payload.isManualRun,
+              }),
             },
             clearPatch,
             undefined,
@@ -573,7 +575,10 @@ async function runWorkflowAndWriteTerminal(
                 timedOut: timeoutController.isTimedOut(),
                 timeoutMs: timeoutController.timeoutMs,
               }),
-              enrichmentDetails: skippedEnrichmentDetail(enrichment, { aborted: true }),
+              enrichmentDetails: skippedEnrichmentDetail(enrichment, {
+                isManualRun: payload.isManualRun,
+                aborted: true,
+              }),
             })
             return 'error'
           }
@@ -600,6 +605,7 @@ async function runWorkflowAndWriteTerminal(
             tableId,
             rowId,
             workspaceId,
+            isManualRun: payload.isManualRun,
             signal: attemptSignal,
             resolvedSecretTraceRegistry: enrichmentRegistry,
           })

apps/sim/enrichments/run.test.ts

@@ -40,7 +40,7 @@ function config(providers: EnrichmentProvider[]): EnrichmentConfig {
   }
 }
 
-const ctx = { workspaceId: 'ws-1' }
+const ctx = { workspaceId: 'ws-1', isManualRun: false }
 
 beforeEach(() => {
   mockExecuteTool.mockReset()
@@ -63,6 +63,7 @@ describe('runEnrichment cascade detail', () => {
     expect(outcome.provider).toBe('B')
 
     expect(outcome.detail.matchedProvider).toBe('b')
+    expect(outcome.detail.isManualRun).toBe(false)
     expect(outcome.detail.totalCost).toBe(0.05)
     // The full cascade is recorded; the provider after the match is `not_run`.
     expect(outcome.detail.providers.map((p) => p.id)).toEqual(['a', 'b', 'c'])
@@ -139,7 +140,10 @@ describe('runEnrichment cascade detail', () => {
   })
 
   it('skippedEnrichmentDetail marks every provider skipped without running', () => {
-    const detail = skippedEnrichmentDetail(config([prov('a'), prov('b')]))
+    const detail = skippedEnrichmentDetail(config([prov('a'), prov('b')]), {
+      isManualRun: true,
+    })
+    expect(detail.isManualRun).toBe(true)
     expect(detail.matchedProvider).toBeNull()
     expect(detail.totalCost).toBe(0)
     expect(detail.providers.map((p) => p.status)).toEqual(['skipped', 'skipped'])

apps/sim/enrichments/run.ts

@@ -32,10 +32,11 @@ export interface EnrichmentRunOutcome {
  */
 export function skippedEnrichmentDetail(
   enrichment: EnrichmentConfig,
-  opts: { aborted?: boolean } = {}
+  opts: { isManualRun: boolean; aborted?: boolean }
 ): EnrichmentRunDetail {
   const now = new Date().toISOString()
   return {
+    isManualRun: opts.isManualRun,
     startedAt: now,
     completedAt: now,
     durationMs: 0,
@@ -206,6 +207,7 @@ export async function runEnrichment(
 
   const completedAt = Date.now()
   const detail: EnrichmentRunDetail = {
+    isManualRun: ctx.isManualRun,
     startedAt: new Date(startedAt).toISOString(),
     completedAt: new Date(completedAt).toISOString(),
     durationMs: completedAt - startedAt,

apps/sim/enrichments/types.ts

@@ -31,6 +31,8 @@ export interface EnrichmentRunContext {
   tableId?: string
   rowId?: string
   workspaceId: string
+  /** Whether a user explicitly requested this table attempt. */
+  isManualRun: boolean
   signal?: AbortSignal
   /** Isolated provenance for the exact mapped row inputs used by this run. */
   resolvedSecretTraceRegistry?: ResolvedSecretTraceRegistry

apps/sim/lib/copilot/tools/server/enrichment/enrichment-run.ts

@@ -44,6 +44,7 @@ export const enrichmentRunServerTool: BaseServerTool<EnrichmentRunParams, Enrich
 
     const { result, cost, error, provider } = await runEnrichment(enrichment, inputs ?? {}, {
       workspaceId,
+      isManualRun: false,
       signal: context?.abortSignal,
     })
 

apps/sim/lib/table/dispatcher.ts

@@ -507,7 +507,19 @@ export async function dispatcherStep(
   // out into one query per row. Returns `Map<rowId, RowExecutions>`.
   const chunkRowIds = chunk.map((r) => r.id)
   const execRows = await db
-    .select()
+    .select({
+      rowId: tableRowExecutions.rowId,
+      groupId: tableRowExecutions.groupId,
+      status: tableRowExecutions.status,
+      executionId: tableRowExecutions.executionId,
+      jobId: tableRowExecutions.jobId,
+      workflowId: tableRowExecutions.workflowId,
+      isManualRun: sql<boolean>`coalesce((${tableRowExecutions.enrichmentDetails} ->> 'isManualRun')::boolean, false)`,
+      error: tableRowExecutions.error,
+      runningBlockIds: tableRowExecutions.runningBlockIds,
+      blockErrors: tableRowExecutions.blockErrors,
+      cancelledAt: tableRowExecutions.cancelledAt,
+    })
     .from(tableRowExecutions)
     .where(inArray(tableRowExecutions.rowId, chunkRowIds))
   const executionsByRow = new Map<string, RowExecutions>()

apps/sim/lib/table/rows/executions.test.ts

@@ -129,6 +129,22 @@ describe('writeExecutionsPatch guards', () => {
       )
     ).resolves.toBe('wrote')
   })
+
+  it('stores manual-run provenance in the existing execution JSON', async () => {
+    await expect(
+      writeExecutionsPatch(
+        dbChainMock.db as unknown as Parameters<typeof writeExecutionsPatch>[0],
+        'table-1',
+        'row-1',
+        { 'group-1': { ...EXECUTION_STATE, isManualRun: true } }
+      )
+    ).resolves.toBe('wrote')
+
+    expect(dbChainMockFns.values).toHaveBeenCalledWith(
+      expect.objectContaining({ enrichmentDetails: { isManualRun: true } })
+    )
+    expect(dbChainMockFns.values.mock.calls[0]?.[0]).not.toHaveProperty('isManualRun')
+  })
 })
 
 describe('loadExecutionsByRow', () => {

apps/sim/lib/table/rows/executions.ts

@@ -19,6 +19,31 @@ import type {
   TableSchema,
 } from '@/lib/table/types'
 
+function readExecutionIsManualRun(value: Record<string, unknown>): boolean {
+  const isManualRun = value.isManualRun
+  if (isManualRun === undefined) return false
+  if (typeof isManualRun !== 'boolean') {
+    throw new Error('Execution metadata isManualRun must be a boolean')
+  }
+  return isManualRun
+}
+
+function readEnrichmentRunDetail(value: unknown): EnrichmentRunDetail | null {
+  if (value === null || value === undefined) return null
+  if (typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error('Enrichment run detail must be a JSON object')
+  }
+  const metadata = value as Record<string, unknown>
+  if (metadata.providers === undefined) return null
+  if (!Array.isArray(metadata.providers)) {
+    throw new Error('Enrichment run detail providers must be an array')
+  }
+  return {
+    ...(value as Omit<EnrichmentRunDetail, 'isManualRun'>),
+    isManualRun: readExecutionIsManualRun(metadata),
+  }
+}
+
 /**
  * Loads `tableRowExecutions` rows for the given row ids and groups them into a
  * `Map<rowId, RowExecutions>` suitable for plugging into `TableRow.executions`.
@@ -30,9 +55,9 @@ export async function loadExecutionsByRow(
   const ids = Array.from(new Set(rowIds))
   const result = new Map<string, RowExecutions>()
   if (ids.length === 0) return result
-  // Explicit column list, never `select()` — `enrichmentDetails` is large and
-  // must stay off the hot grid read path (fetched on demand via
-  // `loadEnrichmentDetail`).
+  // Explicit column list, never `select()` — project only the small provenance
+  // scalar from `enrichmentDetails`; the provider cascade stays off the hot
+  // grid read path and is fetched on demand via `loadEnrichmentDetail`.
   const rows = await trx
     .select({
       rowId: tableRowExecutions.rowId,
@@ -41,7 +66,7 @@ export async function loadExecutionsByRow(
       executionId: tableRowExecutions.executionId,
       jobId: tableRowExecutions.jobId,
       workflowId: tableRowExecutions.workflowId,
-      isManualRun: tableRowExecutions.isManualRun,
+      isManualRun: sql<boolean>`coalesce((${tableRowExecutions.enrichmentDetails} ->> 'isManualRun')::boolean, false)`,
       error: tableRowExecutions.error,
       runningBlockIds: tableRowExecutions.runningBlockIds,
       blockErrors: tableRowExecutions.blockErrors,
@@ -100,7 +125,20 @@ export async function loadEnrichmentDetail(
       ) as SQL
     )
     .limit(1)
-  return (row?.enrichmentDetails as EnrichmentRunDetail | null | undefined) ?? null
+  return readEnrichmentRunDetail(row?.enrichmentDetails)
+}
+
+function buildStoredExecutionMetadata(
+  value: RowExecutionMetadata
+): EnrichmentRunDetail | { isManualRun: boolean } | null {
+  const detail = value.enrichmentDetails
+  if (detail) {
+    if (value.isManualRun !== undefined && detail.isManualRun !== value.isManualRun) {
+      throw new Error('Execution state and enrichment detail disagree on manual-run provenance')
+    }
+    return detail
+  }
+  return value.isManualRun === undefined ? null : { isManualRun: value.isManualRun }
 }
 
 /**
@@ -265,14 +303,18 @@ export async function writeExecutionsPatch(
       executionId: value.executionId,
       jobId: value.jobId,
       workflowId: value.workflowId,
-      isManualRun: value.isManualRun ?? false,
       error: value.error,
       runningBlockIds: value.runningBlockIds ?? [],
       blockErrors: value.blockErrors ?? {},
       cancelledAt: value.cancelledAt ? new Date(value.cancelledAt) : null,
-      enrichmentDetails: value.enrichmentDetails ?? null,
+      enrichmentDetails: buildStoredExecutionMetadata(value),
       updatedAt: new Date(),
     } as const
+    const enrichmentDetailsUpdate = value.enrichmentDetails
+      ? insertValues.enrichmentDetails
+      : value.isManualRun !== undefined
+        ? sql`coalesce(${tableRowExecutions.enrichmentDetails}, '{}'::jsonb) || excluded.enrichment_details`
+        : tableRowExecutions.enrichmentDetails
 
     if (isGuarded) {
       // Gate by guard semantics. The original JSONB guard had two AND'd
@@ -303,19 +345,11 @@ export async function writeExecutionsPatch(
             executionId: insertValues.executionId,
             jobId: insertValues.jobId,
             workflowId: insertValues.workflowId,
-            isManualRun:
-              value.isManualRun === undefined
-                ? tableRowExecutions.isManualRun
-                : insertValues.isManualRun,
             error: insertValues.error,
             runningBlockIds: insertValues.runningBlockIds,
             blockErrors: insertValues.blockErrors,
             cancelledAt: insertValues.cancelledAt,
-            // Sticky: preserve a prior cascade breakdown when this write omits
-            // it (e.g. the running pickup stamp) so only an explicit detail
-            // overwrites it. Re-runs delete the row first, so this never serves
-            // stale detail across runs.
-            enrichmentDetails: sql`coalesce(excluded.enrichment_details, ${tableRowExecutions.enrichmentDetails})`,
+            enrichmentDetails: enrichmentDetailsUpdate,
             updatedAt: insertValues.updatedAt,
           },
           where: guardCondition as SQL,
@@ -335,18 +369,11 @@ export async function writeExecutionsPatch(
           executionId: insertValues.executionId,
           jobId: insertValues.jobId,
           workflowId: insertValues.workflowId,
-          isManualRun:
-            value.isManualRun === undefined
-              ? tableRowExecutions.isManualRun
-              : insertValues.isManualRun,
           error: insertValues.error,
           runningBlockIds: insertValues.runningBlockIds,
           blockErrors: insertValues.blockErrors,
           cancelledAt: insertValues.cancelledAt,
-          // Sticky: preserve a prior cascade breakdown when this write omits it
-          // (e.g. the running pickup stamp) so only an explicit detail overwrites
-          // it. Re-runs delete the row first, so this never serves stale detail.
-          enrichmentDetails: sql`coalesce(excluded.enrichment_details, ${tableRowExecutions.enrichmentDetails})`,
+          enrichmentDetails: enrichmentDetailsUpdate,
           updatedAt: insertValues.updatedAt,
         },
       })