fix(executor): wrap condition expressions the same way in both paths

The batched script put each expression on its own line inside `Boolean(...)`
so a trailing line comment ended before the closing parenthesis; the per-branch
fallback still inlined `Boolean(${expression})` on one line. That made the
recovery path stricter than the path it recovers — a batch that failed to parse
because of a later branch would fall back and then reject an earlier
comment-bearing branch it should have matched.

Both paths now wrap through `buildBooleanTest`, so they cannot drift again.
Also narrows the evaluation-context boundary from `Record<string, any>` to
`Record<string, unknown>`; the context is only ever serialized, never indexed.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: icecrasher321

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

@@ -499,6 +499,45 @@ describe('ConditionBlockHandler', () => {
       expect(mockExecuteTool).toHaveBeenCalledTimes(2)
     })
 
+    it('emits a batch script a trailing line comment cannot break', async () => {
+      mockExecuteTool.mockResolvedValueOnce(matchedAt(0))
+
+      await handler.execute(mockContext, mockBlock, {
+        conditions: JSON.stringify([
+          { id: 'cond1', title: 'if', value: 'context.value > 5 // gate' },
+          { id: 'else1', title: 'else', value: '' },
+        ]),
+      })
+
+      const [, toolParams] = mockExecuteTool.mock.calls[0]
+      // Compiling is the assertion: a comment that swallowed the closing
+      // parenthesis would fail the whole script at parse time.
+      expect(() => new Function(toolParams.code as string)).not.toThrow()
+    })
+
+    it('wraps a comment-bearing expression the same way when falling back', async () => {
+      // The fallback recovers a batch the sandbox could not parse, so it has to
+      // accept every expression the batch accepts — otherwise the recovery path
+      // rejects a branch the primary path would have matched.
+      mockExecuteTool.mockResolvedValueOnce({
+        success: false,
+        error: 'Invalid JavaScript syntax: Unexpected token',
+      })
+      mockExecuteTool.mockResolvedValueOnce({ success: true, output: { result: true } })
+
+      const result = await handler.execute(mockContext, mockBlock, {
+        conditions: JSON.stringify([
+          { id: 'cond1', title: 'if', value: 'context.value > 5 // gate' },
+          { id: 'cond2', title: 'else if', value: 'context.value ===' },
+          { id: 'else1', title: 'else', value: '' },
+        ]),
+      })
+
+      expect((result as any).selectedOption).toBe('cond1')
+      const [, fallbackParams] = mockExecuteTool.mock.calls[1]
+      expect(() => new Function(fallbackParams.code as string)).not.toThrow()
+    })
+
     it('does not fan a timed-out batch out into one call per branch', async () => {
       mockExecuteTool.mockResolvedValue({
         success: false,

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

@@ -33,6 +33,19 @@ type ConditionEvaluation =
   | { status: 'expression-threw'; index: number; message: string }
   | { status: 'no-verdict'; message: string; timedOut: boolean }
 
+/**
+ * Wraps one expression as a boolean test, on its own line so a trailing line
+ * comment ends before the closing parenthesis instead of swallowing it.
+ *
+ * The batched script and the per-branch fallback both wrap through here. Wrapping
+ * them separately let the two drift: an expression carrying a trailing comment
+ * parsed in the batch and failed in the fallback, so the recovery path rejected
+ * a branch the primary path accepted.
+ */
+function buildBooleanTest(expression: string): string {
+  return `Boolean(\n${expression}\n)`
+}
+
 /**
  * Builds one script that tests each expression in order and reports the index of
  * the first truthy one.
@@ -42,16 +55,13 @@ type ConditionEvaluation =
  * a later expression that throws is still never reached and the run takes the
  * same branch it takes today. The `catch` reports the index it was on as data
  * rather than rethrowing, which is what lets the caller name the failing branch.
- *
- * Each expression sits on its own line inside `Boolean(...)` so a trailing line
- * comment ends before the closing parenthesis instead of swallowing it.
  */
-function buildConditionScript(expressions: string[], evalContext: Record<string, any>): string {
+function buildConditionScript(expressions: string[], evalContext: Record<string, unknown>): string {
   const tests = expressions
     .map(
       (expression, index) =>
         `  __simConditionIndex = ${index}\n` +
-        `  if (Boolean(\n${expression}\n  )) return { matchedIndex: ${index} }`
+        `  if (${buildBooleanTest(expression)}) return { matchedIndex: ${index} }`
     )
     .join('\n')
 
@@ -130,7 +140,7 @@ function isTimeoutFailure(error: string | undefined): boolean {
 async function evaluateConditionList(
   ctx: ExecutionContext,
   expressions: string[],
-  evalContext: Record<string, any>,
+  evalContext: Record<string, unknown>,
   currentNodeId?: string
 ): Promise<ConditionEvaluation> {
   const result = await runConditionCode(
@@ -207,10 +217,10 @@ async function evaluateConditionList(
 async function evaluateSingleCondition(
   ctx: ExecutionContext,
   expression: string,
-  evalContext: Record<string, any>,
+  evalContext: Record<string, unknown>,
   currentNodeId?: string
 ): Promise<boolean> {
-  const code = `const context = ${JSON.stringify(evalContext)};\nreturn Boolean(${expression})`
+  const code = `const context = ${JSON.stringify(evalContext)};\nreturn ${buildBooleanTest(expression)}`
   const result = await runConditionCode(ctx, code, currentNodeId)
 
   if (!result.success) {
@@ -335,8 +345,8 @@ export class ConditionBlockHandler implements BlockHandler {
   private buildEvaluationContext(
     ctx: ExecutionContext,
     sourceBlockId?: string
-  ): Record<string, any> {
-    let evalContext: Record<string, any> = {}
+  ): Record<string, unknown> {
+    let evalContext: Record<string, unknown> = {}
 
     if (sourceBlockId) {
       const sourceOutput = ctx.blockStates.get(sourceBlockId)?.output
@@ -359,7 +369,7 @@ export class ConditionBlockHandler implements BlockHandler {
   private async evaluateConditions(
     conditions: ConditionEntry[],
     outgoingConnections: Array<{ source: string; target: string; sourceHandle?: string }>,
-    evalContext: Record<string, any>,
+    evalContext: Record<string, unknown>,
     ctx: ExecutionContext,
     currentNodeId?: string
   ): Promise<{
@@ -386,7 +396,7 @@ export class ConditionBlockHandler implements BlockHandler {
 
   private async findMatchingCondition(
     conditions: ConditionEntry[],
-    evalContext: Record<string, any>,
+    evalContext: Record<string, unknown>,
     ctx: ExecutionContext,
     currentNodeId?: string
   ): Promise<ConditionEntry | null> {
@@ -433,7 +443,7 @@ export class ConditionBlockHandler implements BlockHandler {
 
   private async findMatchingConditionIndividually(
     conditions: ConditionEntry[],
-    evalContext: Record<string, any>,
+    evalContext: Record<string, unknown>,
     ctx: ExecutionContext,
     currentNodeId?: string
   ): Promise<ConditionEntry | null> {