fix(logs): redact error/trigger/executionState; keep guardrails import lazy

- Extend PII redaction to span error/errorMessage/toolCalls and top-level
  error/completionFailure/trigger/executionState (Bugbot: PII in execution
  metadata). executionState is safe to redact — resume reads from the separate
  pausedExecutions table, not the log copy.
- Lazy-import validate_pii in pii-redaction so the Python/child_process
  guardrails module stays out of the static middleware/RSC graph.
- Type the org retention mutation to the contract body (optional, non-null).

Author: TheodoreSpeaks

apps/sim/ee/data-retention/hooks/data-retention.ts

@@ -6,6 +6,7 @@ import {
   getOrganizationDataRetentionContract,
   type OrganizationDataRetention,
   type OrganizationRetentionValues,
+  type UpdateOrganizationDataRetentionBody,
   updateOrganizationDataRetentionContract,
 } from '@/lib/api/contracts/organization'
 import {
@@ -48,7 +49,7 @@ export function useOrganizationRetention(orgId: string | undefined) {
 
 interface UpdateRetentionVariables {
   orgId: string
-  settings: Partial<RetentionValues>
+  settings: UpdateOrganizationDataRetentionBody
 }
 
 export function useUpdateOrganizationRetention() {

apps/sim/lib/api/contracts/organization.ts

@@ -111,6 +111,10 @@ export const updateOrganizationDataRetentionBodySchema = z.object({
   piiRedaction: piiRedactionSettingsSchema.optional(),
 })
 
+export type UpdateOrganizationDataRetentionBody = z.input<
+  typeof updateOrganizationDataRetentionBodySchema
+>
+
 const organizationRetentionValuesSchema = z.object({
   logRetentionHours: z.number().int().nullable(),
   softDeleteRetentionHours: z.number().int().nullable(),

apps/sim/lib/logs/execution/logger.ts

@@ -761,6 +761,14 @@ export class ExecutionLogger implements IExecutionLoggerService {
       traceSpans: redactedTraceSpans,
       finalOutput: redactedFinalOutput,
       ...(redactedWorkflowInput !== undefined ? { workflowInput: redactedWorkflowInput } : {}),
+      ...(builtExecutionData.error !== undefined ? { error: builtExecutionData.error } : {}),
+      ...(builtExecutionData.completionFailure !== undefined
+        ? { completionFailure: builtExecutionData.completionFailure }
+        : {}),
+      ...(builtExecutionData.trigger !== undefined ? { trigger: builtExecutionData.trigger } : {}),
+      ...(builtExecutionData.executionState !== undefined
+        ? { executionState: builtExecutionData.executionState }
+        : {}),
     })
 
     const rawDurationMs =
@@ -777,6 +785,14 @@ export class ExecutionLogger implements IExecutionLoggerService {
       traceSpans: pii.traceSpans as TraceSpan[],
       finalOutput: pii.finalOutput as BlockOutputData,
       ...(pii.workflowInput !== undefined ? { workflowInput: pii.workflowInput } : {}),
+      ...(pii.error !== undefined ? { error: pii.error as string } : {}),
+      ...(pii.completionFailure !== undefined
+        ? { completionFailure: pii.completionFailure as string }
+        : {}),
+      ...(pii.trigger !== undefined ? { trigger: pii.trigger as ExecutionTrigger } : {}),
+      ...(pii.executionState !== undefined
+        ? { executionState: pii.executionState as SerializableExecutionState }
+        : {}),
     }
 
     stripSpanCosts((cleanExecutionData as Record<string, unknown>).traceSpans)

apps/sim/lib/logs/execution/pii-redaction.test.ts

@@ -85,6 +85,28 @@ describe('redactPIIFromExecution', () => {
     expect(mockMaskPIIBatch.mock.calls[0][0]).toEqual(['pii'])
   })
 
+  it('masks span error/errorMessage and top-level error, trigger, executionState', async () => {
+    const payload = {
+      traceSpans: [{ blockId: 'b1', error: 'failed for bob@x.com', errorMessage: 'bad input z' }],
+      error: 'run failed: a@b.com',
+      completionFailure: 'cancelled by c@d.com',
+      trigger: { type: 'webhook', data: { from: 'caller@x.com' } },
+      executionState: { status: 'completed', note: 'state for e@f.com' },
+    }
+
+    const result = await redactPIIFromExecution(payload, { entityTypes: ['EMAIL_ADDRESS'] })
+
+    const span = (result.traceSpans as any[])[0]
+    expect(span.blockId).toBe('b1')
+    expect(span.error).toBe('MASKED(failed for bob@x.com)')
+    expect(span.errorMessage).toBe('MASKED(bad input z)')
+    expect(result.error).toBe('MASKED(run failed: a@b.com)')
+    expect(result.completionFailure).toBe('MASKED(cancelled by c@d.com)')
+    expect((result.trigger as any).type).toBe('MASKED(webhook)')
+    expect((result.trigger as any).data.from).toBe('MASKED(caller@x.com)')
+    expect((result.executionState as any).note).toBe('MASKED(state for e@f.com)')
+  })
+
   it('returns payload unchanged when there is nothing to mask', async () => {
     const payload = { traceSpans: [{ blockId: 'b1', count: 5 }] }
     const result = await redactPIIFromExecution(payload, { entityTypes: [] })

apps/sim/lib/logs/execution/pii-redaction.ts

@@ -1,6 +1,5 @@
 import { createLogger } from '@sim/logger'
 import { getErrorMessage } from '@sim/utils/errors'
-import { maskPIIBatch } from '@/lib/guardrails/validate_pii'
 
 const logger = createLogger('PiiRedaction')
 
@@ -29,10 +28,33 @@ export interface RedactablePayload {
   traceSpans?: unknown
   finalOutput?: unknown
   workflowInput?: unknown
+  error?: unknown
+  completionFailure?: unknown
+  trigger?: unknown
+  executionState?: unknown
 }
 
+/** Keys of {@link RedactablePayload} processed by the redactor, in order. */
+const REDACTABLE_KEYS: (keyof RedactablePayload)[] = [
+  'traceSpans',
+  'finalOutput',
+  'workflowInput',
+  'error',
+  'completionFailure',
+  'trigger',
+  'executionState',
+]
+
 /** Trace-span fields that carry runtime content (and therefore possible PII). */
-const SPAN_CONTENT_FIELDS = ['input', 'output', 'thinking', 'modelToolCalls'] as const
+const SPAN_CONTENT_FIELDS = [
+  'input',
+  'output',
+  'thinking',
+  'modelToolCalls',
+  'toolCalls',
+  'error',
+  'errorMessage',
+] as const
 
 function isEligibleString(value: string): boolean {
   return value.length > 0 && Buffer.byteLength(value, 'utf8') <= PII_MAX_STRING_BYTES
@@ -110,12 +132,10 @@ export async function redactPIIFromExecution(
   const { entityTypes } = options
   const language = options.language ?? 'en'
 
-  const units: { key: keyof RedactablePayload; value: unknown }[] = []
-  if (payload.traceSpans !== undefined) units.push({ key: 'traceSpans', value: payload.traceSpans })
-  if (payload.finalOutput !== undefined)
-    units.push({ key: 'finalOutput', value: payload.finalOutput })
-  if (payload.workflowInput !== undefined)
-    units.push({ key: 'workflowInput', value: payload.workflowInput })
+  const units = REDACTABLE_KEYS.filter((key) => payload[key] !== undefined).map((key) => ({
+    key,
+    value: payload[key],
+  }))
 
   const collected: string[] = []
   let totalBytes = 0
@@ -138,6 +158,10 @@ export async function redactPIIFromExecution(
     masked = collected.map(() => REDACTION_FAILED_MARKER)
   } else {
     try {
+      // Lazy import keeps the Python-spawning guardrails module (child_process +
+      // a `lib/guardrails` dir reference) out of the static middleware/RSC graph;
+      // it's only loaded at runtime on the Node log-persist path.
+      const { maskPIIBatch } = await import('@/lib/guardrails/validate_pii')
       masked = await maskPIIBatch(collected, entityTypes, language)
     } catch (error) {
       logger.error('PII masking failed; scrubbing text to avoid leaking PII', {