fix(logs): keep span trees well formed and keep nested child workflows in the skeleton

The structural walk now keeps only span objects and drops a child list that
is not an array, so building a skeleton can never throw on a malformed entry.
The skeleton keeps a nested child workflow's output.childTraceSpans.

Author: waleedlatif1

apps/sim/lib/execution/payloads/serializer.test.ts

@@ -404,6 +404,38 @@ describe('compacting span trees', () => {
     expect(loop.children?.[0].children?.[0].output).toBeUndefined()
   })
 
+  it('drops malformed span entries so an oversized tree still keeps its skeleton', async () => {
+    const spans = spansTooLargeAsAWhole()
+    const iteration = spans[0].children?.[0]
+    iteration?.children?.push(null as unknown as TraceSpan)
+
+    const compacted = await compactBlockOutput(
+      { childTraceSpans: [...spans, undefined as unknown as TraceSpan] },
+      options
+    )
+
+    expectSpanTree(compacted.childTraceSpans)
+    expect(compacted.childTraceSpans).toHaveLength(1)
+  })
+
+  it('keeps nested child workflow trees in the skeleton', async () => {
+    const nestedWorkflowSpan: TraceSpan = {
+      id: 'nested-workflow',
+      name: 'Nested Workflow',
+      type: 'workflow',
+      duration: 2,
+      startTime: '2026-09-29T00:00:00.000Z',
+      endTime: '2026-09-29T00:00:00.002Z',
+      output: { result: 'done', childTraceSpans: spansTooLargeAsAWhole() },
+    }
+
+    const compacted = await compactBlockOutput({ childTraceSpans: [nestedWorkflowSpan] }, options)
+
+    const [nested] = compacted.childTraceSpans as TraceSpan[]
+    expect(nested.output?.result).toBeUndefined()
+    expectSpanTree(nested.output?.childTraceSpans)
+  })
+
   it('drops a child span tree whose skeleton alone exceeds the threshold', async () => {
     const spans = Array.from({ length: 64 }, (_, index) => ({
       ...spansTooLargeAsAWhole()[0],

apps/sim/lib/execution/payloads/serializer.ts

@@ -274,28 +274,28 @@ async function mapEntriesAsync(
 
 /**
  * Compacts a trace span tree without collapsing its structure: `children` and
- * `output.childTraceSpans` stay arrays and only each span's payload fields
- * spill when oversized. See {@link compactChildTraceSpans} for the size bound.
+ * `output.childTraceSpans` stay arrays of spans and only each span's payload
+ * fields spill when oversized. A malformed list or entry is dropped, so every
+ * reader can walk the tree. See {@link compactChildTraceSpans} for the size bound.
  */
 async function compactTraceSpanTree(
   spans: unknown,
   options: CompactExecutionPayloadOptions,
   seen: WeakSet<object>
-): Promise<unknown> {
+): Promise<unknown[] | undefined> {
   if (!Array.isArray(spans)) {
-    return compactExecutionPayload(spans, options)
+    return undefined
   }
-  return Promise.all(spans.map((span) => compactTraceSpan(span, options, seen)))
+  return Promise.all(
+    spans.filter(isRecordLike).map((span) => compactTraceSpan(span, options, seen))
+  )
 }
 
 async function compactTraceSpan(
-  span: unknown,
+  span: Record<string, unknown>,
   options: CompactExecutionPayloadOptions,
   seen: WeakSet<object>
-): Promise<unknown> {
-  if (!isRecordLike(span)) {
-    return compactExecutionPayload(span, options)
-  }
+): Promise<Record<string, unknown>> {
   if (seen.has(span)) {
     return span
   }

apps/sim/lib/logs/execution/trace-spans/summarize.ts

@@ -1,3 +1,4 @@
+import { isRecordLike } from '@sim/utils/object'
 import type { TraceSpan } from '@/lib/logs/types'
 
 export function stripModelToolCallArguments(
@@ -35,7 +36,8 @@ export function stripProviderTimingContent(
 /**
  * A trace span tree with every span's content removed: inputs, outputs,
  * thinking, error text, tool-call arguments, and provider content. Keeps the
- * tree's shape, names, timing, status, and cost.
+ * tree's shape, names, timing, status, and cost, including a nested child
+ * workflow's spans carried on `output.childTraceSpans`.
  */
 export function summarizeTraceSpansWithoutIo(traceSpans?: TraceSpan[]): TraceSpan[] | undefined {
   if (!traceSpans) {
@@ -45,7 +47,7 @@ export function summarizeTraceSpansWithoutIo(traceSpans?: TraceSpan[]): TraceSpa
   return traceSpans.map((span) => {
     const {
       input: _input,
-      output: _output,
+      output,
       children,
       thinking: _thinking,
       errorMessage: _errorMessage,
@@ -54,8 +56,12 @@ export function summarizeTraceSpansWithoutIo(traceSpans?: TraceSpan[]): TraceSpa
       providerTiming,
       ...rest
     } = span
+    const nestedSpans = isRecordLike(output) ? output.childTraceSpans : undefined
     return {
       ...rest,
+      ...(Array.isArray(nestedSpans) && nestedSpans.length
+        ? { output: { childTraceSpans: summarizeTraceSpansWithoutIo(nestedSpans) } }
+        : {}),
       ...(modelToolCalls ? { modelToolCalls: stripModelToolCallArguments(modelToolCalls) } : {}),
       ...(toolCalls ? { toolCalls: stripLegacyToolCallContent(toolCalls) } : {}),
       ...(providerTiming ? { providerTiming: stripProviderTimingContent(providerTiming) } : {}),