fix(logs): close the remaining double logs found in review

Carries failure marks through the scrubbed Pi error and normalizes a
non-Error node failure before logging so the engine sees its mark; drops the
condition handler's and response-size handler's own error lines in favor of
the owning boundary; logs MCP failures once and marks their output; passes
the block id to the API and Function tool calls so the tool line carries it;
attributes custom tool parameter validation and condition expression errors
to the author; checks the whole cause chain for a retryable setup failure
before honoring a mark; and restores the sandbox failure logs, whose adapters
cannot yet tell a provider exception from a non-zero exit.

Author: waleedlatif1

apps/sim/executor/execution/engine.ts

@@ -482,15 +482,17 @@ export class ExecutionEngine {
       /**
        * Block failures were logged by the block executor. This catches a completion-handling
        * fault, which only this frame sees when a concurrent failure already won `executionError`.
+       * Normalized first, as `trackExecution` would, so `run()` sees the mark on the same object.
        */
-      logFailureOnce(this.execLogger, 'Node execution failed', error, {
+      const failure = toError(error)
+      logFailureOnce(this.execLogger, 'Node execution failed', failure, {
         metadata: () =>
-          projectResolvedSecretDiagnosticError(error, this.context.resolvedSecretTraceRegistry, {
+          projectResolvedSecretDiagnosticError(failure, this.context.resolvedSecretTraceRegistry, {
             nodeId,
           }),
         executionId: this.context.executionId,
       })
-      throw error
+      throw failure
     }
   }
 

apps/sim/executor/handlers/api/api-handler.ts

@@ -72,6 +72,7 @@ export class ApiBlockHandler implements BlockHandler {
             isDeployedContext: ctx.isDeployedContext,
             enforceCredentialAccess: ctx.enforceCredentialAccess,
             callChain: ctx.callChain,
+            blockId: block.id,
           },
         },
         { executionContext: ctx }

apps/sim/executor/handlers/condition/condition-handler.ts

@@ -1,6 +1,6 @@
 import { createLogger } from '@sim/logger'
-import { getErrorMessage, toError } from '@sim/utils/errors'
-import { adoptToolFailure } from '@/lib/core/errors/failure-log'
+import { getErrorMessage } from '@sim/utils/errors'
+import { adoptToolFailure, markFailureKind } from '@/lib/core/errors/failure-log'
 import { normalizeStringRecord, normalizeWorkflowVariables } from '@/lib/core/utils/records'
 import {
   isNonRetryableExecutionError,
@@ -508,8 +508,11 @@ export class ConditionBlockHandler implements BlockHandler {
       case 'no-match':
         return null
       case 'expression-threw':
-        logger.error('Failed to evaluate condition', { conditionCount: conditions.length })
-        throw conditionError(conditions[evaluation.index], evaluation.message)
+        /** The author's expression threw; the block executor logs it once. */
+        throw markFailureKind(
+          conditionError(conditions[evaluation.index], evaluation.message),
+          'user'
+        )
       case 'no-verdict':
         if (!evaluation.retryable) {
           throw new NonRetryableExecutionError(
@@ -523,7 +526,6 @@ export class ConditionBlockHandler implements BlockHandler {
         // failure as it stands. The whole list was one call, so no single
         // branch owns that failure; name the first, where evaluation started.
         if (evaluation.timedOut || ctx.abortSignal?.aborted) {
-          logger.error('Failed to evaluate conditions', { conditionCount: conditions.length })
           throw conditionError(conditions[0], evaluation.message)
         }
         logger.warn('Batched condition evaluation produced no verdict, retrying one at a time', {
@@ -549,7 +551,6 @@ export class ConditionBlockHandler implements BlockHandler {
         )
         if (conditionMet) return condition
       } catch (error) {
-        logger.error('Failed to evaluate condition', { errorName: toError(error).name })
         throw conditionError(
           condition,
           getErrorMessage(error, 'Condition evaluation failed'),

apps/sim/executor/handlers/function/function-handler.ts

@@ -107,6 +107,7 @@ export class FunctionBlockHandler implements BlockHandler {
         userId: ctx.userId,
         isDeployedContext: ctx.isDeployedContext,
         enforceCredentialAccess: ctx.enforceCredentialAccess,
+        blockId: block.id,
       },
     }
 

apps/sim/executor/handlers/pi/core/redaction.ts

@@ -1,4 +1,5 @@
 import { getErrorMessage } from '@sim/utils/errors'
+import { inheritFailureMarks } from '@/lib/core/errors/failure-log'
 import type { PiEvent } from '@/executor/handlers/pi/core/events'
 
 /**
@@ -36,11 +37,14 @@ export function getScrubbedPiErrorMessage(
   return scrubPiSecrets(getErrorMessage(error, fallback), secrets)
 }
 
-/** Creates a boundary-safe error without retaining a potentially secret-bearing cause. */
+/**
+ * Creates a boundary-safe error without retaining a potentially secret-bearing cause. The failure
+ * marks still cross, so a GitHub tool failure the tool layer logged is not logged again.
+ */
 export function createScrubbedPiError(
   error: unknown,
   secrets: readonly string[],
   fallback?: string
 ): Error {
-  return new Error(getScrubbedPiErrorMessage(error, secrets, fallback))
+  return inheritFailureMarks(new Error(getScrubbedPiErrorMessage(error, secrets, fallback)), error)
 }

apps/sim/lib/core/errors/failure-log.test.ts

@@ -26,6 +26,13 @@ describe('classifyFailure', () => {
     expect(classifyFailure(wrapped)).toBe('internal')
   })
 
+  it('keeps a retryable setup failure internal even beneath a marked wrapper', () => {
+    const setup = new RetryableSetupError('setup')
+    expect(classifyFailure(markFailureKind(new Error('wrapped', { cause: setup }), 'user'))).toBe(
+      'internal'
+    )
+  })
+
   it('keeps a retryable setup failure internal even when its cause was the author’s', () => {
     const cause = markFailureKind(new Error('missing field'), 'user')
     expect(classifyFailure(new RetryableSetupError('setup', { cause }))).toBe('internal')

apps/sim/lib/core/errors/failure-log.ts

@@ -63,10 +63,10 @@ export function markFailureKind<T>(error: T, kind: FailureKind): T {
  */
 export function classifyFailure(error: unknown): FailureKind {
   if (findDatabaseQueryError(error)) return 'internal'
+  const chain = causeChain(error)
+  if (chain.some(isRetryableSetupError)) return 'internal'
 
-  for (const link of causeChain(error)) {
-    if (isRetryableSetupError(link)) return 'internal'
-
+  for (const link of chain) {
     const marked = failureKinds.get(link)
     if (marked) return marked
     if (link instanceof UserFailure) return 'user'

apps/sim/lib/execution/remote-sandbox/index.ts

@@ -958,14 +958,10 @@ async function executeInSandboxWithinBudget(
 
     if (execution.error) {
       const errorMessage = `${execution.error.name}: ${execution.error.value}`
-      /** The author's code raising is logged once by the tool boundary; a provider failure is ours. */
-      if (execution.providerFailure) {
-        logger.error('Sandbox execution failed', {
-          sandboxId,
-          hasTraceback: Boolean(execution.error.traceback),
-          providerFailure: execution.providerFailure,
-        })
-      }
+      logger.error('Sandbox execution failed', {
+        sandboxId,
+        hasTraceback: Boolean(execution.error.traceback),
+      })
       const executionResult = {
         result: null,
         stdout: execution.error.traceback || errorMessage,
@@ -1157,14 +1153,10 @@ async function executeShellInSandboxWithinBudget(
       // back to stdout for the real command output before the generic message.
       const errorMessage =
         result.stderr || result.stdout || `Process exited with code ${result.exitCode}`
-      /** A non-zero exit is logged once by the tool boundary; a provider failure is ours. */
-      if (result.providerFailure) {
-        logger.error('Sandbox shell execution error', {
-          sandboxId,
-          exitCode: result.exitCode,
-          providerFailure: result.providerFailure,
-        })
-      }
+      logger.error('Sandbox shell execution error', {
+        sandboxId,
+        exitCode: result.exitCode,
+      })
       const executionResult = {
         result: null,
         stdout,