diff --git a/apps/sim/executor/variables/resolver.ts b/apps/sim/executor/variables/resolver.ts
index 4b57450d705..c4076a21d25 100644
--- a/apps/sim/executor/variables/resolver.ts
+++ b/apps/sim/executor/variables/resolver.ts
@@ -176,6 +176,36 @@ type CodeScanMode =
   | { type: 'block-comment' }
   | { type: 'regex'; inCharacterClass: boolean }
 
+/**
+ * Lexer progress through one code template, shared by every reference spliced into it.
+ * References are formatted in ascending offset order, so each quote lookup resumes where the
+ * previous one stopped: rescanning from offset 0 per reference is quadratic in template size.
+ */
+interface CodeTemplateScan {
+  readonly template: string
+  quoteCursor?: CodeQuoteCursor
+  shellQuoteCursor?: ShellQuoteCursor
+  hasModuleDependencySyntax?: boolean
+}
+
+interface CodeQuoteCursor {
+  language: string | undefined
+  queriedIndex: number
+  position: number
+  modes: CodeScanMode[]
+  lastSignificantIndex: number
+  openParenIsControlHead: boolean[]
+  identifierFollowsPropertyAccess: boolean
+  controlHeadParenCloses: Set<number>
+  regexCloseIndices: Set<number>
+}
+
+interface ShellQuoteCursor {
+  queriedIndex: number
+  position: number
+  quoteContext: ShellQuoteContext
+}
+
 /**
  * Characters after which a `/` opens a regular expression rather than dividing.
  *
@@ -516,6 +546,7 @@ export class VariableResolver {
     let replacementError: Error | null = null
     let displayResult = ''
     let displayCursor = 0
+    const scan: CodeTemplateScan = { template }
 
     const result = await replaceValidReferencesAsync(template, async (match, index) => {
       if (replacementError) return match
@@ -527,7 +558,7 @@ export class VariableResolver {
           match,
           resolutionContext,
           language,
-          template,
+          scan,
           index,
           contextVarAccumulator
         )
@@ -540,7 +571,7 @@ export class VariableResolver {
           match,
           resolutionContext,
           language,
-          template,
+          scan,
           index,
           contextVarAccumulator
         )
@@ -571,7 +602,7 @@ export class VariableResolver {
             const lazyReplacement = this.formatLazyLargeValueReference(
               varName,
               language,
-              template,
+              scan,
               index
             )
             if (!lazyReplacement) {
@@ -582,7 +613,7 @@ export class VariableResolver {
             const lazyReplacement = this.formatLazyLargeArrayManifestReference(
               varName,
               language,
-              template,
+              scan,
               index
             )
             if (!lazyReplacement) {
@@ -596,7 +627,7 @@ export class VariableResolver {
               ctx,
               effectiveValue,
               language,
-              template,
+              scan,
               offloadState
             )
             if (offloadedRef) {
@@ -605,19 +636,13 @@ export class VariableResolver {
               // maybeOffload only returns a ref when the JS runtime helpers are usable —
               // the same guard formatLazyLargeValueReference needs — so it is non-null here.
               replacement =
-                this.formatLazyLargeValueReference(varName, language, template, index) ??
-                this.formatContextVariableReference(
-                  varName,
-                  language,
-                  template,
-                  index,
-                  effectiveValue
-                )
+                this.formatLazyLargeValueReference(varName, language, scan, index) ??
+                this.formatContextVariableReference(varName, language, scan, index, effectiveValue)
             } else {
               replacement = this.formatContextVariableReference(
                 varName,
                 language,
-                template,
+                scan,
                 index,
                 effectiveValue
               )
@@ -627,7 +652,7 @@ export class VariableResolver {
           displayResult += this.formatDisplayValueForCodeContext(
             displayValue,
             language,
-            template,
+            scan,
             index
           )
           return replacement
@@ -644,17 +669,12 @@ export class VariableResolver {
         if (isLargeValueRef(effectiveValue)) {
           const varName = `__blockRef_${Object.keys(contextVarAccumulator).length}`
           contextVarAccumulator[varName] = effectiveValue
-          const lazyReplacement = this.formatLazyLargeValueReference(
-            varName,
-            language,
-            template,
-            index
-          )
+          const lazyReplacement = this.formatLazyLargeValueReference(varName, language, scan, index)
           if (lazyReplacement) {
             displayResult += this.formatDisplayValueForCodeContext(
               effectiveValue,
               language,
-              template,
+              scan,
               index
             )
             return lazyReplacement
@@ -668,14 +688,14 @@ export class VariableResolver {
           const lazyReplacement = this.formatLazyLargeArrayManifestReference(
             varName,
             language,
-            template,
+            scan,
             index
           )
           if (lazyReplacement) {
             displayResult += this.formatDisplayValueForCodeContext(
               effectiveValue,
               language,
-              template,
+              scan,
               index
             )
             return lazyReplacement
@@ -702,14 +722,14 @@ export class VariableResolver {
         const replacement = this.formatContextVariableReference(
           varName,
           language,
-          template,
+          scan,
           index,
           effectiveValue
         )
         displayResult += this.formatDisplayValueForCodeContext(
           effectiveValue,
           language,
-          template,
+          scan,
           index
         )
         return replacement
@@ -742,7 +762,7 @@ export class VariableResolver {
     reference: string,
     context: ResolutionContext,
     language: string | undefined,
-    template: string,
+    scan: CodeTemplateScan,
     matchIndex: number,
     contextVarAccumulator: Record<string, unknown>
   ): Promise<{ replacement: string; display: string } | null> {
@@ -773,7 +793,7 @@ export class VariableResolver {
     }
 
     return {
-      replacement: this.formatContextVariablePathReference(varName, language, template, matchIndex),
+      replacement: this.formatContextVariablePathReference(varName, language, scan, matchIndex),
       display: reference,
     }
   }
@@ -800,14 +820,14 @@ export class VariableResolver {
   private formatContextVariablePathReference(
     varName: string,
     language: string | undefined,
-    template: string,
+    scan: CodeTemplateScan,
     matchIndex: number
   ): string {
     if (language === 'shell') {
-      return this.formatShellContextVariableReference(varName, template, matchIndex, '')
+      return this.formatShellContextVariableReference(varName, scan, matchIndex, '')
     }
 
-    const quoteContext = this.getCodeStringQuoteContext(template, matchIndex, language)
+    const quoteContext = this.getCodeStringQuoteContext(scan, matchIndex, language)
 
     if (language === 'python') {
       const expression = `globals()[${JSON.stringify(varName)}]`
@@ -833,11 +853,11 @@ export class VariableResolver {
     reference: string,
     context: ResolutionContext,
     language: string | undefined,
-    template: string,
+    scan: CodeTemplateScan,
     matchIndex: number,
     contextVarAccumulator: Record<string, unknown>
   ): Promise<{ replacement: string; display: string } | null> {
-    if (!this.canUseJavaScriptRuntimeHelpers(language, template)) {
+    if (!this.canUseJavaScriptRuntimeHelpers(language, scan)) {
       return null
     }
 
@@ -862,7 +882,7 @@ export class VariableResolver {
     const lazyExpression = `(await sim.files.readBase64(${fileExpression}))`
 
     return {
-      replacement: this.formatJavaScriptAsyncExpression(lazyExpression, template, matchIndex),
+      replacement: this.formatJavaScriptAsyncExpression(lazyExpression, scan, matchIndex),
       display: reference,
     }
   }
@@ -883,12 +903,12 @@ export class VariableResolver {
     ctx: ExecutionContext,
     value: unknown,
     language: string | undefined,
-    template: string,
+    scan: CodeTemplateScan,
     offloadState: FunctionContextOffloadState
   ): Promise<LargeValueRef | null> {
     // Lazy re-reading is only available in the JavaScript isolated-vm runtime; other
     // runtimes have no broker to materialize a ref, so the value must stay inline.
-    if (!this.canUseJavaScriptRuntimeHelpers(language, template)) {
+    if (!this.canUseJavaScriptRuntimeHelpers(language, scan)) {
       return null
     }
     if (!ctx.workspaceId || !ctx.workflowId || !ctx.executionId) {
@@ -932,15 +952,15 @@ export class VariableResolver {
   private formatLazyLargeValueReference(
     varName: string,
     language: string | undefined,
-    template: string,
+    scan: CodeTemplateScan,
     matchIndex: number
   ): string | null {
-    if (!this.canUseJavaScriptRuntimeHelpers(language, template)) {
+    if (!this.canUseJavaScriptRuntimeHelpers(language, scan)) {
       return null
     }
 
     const expression = `(await sim.values.read(globalThis[${JSON.stringify(varName)}]))`
-    return this.formatJavaScriptAsyncExpression(expression, template, matchIndex, {
+    return this.formatJavaScriptAsyncExpression(expression, scan, matchIndex, {
       stringifyInStringContext: true,
     })
   }
@@ -948,15 +968,15 @@ export class VariableResolver {
   private formatLazyLargeArrayManifestReference(
     varName: string,
     language: string | undefined,
-    template: string,
+    scan: CodeTemplateScan,
     matchIndex: number
   ): string | null {
-    if (!this.canUseJavaScriptRuntimeHelpers(language, template)) {
+    if (!this.canUseJavaScriptRuntimeHelpers(language, scan)) {
       return null
     }
 
     const expression = `(await sim.values.readArray(globalThis[${JSON.stringify(varName)}]))`
-    return this.formatJavaScriptAsyncExpression(expression, template, matchIndex, {
+    return this.formatJavaScriptAsyncExpression(expression, scan, matchIndex, {
       stringifyInStringContext: true,
     })
   }
@@ -996,11 +1016,11 @@ export class VariableResolver {
 
   private formatJavaScriptAsyncExpression(
     expression: string,
-    template: string,
+    scan: CodeTemplateScan,
     matchIndex: number,
     options: { stringifyInStringContext?: boolean } = {}
   ): string {
-    const quoteContext = this.getCodeStringQuoteContext(template, matchIndex, 'javascript')
+    const quoteContext = this.getCodeStringQuoteContext(scan, matchIndex, 'javascript')
     const stringExpression = options.stringifyInStringContext
       ? `JSON.stringify(${expression})`
       : expression
@@ -1015,11 +1035,15 @@ export class VariableResolver {
     return expression
   }
 
-  private canUseJavaScriptRuntimeHelpers(language: string | undefined, template: string): boolean {
+  private canUseJavaScriptRuntimeHelpers(
+    language: string | undefined,
+    scan: CodeTemplateScan
+  ): boolean {
     if (language !== 'javascript') {
       return false
     }
-    return !this.hasJavaScriptModuleDependencySyntax(template)
+    scan.hasModuleDependencySyntax ??= this.hasJavaScriptModuleDependencySyntax(scan.template)
+    return !scan.hasModuleDependencySyntax
   }
 
   private hasJavaScriptModuleDependencySyntax(template: string): boolean {
@@ -1199,10 +1223,11 @@ export class VariableResolver {
    * author did not write, silently, while admitting one too many only costs the narrowing.
    */
   private readsEnvironmentMap(expression: string): boolean {
+    const scan: CodeTemplateScan = { template: expression }
     ENVIRONMENT_MAP_IDENTIFIER.lastIndex = 0
     let match = ENVIRONMENT_MAP_IDENTIFIER.exec(expression)
     while (match !== null) {
-      if (this.getCodeStringQuoteContext(expression, match.index, 'javascript') === null) {
+      if (this.getCodeStringQuoteContext(scan, match.index, 'javascript') === null) {
         return true
       }
       match = ENVIRONMENT_MAP_IDENTIFIER.exec(expression)
@@ -1265,13 +1290,13 @@ export class VariableResolver {
   private formatContextVariableReference(
     varName: string,
     language: string | undefined,
-    template: string,
+    scan: CodeTemplateScan,
     matchIndex: number,
     value: unknown
   ): string {
     if (language === 'python') {
       const expression = `globals()[${JSON.stringify(varName)}]`
-      const quoteContext = this.getCodeStringQuoteContext(template, matchIndex, language)
+      const quoteContext = this.getCodeStringQuoteContext(scan, matchIndex, language)
       if (this.isPythonStringQuoteContext(quoteContext)) {
         const quote = this.getCodeStringQuoteToken(quoteContext)
         return `${quote} + json.dumps(${expression}) + ${quote}`
@@ -1280,11 +1305,11 @@ export class VariableResolver {
     }
 
     if (language === 'shell') {
-      return this.formatShellContextVariableReference(varName, template, matchIndex, value)
+      return this.formatShellContextVariableReference(varName, scan, matchIndex, value)
     }
 
     const expression = `globalThis[${JSON.stringify(varName)}]`
-    const quoteContext = this.getCodeStringQuoteContext(template, matchIndex, language)
+    const quoteContext = this.getCodeStringQuoteContext(scan, matchIndex, language)
     if (quoteContext === 'template') {
       return `\${JSON.stringify(${expression})}`
     }
@@ -1318,7 +1343,7 @@ export class VariableResolver {
   private formatDisplayValueForCodeContext(
     value: unknown,
     language: string | undefined,
-    template: string,
+    scan: CodeTemplateScan,
     matchIndex: number
   ): string {
     // Offloaded large values carry only a storage ref (or array manifest), never the
@@ -1332,15 +1357,19 @@ export class VariableResolver {
     }
 
     if (language === 'shell') {
-      return this.formatShellDisplayValue(value, template, matchIndex)
+      return this.formatShellDisplayValue(value, scan, matchIndex)
     }
 
     return this.blockResolver.formatValueForBlock(value, BlockType.FUNCTION, language)
   }
 
-  private formatShellDisplayValue(value: unknown, template: string, matchIndex: number): string {
+  private formatShellDisplayValue(
+    value: unknown,
+    scan: CodeTemplateScan,
+    matchIndex: number
+  ): string {
     const text = this.stringifyShellDisplayValue(value)
-    const quoteContext = this.getShellQuoteContext(template, matchIndex)
+    const quoteContext = this.getShellQuoteContext(scan, matchIndex)
     if (quoteContext === 'double') {
       return text.replace(/["\\$`]/g, '\\$&')
     }
@@ -1362,19 +1391,33 @@ export class VariableResolver {
   }
 
   private getCodeStringQuoteContext(
-    template: string,
+    scan: CodeTemplateScan,
     index: number,
     language: string | undefined
   ): CodeStringQuoteContext {
+    const template = scan.template
     const isPython = language === 'python'
-    const modes: CodeScanMode[] = [{ type: 'normal' }]
-    let lastSignificantIndex = -1
-    const openParenIsControlHead: boolean[] = []
-    let identifierFollowsPropertyAccess = false
-    const controlHeadParenCloses = new Set<number>()
-    const regexCloseIndices = new Set<number>()
+    let cursor = scan.quoteCursor
+    if (!cursor || cursor.language !== language || index < cursor.queriedIndex) {
+      cursor = {
+        language,
+        queriedIndex: 0,
+        position: 0,
+        modes: [{ type: 'normal' }],
+        lastSignificantIndex: -1,
+        openParenIsControlHead: [],
+        identifierFollowsPropertyAccess: false,
+        controlHeadParenCloses: new Set(),
+        regexCloseIndices: new Set(),
+      }
+      scan.quoteCursor = cursor
+    }
+    cursor.queriedIndex = index
+    const { modes, openParenIsControlHead, controlHeadParenCloses, regexCloseIndices } = cursor
+    let { lastSignificantIndex, identifierFollowsPropertyAccess } = cursor
 
-    for (let i = 0; i < index; i++) {
+    let i = cursor.position
+    for (; i < index; i++) {
       const char = template[i]
       const next = template[i + 1]
       const mode = modes[modes.length - 1]
@@ -1603,6 +1646,9 @@ export class VariableResolver {
         modes.push({ type: 'template' })
       }
     }
+    cursor.position = i
+    cursor.lastSignificantIndex = lastSignificantIndex
+    cursor.identifierFollowsPropertyAccess = identifierFollowsPropertyAccess
 
     const mode = modes[modes.length - 1]
     if (mode.type === 'regex') {
@@ -1622,12 +1668,12 @@ export class VariableResolver {
 
   private formatShellContextVariableReference(
     varName: string,
-    template: string,
+    scan: CodeTemplateScan,
     matchIndex: number,
     value: unknown
   ): string {
     const expansion = `\${${varName}}`
-    const quoteContext = this.getShellQuoteContext(template, matchIndex)
+    const quoteContext = this.getShellQuoteContext(scan, matchIndex)
     if (quoteContext === 'double') {
       return expansion
     }
@@ -1650,34 +1696,39 @@ export class VariableResolver {
     return quotedExpansion
   }
 
-  private getShellQuoteContext(template: string, index: number): ShellQuoteContext {
-    let quoteContext: ShellQuoteContext = null
+  private getShellQuoteContext(scan: CodeTemplateScan, index: number): ShellQuoteContext {
+    const template = scan.template
+    let cursor = scan.shellQuoteCursor
+    if (!cursor || index < cursor.queriedIndex) {
+      cursor = { queriedIndex: 0, position: 0, quoteContext: null }
+      scan.shellQuoteCursor = cursor
+    }
+    cursor.queriedIndex = index
 
-    for (let i = 0; i < index; i++) {
+    let i = cursor.position
+    for (; i < index; i++) {
       const char = template[i]
 
-      if (quoteContext === null && this.isShellCommentStart(template, i)) {
+      if (cursor.quoteContext === null && this.isShellCommentStart(template, i)) {
         const nextNewline = template.indexOf('\n', i + 1)
-        if (nextNewline === -1 || nextNewline >= index) {
-          break
-        }
-        i = nextNewline
+        i = nextNewline === -1 ? template.length : nextNewline
         continue
       }
 
-      if (char === '\\' && quoteContext !== 'single') {
+      if (char === '\\' && cursor.quoteContext !== 'single') {
         i++
         continue
       }
 
-      if (char === "'" && quoteContext !== 'double') {
-        quoteContext = quoteContext === 'single' ? null : 'single'
-      } else if (char === '"' && quoteContext !== 'single') {
-        quoteContext = quoteContext === 'double' ? null : 'double'
+      if (char === "'" && cursor.quoteContext !== 'double') {
+        cursor.quoteContext = cursor.quoteContext === 'single' ? null : 'single'
+      } else if (char === '"' && cursor.quoteContext !== 'single') {
+        cursor.quoteContext = cursor.quoteContext === 'double' ? null : 'double'
       }
     }
+    cursor.position = i
 
-    return quoteContext
+    return cursor.quoteContext
   }
 
   private isShellCommentStart(template: string, index: number): boolean {
@@ -1791,6 +1842,7 @@ export class VariableResolver {
     }
 
     let replacementError: Error | null = null
+    const scan: CodeTemplateScan = { template }
 
     let projectedReferenceResult = ''
     let projectedReferenceCursor = 0
@@ -1825,7 +1877,7 @@ export class VariableResolver {
           return formatted
         }
         if (typeof resolved === 'object' && resolved !== null) {
-          const formatted = this.formatConditionJson(resolved, template, index)
+          const formatted = this.formatConditionJson(resolved, scan, index)
           projectedReferenceResult += containsResolvedSecret ? match : formatted
           return formatted
         }
@@ -1872,9 +1924,9 @@ export class VariableResolver {
    * surrounding context wrongly, and a quote inside a regex literal is enough to do that.
    * Splicing raw JSON would make that heuristic load-bearing for injection.
    */
-  private formatConditionJson(value: object, template: string, matchIndex: number): string {
+  private formatConditionJson(value: object, scan: CodeTemplateScan, matchIndex: number): string {
     const escaped = escapeInertStringContent(JSON.stringify(value))
-    const quoteContext = this.getCodeStringQuoteContext(template, matchIndex, 'javascript')
+    const quoteContext = this.getCodeStringQuoteContext(scan, matchIndex, 'javascript')
     return quoteContext === null ? `JSON.parse('${escaped}')` : escaped
   }
 
diff --git a/apps/sim/lib/execution/code-placeholders/compiler.test.ts b/apps/sim/lib/execution/code-placeholders/compiler.test.ts
index ef5d2434060..d7ba6b94d1c 100644
--- a/apps/sim/lib/execution/code-placeholders/compiler.test.ts
+++ b/apps/sim/lib/execution/code-placeholders/compiler.test.ts
@@ -1611,3 +1611,17 @@ describe('compiler failure classification', () => {
     ).rejects.toBeInstanceOf(CodePlaceholderCompileError)
   })
 })
+
+describe('python keyword lookback', () => {
+  it('terminates when the only keyword match on the line sits inside a string', async () => {
+    const compiled = await compileCodePlaceholders({
+      code: 'x = """\nlambda""" + {{A}}\n',
+      language: CodeLanguage.Python,
+      params: { A: 'v' },
+    })
+
+    expect(compiled.code).toBe(
+      `x = """\nlambda""" + (${compiled.bindings[0].name} if True else None)\n`
+    )
+  })
+})
diff --git a/apps/sim/lib/execution/code-placeholders/javascript.ts b/apps/sim/lib/execution/code-placeholders/javascript.ts
index 27f503ec93e..36cdb05f564 100644
--- a/apps/sim/lib/execution/code-placeholders/javascript.ts
+++ b/apps/sim/lib/execution/code-placeholders/javascript.ts
@@ -3,7 +3,8 @@ import {
   applySourceEdits,
   CodePlaceholderCompileError,
   createCodePlaceholderCompilationContext,
-  isOffsetInRanges,
+  createOffsetRangeLookup,
+  partitionPoint,
   type SourceEdit,
 } from '@/lib/execution/code-placeholders/shared'
 import type {
@@ -357,27 +358,32 @@ function collectAnnexBHtmlCommentRanges(
   source: string,
   sourceFile: ts.SourceFile
 ): AnnexBHtmlCommentRange[] {
-  const protectedRanges = [
+  const isProtected = createOffsetRangeLookup([
     ...collectStandardCommentRanges(source, sourceFile),
     ...collectJavaScriptLiteralRanges(sourceFile),
-  ]
+  ])
   const ranges: AnnexBHtmlCommentRange[] = []
 
+  // Reused across lines: searching from every line start rescans to EOF when no marker exists.
+  let nextOpenMarker = source.indexOf('<!--')
   let lineStart = 0
   while (lineStart < source.length) {
     const newline = source.indexOf('\n', lineStart)
     const lineEnd = newline === -1 ? source.length : newline
     const leadingWhitespace = /^\s*/.exec(source.slice(lineStart, lineEnd))?.[0].length ?? 0
     const closeMarker = lineStart + leadingWhitespace
-    if (source.startsWith('-->', closeMarker) && !isOffsetInRanges(closeMarker, protectedRanges)) {
+    if (source.startsWith('-->', closeMarker) && !isProtected(closeMarker)) {
       ranges.push({ start: closeMarker, end: lineEnd, markerLength: 3 })
       lineStart = newline === -1 ? source.length : newline + 1
       continue
     }
 
-    let openMarker = source.indexOf('<!--', lineStart)
+    if (nextOpenMarker !== -1 && nextOpenMarker < lineStart) {
+      nextOpenMarker = source.indexOf('<!--', lineStart)
+    }
+    let openMarker = nextOpenMarker
     while (openMarker >= 0 && openMarker < lineEnd) {
-      if (!isOffsetInRanges(openMarker, protectedRanges)) {
+      if (!isProtected(openMarker)) {
         ranges.push({ start: openMarker, end: lineEnd, markerLength: 4 })
         break
       }
@@ -714,10 +720,10 @@ export async function compileJavaScriptPlaceholders(
     ts.ScriptKind.JS
   )
   if (!input.analysisOnly) assertSyntacticallyValidJavaScript(source, input.code, sourceFile)
-  const commentRanges: Array<[number, number]> = [
+  const isInComment = createOffsetRangeLookup([
     ...collectStandardCommentRanges(parserSource, sourceFile),
     ...htmlCommentRanges.map(({ start, end }) => [start, end] as [number, number]),
-  ]
+  ])
   const itemByRange = new Map(
     sentinelOccurrences.map((item) => [`${item.occurrence.start}:${item.occurrence.end}`, item])
   )
@@ -757,12 +763,19 @@ export async function compileJavaScriptPlaceholders(
       if (ts.isTemplateExpression(node.template)) {
         for (const span of node.template.templateSpans) visit(span.expression)
       }
-      const nestedEdits = edits.splice(nestedEditStart)
+      // A stable sort: applySourceEdits keeps input order among edits with equal bounds.
+      const nestedEdits = edits
+        .splice(nestedEditStart)
+        .sort((left, right) => left.start - right.start)
       const transformedNodeText = (child: ts.Node): string => {
         const childStart = child.getStart(sourceFile)
         const childEnd = child.getEnd()
         const childEdits = nestedEdits
-          .filter((edit) => edit.start >= childStart && edit.end <= childEnd)
+          .slice(
+            partitionPoint(nestedEdits, (edit) => edit.start < childStart),
+            partitionPoint(nestedEdits, (edit) => edit.start <= childEnd)
+          )
+          .filter((edit) => edit.end <= childEnd)
           .map((edit) => ({
             ...edit,
             start: edit.start - childStart,
@@ -873,7 +886,7 @@ export async function compileJavaScriptPlaceholders(
 
     if (ts.isIdentifier(node)) {
       const item = itemByRange.get(`${node.getStart(sourceFile)}:${node.getEnd()}`)
-      if (!item || isOffsetInRanges(item.occurrence.start, commentRanges)) return
+      if (!item || isInComment(item.occurrence.start)) return
       const resolved = context.resolve(item.occurrence)
       if (!resolved) return
       if (isDeclarationIdentifier(node) || isWriteIdentifier(node)) {
@@ -919,7 +932,7 @@ export async function compileJavaScriptPlaceholders(
   visit(sourceFile)
 
   for (const item of sentinelOccurrences) {
-    if (isOffsetInRanges(item.occurrence.start, commentRanges)) continue
+    if (isInComment(item.occurrence.start)) continue
     if (!context.hasValue(item.occurrence.name) || consumed.has(item.occurrence)) continue
     rejectUnsupported(item, 'this JavaScript syntax position')
   }
diff --git a/apps/sim/lib/execution/code-placeholders/python.ts b/apps/sim/lib/execution/code-placeholders/python.ts
index eb8dc973d0d..4bc25224c39 100644
--- a/apps/sim/lib/execution/code-placeholders/python.ts
+++ b/apps/sim/lib/execution/code-placeholders/python.ts
@@ -4,7 +4,9 @@ import {
   CodePlaceholderCompileError,
   CodePlaceholderInvariantError,
   createCodePlaceholderCompilationContext,
-  isOffsetInRanges,
+  createOffsetRangeLookup,
+  occurrencesWithin,
+  partitionPoint,
   type SourceEdit,
 } from '@/lib/execution/code-placeholders/shared'
 import type {
@@ -31,21 +33,14 @@ function isIdentifierCharacter(character: string | undefined): boolean {
   return character !== undefined && /[A-Za-z0-9_]/.test(character)
 }
 
-function findLastPythonKeyword(
-  value: string,
-  keyword: string,
-  isIgnored: (index: number) => boolean = () => false
-): number {
-  let index = value.lastIndexOf(keyword)
-  while (index >= 0) {
-    const before = value[index - 1]
-    const after = value[index + keyword.length]
-    if (!isIdentifierCharacter(before) && !isIdentifierCharacter(after) && !isIgnored(index)) {
-      return index
-    }
-    index = value.lastIndexOf(keyword, index - 1)
-  }
-  return -1
+/** The token wholly containing `occurrence`, found by bisection over ordered, disjoint tokens. */
+function findContainingToken(
+  tokens: readonly PythonStringToken[],
+  occurrence: CodePlaceholderOccurrence
+): PythonStringToken | undefined {
+  const token =
+    tokens[partitionPoint(tokens, (candidate) => candidate.start <= occurrence.start) - 1]
+  return token && occurrence.end <= token.end ? token : undefined
 }
 
 function readPythonStringStart(
@@ -247,22 +242,24 @@ function createSentinel(code: string): string {
   throw new CodePlaceholderInvariantError('Unable to allocate a collision-free Python marker')
 }
 
+/** `comments` are ordered and disjoint; the scan starts at the first that can overlap the gap. */
 function pythonTriviaGap(
   code: string,
   start: number,
   end: number,
-  comments: ReadonlyArray<[number, number]>
+  comments: ReadonlyArray<[number, number]>,
+  firstComment: number
 ): string {
-  let gap = code.slice(start, end)
-  for (const [commentStart, commentEnd] of comments) {
-    const overlapStart = Math.max(start, commentStart)
-    const overlapEnd = Math.min(end, commentEnd)
+  let gap = ''
+  let cursor = start
+  for (let index = firstComment; index < comments.length && comments[index][0] < end; index++) {
+    const overlapStart = Math.max(cursor, comments[index][0])
+    const overlapEnd = Math.min(end, comments[index][1])
     if (overlapStart >= overlapEnd) continue
-    const relativeStart = overlapStart - start
-    const relativeEnd = overlapEnd - start
-    gap = `${gap.slice(0, relativeStart)}${' '.repeat(relativeEnd - relativeStart)}${gap.slice(relativeEnd)}`
+    gap += `${code.slice(cursor, overlapStart)}${' '.repeat(overlapEnd - overlapStart)}`
+    cursor = overlapEnd
   }
-  return gap
+  return gap + code.slice(cursor, end)
 }
 
 function groupAdjacentStrings(
@@ -271,10 +268,17 @@ function groupAdjacentStrings(
   comments: ReadonlyArray<[number, number]>
 ): PythonStringToken[][] {
   const groups: PythonStringToken[][] = []
+  let firstComment = 0
   for (const token of strings) {
     const current = groups.at(-1)
     const previous = current?.at(-1)
-    const gap = previous ? pythonTriviaGap(code, previous.end, token.start, comments) : ''
+    let gap = ''
+    if (previous) {
+      while (firstComment < comments.length && comments[firstComment][1] <= previous.end) {
+        firstComment += 1
+      }
+      gap = pythonTriviaGap(code, previous.end, token.start, comments, firstComment)
+    }
     const sameLogicalExpression =
       !/[\r\n]/.test(gap) ||
       (previous !== undefined && previous.bracketDepth > 0 && token.bracketDepth > 0) ||
@@ -297,18 +301,28 @@ type FStringPosition =
   | 'comment'
   | 'debug'
 
+interface FStringExpressionState {
+  depth: number
+  parentheses: number
+  brackets: number
+}
+
+/**
+ * Whether a debug `=` follows `start` before its replacement field closes.
+ *
+ * `decided` holds answers for later placeholders in the same token. Reaching one of them in
+ * exactly the state its own scan started from means the rest of this scan would repeat that
+ * one, so its answer is reused: a field holding many placeholders is scanned once, not once each.
+ */
 function hasFStringDebugMarker(
   code: string,
   token: PythonStringToken,
   start: number,
-  initialDepth: number,
-  initialParentheses: number,
-  initialBrackets: number
+  initial: FStringExpressionState,
+  decided: ReadonlyMap<number, FStringExpressionState & { debug: boolean }>
 ): boolean {
   const contentEnd = token.end - token.quoteLength
-  let depth = initialDepth
-  let parentheses = initialParentheses
-  let brackets = initialBrackets
+  let { depth, parentheses, brackets } = initial
   let nestedString: { delimiter: string } | null = null
   let comment = false
 
@@ -338,6 +352,15 @@ function hasFStringDebugMarker(
       continue
     }
     if (code.startsWith('{{', index)) {
+      const later = decided.get(index)
+      if (
+        later &&
+        later.depth === depth &&
+        later.parentheses === parentheses &&
+        later.brackets === brackets
+      ) {
+        return later.debug
+      }
       const placeholderEnd = code.indexOf('}}', index + 2)
       if (placeholderEnd !== -1) {
         index = placeholderEnd + 1
@@ -370,12 +393,16 @@ function hasFStringDebugMarker(
   return false
 }
 
-function getFStringPosition(
+/**
+ * Classifies every placeholder offset (ascending) inside one string token in a single pass.
+ * Re-scanning the token from its start for each placeholder is quadratic in user code.
+ */
+function getFStringPositions(
   code: string,
   token: PythonStringToken,
-  absoluteOffset: number
-): FStringPosition {
-  if (!/f/i.test(token.prefix)) return 'literal'
+  offsets: readonly number[]
+): FStringPosition[] {
+  if (!/f/i.test(token.prefix)) return offsets.map(() => 'literal')
   const quoteLength = token.quoteLength
   const contentStart = token.start + token.prefix.length + quoteLength
   const contentEnd = token.end - quoteLength
@@ -386,7 +413,24 @@ function getFStringPosition(
   let inConversion = false
   let nestedString: { delimiter: string } | null = null
   let comment = false
-  for (let index = contentStart; index < contentEnd && index < absoluteOffset; index += 1) {
+  const positions: FStringPosition[] = []
+  const expressionStates = new Map<number, FStringExpressionState>()
+  const recordPositionsThrough = (index: number) => {
+    while (positions.length < offsets.length && offsets[positions.length] <= index) {
+      if (comment) positions.push('comment')
+      else if (nestedString) positions.push('nested-string')
+      else if (depth === 0) positions.push('literal')
+      else if (inFormatSpec && depth === 1) positions.push('format')
+      else if (inConversion) positions.push('conversion')
+      else {
+        expressionStates.set(positions.length, { depth, parentheses, brackets })
+        positions.push('expression')
+      }
+    }
+  }
+  for (let index = contentStart; index < contentEnd; index += 1) {
+    recordPositionsThrough(index)
+    if (positions.length === offsets.length) break
     const character = code[index]
     if (comment) {
       if (character === '\n' || character === '\r') comment = false
@@ -461,15 +505,15 @@ function getFStringPosition(
       }
     }
   }
-  if (comment) return 'comment'
-  if (nestedString) return 'nested-string'
-  if (depth === 0) return 'literal'
-  if (inFormatSpec && depth === 1) return 'format'
-  if (inConversion) return 'conversion'
-  if (hasFStringDebugMarker(code, token, absoluteOffset, depth, parentheses, brackets)) {
-    return 'debug'
+  recordPositionsThrough(Number.POSITIVE_INFINITY)
+
+  const decided = new Map<number, FStringExpressionState & { debug: boolean }>()
+  for (const [position, state] of [...expressionStates].reverse()) {
+    const debug = hasFStringDebugMarker(code, token, offsets[position], state, decided)
+    if (debug) positions[position] = 'debug'
+    decided.set(offsets[position], { ...state, debug })
   }
-  return 'expression'
+  return positions
 }
 
 function buildSimultaneousInterpolation(
@@ -497,72 +541,358 @@ function pythonRuntimeValue(bindingName: string): string {
 
 type PythonBarePlaceholderPosition = 'value' | 'attribute' | 'unsupported-name'
 
-function classifyPythonBarePlaceholder(
+const ASSIGNMENT_OPERATOR = /^(?:=(?!=)|:=|\+=|-=|\*=|\/=|\/\/=|%=|@=|&=|\|=|\^=|>>=|<<=|\*\*=)/
+const NAME_POSITION_KEYWORDS = [
+  'def',
+  'class',
+  'import',
+  'from',
+  'as',
+  'global',
+  'nonlocal',
+  'del',
+  'for',
+  'lambda',
+] as const
+
+function isWhitespace(character: string | undefined): boolean {
+  return character !== undefined && /\s/.test(character)
+}
+
+interface PythonKeywordHead {
+  start: number
+  /** End of the whitespace run that follows the keyword. */
+  whitespaceEnd: number
+  /** First carriage return at or after `whitespaceEnd`, or `Infinity`. */
+  carriageReturnAfter: number
+}
+
+interface PythonSourceIndex {
+  newlines: number[]
+  carriageReturns: number[]
+  openParens: number[]
+  closeParens: number[]
+  commas: number[]
+  equals: number[]
+  colons: number[]
+  /** `(` offsets that close a `def name(` head. */
+  defParens: number[]
+  forHeads: PythonKeywordHead[]
+  delHeads: PythonKeywordHead[]
+  /** `in` tokens with whitespace on both sides. */
+  inTokens: number[]
+  /** `lambda` and `if` offsets not adjoining an identifier character. */
+  lambdas: number[]
+  ifs: number[]
+}
+
+function firstAtOrAfter(offsets: readonly number[], offset: number): number {
+  return partitionPoint(offsets, (candidate) => candidate < offset)
+}
+
+function hasOffsetIn(offsets: readonly number[], start: number, end: number): boolean {
+  const index = firstAtOrAfter(offsets, start)
+  return index < offsets.length && offsets[index] < end
+}
+
+/** The last offset in `[start, end)`, or `start - 1` when there is none. */
+function lastOffsetIn(offsets: readonly number[], start: number, end: number): number {
+  const offset = offsets[firstAtOrAfter(offsets, end) - 1]
+  return offset !== undefined && offset >= start ? offset : start - 1
+}
+
+function nextOffset(offsets: readonly number[], offset: number, fallback: number): number {
+  return offsets[firstAtOrAfter(offsets, offset)] ?? fallback
+}
+
+function lineStartOf(newlines: readonly number[], offset: number): number {
+  return lastOffsetIn(newlines, 0, offset) + 1
+}
+
+function standaloneKeywordOffsets(code: string, keyword: string): number[] {
+  const offsets: number[] = []
+  for (let index = code.indexOf(keyword); index !== -1; index = code.indexOf(keyword, index + 1)) {
+    if (
+      !isIdentifierCharacter(code[index - 1]) &&
+      !isIdentifierCharacter(code[index + keyword.length])
+    ) {
+      offsets.push(index)
+    }
+  }
+  return offsets
+}
+
+function keywordHeads(
   code: string,
-  occurrence: CodePlaceholderOccurrence,
-  ignoredRanges: ReadonlyArray<[number, number]> = []
-): PythonBarePlaceholderPosition {
-  const immediatelyPrevious = code[occurrence.start - 1]
-  const immediatelyNext = code[occurrence.end]
-  let previousIndex = occurrence.start - 1
-  while (previousIndex >= 0 && /[ \t\f]/.test(code[previousIndex])) previousIndex -= 1
-  const previous = code[previousIndex]
-  const attribute = previous === '.'
-  if (isIdentifierCharacter(immediatelyPrevious) || isIdentifierCharacter(immediatelyNext)) {
-    return 'unsupported-name'
+  keyword: string,
+  carriageReturns: number[]
+): PythonKeywordHead[] {
+  const heads: PythonKeywordHead[] = []
+  for (let index = code.indexOf(keyword); index !== -1; index = code.indexOf(keyword, index + 1)) {
+    if (index > 0 && !isWhitespace(code[index - 1])) continue
+    let whitespaceEnd = index + keyword.length
+    if (!isWhitespace(code[whitespaceEnd])) continue
+    while (isWhitespace(code[whitespaceEnd])) whitespaceEnd += 1
+    heads.push({
+      start: index,
+      whitespaceEnd,
+      carriageReturnAfter: nextOffset(carriageReturns, whitespaceEnd, Number.POSITIVE_INFINITY),
+    })
+  }
+  return heads
+}
+
+/** Whether the `(` at `paren` closes `def name(`, scanning back no further than `lineStart`. */
+function closesDefHead(code: string, paren: number, lineStart: number): boolean {
+  let index = paren - 1
+  while (index >= lineStart && isWhitespace(code[index])) index -= 1
+  const identifierEnd = index + 1
+  while (index >= lineStart && isIdentifierCharacter(code[index])) index -= 1
+  const identifierStart = index + 1
+  if (identifierStart === identifierEnd || !/[A-Za-z_]/.test(code[identifierStart])) return false
+  if (index < lineStart || !isWhitespace(code[index])) return false
+  while (index >= lineStart && isWhitespace(code[index])) index -= 1
+  const defStart = index - 2
+  if (defStart < lineStart || !code.startsWith('def', defStart)) return false
+  return defStart === lineStart || isWhitespace(code[defStart - 1])
+}
+
+function indexPythonSource(code: string): PythonSourceIndex {
+  const newlines: number[] = []
+  const carriageReturns: number[] = []
+  const openParens: number[] = []
+  const closeParens: number[] = []
+  const commas: number[] = []
+  const equals: number[] = []
+  const colons: number[] = []
+  for (let index = 0; index < code.length; index += 1) {
+    const character = code[index]
+    if (character === '\n') newlines.push(index)
+    else if (character === '\r') carriageReturns.push(index)
+    else if (character === '(') openParens.push(index)
+    else if (character === ')') closeParens.push(index)
+    else if (character === ',') commas.push(index)
+    else if (character === '=') equals.push(index)
+    else if (character === ':') colons.push(index)
+  }
+  return {
+    newlines,
+    carriageReturns,
+    openParens,
+    closeParens,
+    commas,
+    equals,
+    colons,
+    defParens: openParens.filter((paren) =>
+      closesDefHead(code, paren, lineStartOf(newlines, paren))
+    ),
+    forHeads: keywordHeads(code, 'for', carriageReturns),
+    delHeads: keywordHeads(code, 'del', carriageReturns),
+    inTokens: standaloneKeywordOffsets(code, 'in').filter(
+      (offset) => isWhitespace(code[offset - 1]) && isWhitespace(code[offset + 2])
+    ),
+    lambdas: standaloneKeywordOffsets(code, 'lambda'),
+    ifs: standaloneKeywordOffsets(code, 'if'),
+  }
+}
+
+/**
+ * The first head starting at or after `lineStart` whose text up to `end` has no carriage
+ * return past its whitespace. Heads are disjoint, so `carriageReturnAfter` only grows along
+ * the list and the qualifying heads form a suffix.
+ */
+function firstHeadClearOfCarriageReturn(
+  heads: readonly PythonKeywordHead[],
+  lineStart: number,
+  end: number
+): PythonKeywordHead | undefined {
+  return heads[
+    Math.max(
+      partitionPoint(heads, (head) => head.start < lineStart),
+      partitionPoint(heads, (head) => head.carriageReturnAfter < end)
+    )
+  ]
+}
+
+/**
+ * Classifies a bare placeholder by the Python construct around it on its line, answering each
+ * rule from one sorted offset index of the file instead of a regex over the line prefix.
+ * `isIgnored` must be a pure membership test over the whole file: keyword lookbacks memoize
+ * their walk per predicate and may probe offsets on earlier lines.
+ */
+function createPythonBarePlaceholderClassifier(code: string) {
+  let sourceIndex: PythonSourceIndex | undefined
+  const caseClauses = new Map<
+    number,
+    { keywordStart: number; prefixStart: number; carriageReturnAfter: number } | null
+  >()
+  const keywordMemos = new WeakMap<
+    (offset: number) => boolean,
+    { lambda: Map<number, number>; if: Map<number, number> }
+  >()
+
+  /** The last keyword offset at or before `maxStart` that `isIgnored` does not exclude, or -1. */
+  const lastUnignored = (
+    offsets: readonly number[],
+    memo: Map<number, number>,
+    isIgnored: (offset: number) => boolean,
+    maxStart: number
+  ): number => {
+    const visited: number[] = []
+    let found = -1
+    for (
+      let index = partitionPoint(offsets, (offset) => offset <= maxStart) - 1;
+      index >= 0;
+      index -= 1
+    ) {
+      const known = memo.get(index)
+      if (known !== undefined) {
+        found = known
+        break
+      }
+      visited.push(index)
+      if (!isIgnored(offsets[index])) {
+        found = index
+        break
+      }
+    }
+    for (const index of visited) memo.set(index, found)
+    return found < 0 ? -1 : offsets[found]
   }
 
-  const lineStart = code.lastIndexOf('\n', occurrence.start - 1) + 1
-  const nextNewline = code.indexOf('\n', occurrence.end)
-  const lineEnd = nextNewline === -1 ? code.length : nextNewline
-  const before = code.slice(lineStart, occurrence.start)
-  const after = code.slice(occurrence.end, lineEnd)
-  const isIgnoredBeforeOffset = (offset: number): boolean =>
-    isOffsetInRanges(lineStart + offset, ignoredRanges)
-  const parameterSegment = before.slice(
-    Math.max(before.lastIndexOf('('), before.lastIndexOf(',')) + 1
-  )
-  const inFunctionParameterName =
-    /(?:^|\s)(?:async\s+)?def\s+[A-Za-z_][A-Za-z0-9_]*\s*\([^)]*$/.test(before) &&
-    !/[=:]/.test(parameterSegment)
-  const lambdaStart = findLastPythonKeyword(before, 'lambda', isIgnoredBeforeOffset)
-  const inLambdaParameterName =
-    lambdaStart >= 0 &&
-    before.indexOf(':', lambdaStart) === -1 &&
-    !before
-      .slice(Math.max(lambdaStart + 'lambda'.length, before.lastIndexOf(',') + 1))
-      .includes('=')
-  const forMatch = /(?:^|\s)(?:async\s+)?for\s+([^\r\n]*)$/.exec(before)
-  const inForTarget = forMatch !== null && !/(?:^|\s)in\s/.test(forMatch[1])
-  const followedByAssignment =
-    /^\s*(?:=(?!=)|:=|\+=|-=|\*=|\/=|\/\/=|%=|@=|&=|\|=|\^=|>>=|<<=|\*\*=)/.test(after)
-  const caseClause = /^\s*case\s+([^\r\n]*)$/.exec(before)
-  const casePrefix = caseClause?.[1] ?? ''
-  const caseStartsWithAssignment =
-    /^(?:=(?!=)|:=|\+=|-=|\*=|\/=|\/\/=|%=|@=|&=|\|=|\^=|>>=|<<=|\*\*=)/.test(casePrefix)
-  const casePrefixOffset = before.length - casePrefix.length
-  const inCasePattern =
-    caseClause !== null &&
-    !caseStartsWithAssignment &&
-    findLastPythonKeyword(casePrefix, 'if', (offset) =>
-      isIgnoredBeforeOffset(casePrefixOffset + offset)
-    ) === -1 &&
-    after.includes(':')
-  if (
-    /(?:^|\s)(?:async\s+)?(?:def|class|import|from|as|global|nonlocal|del)\s*$/.test(before) ||
-    /(?:^|\s)(?:async\s+)?for\s*$/.test(before) ||
-    /(?:^|\s)(?:as|lambda)\s*$/.test(before) ||
-    inFunctionParameterName ||
-    inLambdaParameterName ||
-    inForTarget ||
-    inCasePattern ||
-    followedByAssignment ||
-    (attribute && /(?:^|\s)del\s+[^\r\n]*\.\s*$/.test(before))
-  ) {
-    return 'unsupported-name'
+  const caseClauseAt = (source: PythonSourceIndex, lineStart: number) => {
+    let clause = caseClauses.get(lineStart)
+    if (clause === undefined) {
+      let keywordStart = lineStart
+      while (isWhitespace(code[keywordStart])) keywordStart += 1
+      clause = null
+      if (code.startsWith('case', keywordStart) && isWhitespace(code[keywordStart + 4])) {
+        let prefixStart = keywordStart + 4
+        while (isWhitespace(code[prefixStart])) prefixStart += 1
+        clause = {
+          keywordStart,
+          prefixStart,
+          carriageReturnAfter: nextOffset(
+            source.carriageReturns,
+            prefixStart,
+            Number.POSITIVE_INFINITY
+          ),
+        }
+      }
+      caseClauses.set(lineStart, clause)
+    }
+    return clause
+  }
+
+  return (
+    occurrence: CodePlaceholderOccurrence,
+    isIgnored: (offset: number) => boolean
+  ): PythonBarePlaceholderPosition => {
+    const { start, end } = occurrence
+    const immediatelyPrevious = code[start - 1]
+    const immediatelyNext = code[end]
+    let previousIndex = start - 1
+    while (previousIndex >= 0 && /[ \t\f]/.test(code[previousIndex])) previousIndex -= 1
+    const attribute = code[previousIndex] === '.'
+    if (isIdentifierCharacter(immediatelyPrevious) || isIdentifierCharacter(immediatelyNext)) {
+      return 'unsupported-name'
+    }
+
+    const source = (sourceIndex ??= indexPythonSource(code))
+    let memo = keywordMemos.get(isIgnored)
+    if (!memo) {
+      memo = { lambda: new Map(), if: new Map() }
+      keywordMemos.set(isIgnored, memo)
+    }
+    const lineStart = lineStartOf(source.newlines, start)
+    const lineEnd = nextOffset(source.newlines, end, code.length)
+
+    let trailingWhitespace = start
+    while (trailingWhitespace > lineStart && isWhitespace(code[trailingWhitespace - 1])) {
+      trailingWhitespace -= 1
+    }
+    const endsWithKeyword = (keyword: string) => {
+      const keywordStart = trailingWhitespace - keyword.length
+      return (
+        keywordStart >= lineStart &&
+        code.startsWith(keyword, keywordStart) &&
+        (keywordStart === lineStart || isWhitespace(code[keywordStart - 1]))
+      )
+    }
+
+    const defParen = lastOffsetIn(source.defParens, lineStart, start)
+    const parameterStart =
+      Math.max(
+        lastOffsetIn(source.openParens, lineStart, start),
+        lastOffsetIn(source.commas, lineStart, start)
+      ) + 1
+    const inFunctionParameterName =
+      defParen >= lineStart &&
+      !hasOffsetIn(source.closeParens, defParen + 1, start) &&
+      !hasOffsetIn(source.equals, parameterStart, start) &&
+      !hasOffsetIn(source.colons, parameterStart, start)
+
+    const lambdaStart = lastUnignored(
+      source.lambdas,
+      memo.lambda,
+      isIgnored,
+      start - 'lambda'.length
+    )
+    const inLambdaParameterName =
+      lambdaStart >= lineStart &&
+      !hasOffsetIn(source.colons, lambdaStart, start) &&
+      !hasOffsetIn(
+        source.equals,
+        Math.max(lambdaStart + 'lambda'.length, lastOffsetIn(source.commas, lineStart, start) + 1),
+        start
+      )
+
+    const forHead = firstHeadClearOfCarriageReturn(source.forHeads, lineStart, start)
+    const inForTarget =
+      forHead !== undefined &&
+      forHead.start <= start - 4 &&
+      !hasOffsetIn(source.inTokens, forHead.whitespaceEnd, start - 2)
+
+    let assignmentStart = end
+    while (assignmentStart < lineEnd && isWhitespace(code[assignmentStart])) assignmentStart += 1
+    const followedByAssignment = ASSIGNMENT_OPERATOR.test(
+      code.slice(assignmentStart, Math.min(lineEnd, assignmentStart + 3))
+    )
+
+    const caseClause = caseClauseAt(source, lineStart)
+    const inCaseClause =
+      caseClause !== null &&
+      caseClause.keywordStart + 4 < start &&
+      caseClause.carriageReturnAfter >= start
+    const inCasePattern =
+      inCaseClause &&
+      !ASSIGNMENT_OPERATOR.test(
+        code.slice(caseClause.prefixStart, Math.min(start, caseClause.prefixStart + 3))
+      ) &&
+      lastUnignored(source.ifs, memo.if, isIgnored, start - 'if'.length) < caseClause.prefixStart &&
+      hasOffsetIn(source.colons, end, lineEnd)
+
+    const deletesAttribute = () => {
+      const dot = trailingWhitespace - 1
+      if (dot < lineStart || code[dot] !== '.') return false
+      const delHead = firstHeadClearOfCarriageReturn(source.delHeads, lineStart, dot)
+      return delHead !== undefined && delHead.start <= dot - 4
+    }
+
+    if (
+      NAME_POSITION_KEYWORDS.some(endsWithKeyword) ||
+      inFunctionParameterName ||
+      inLambdaParameterName ||
+      inForTarget ||
+      inCasePattern ||
+      followedByAssignment ||
+      (attribute && deletesAttribute())
+    ) {
+      return 'unsupported-name'
+    }
+    if (attribute) return 'attribute'
+    return 'value'
   }
-  if (attribute) return 'attribute'
-  return 'value'
 }
 
 /**
@@ -599,10 +929,10 @@ function recordPythonDirectEnvironmentReads(
   if (matches.length === 0) return
 
   const lexed = lex()
-  const ignoredRanges: Array<[number, number]> = [
+  const isIgnored = createOffsetRangeLookup([
     ...lexed.comments,
     ...lexed.strings.map((token): [number, number] => [token.start, token.end]),
-  ]
+  ])
 
   /**
    * A write or `del` target is reported like any other access, deliberately.
@@ -618,7 +948,7 @@ function recordPythonDirectEnvironmentReads(
    * per node, with no text to misread.
    */
   for (const candidate of matches) {
-    if (isOffsetInRanges(candidate.index, ignoredRanges)) continue
+    if (isIgnored(candidate.index)) continue
     /**
      * `other.environmentVariables['K']` reads a different object that merely shares the name,
      * so it is not the mounted binding at all. This is the receiver check the JavaScript side
@@ -634,7 +964,7 @@ function recordPythonDirectEnvironmentReads(
      */
     let previous = candidate.index - 1
     while (previous >= 0 && /[\s\\]/.test(code[previous])) previous -= 1
-    if (code[previous] === '.' && !isOffsetInRanges(previous, ignoredRanges)) continue
+    if (code[previous] === '.' && !isIgnored(previous)) continue
     const name = candidate[2] ?? candidate[4]
     if (name) context.recordDirectEnvironmentRead(name, candidate.index)
   }
@@ -650,6 +980,7 @@ export async function compilePythonPlaceholders(
   }
 
   const lexed = lexPython(input.code)
+  const classifyBarePlaceholder = createPythonBarePlaceholderClassifier(input.code)
   recordPythonDirectEnvironmentReads(input.code, () => lexed, context)
   const edits: SourceEdit[] = []
   const consumed = new Set<CodePlaceholderOccurrence>()
@@ -665,9 +996,7 @@ export async function compilePythonPlaceholders(
   for (const group of groupAdjacentStrings(input.code, lexed.strings, lexed.comments)) {
     const start = group[0].start
     const end = group.at(-1)?.end ?? start
-    const items = context.occurrences.filter(
-      (occurrence) => occurrence.start >= start && occurrence.end <= end
-    )
+    const items = occurrencesWithin(context.occurrences, start, end)
     if (items.length === 0) continue
 
     let groupSource = input.code.slice(start, end)
@@ -679,33 +1008,42 @@ export async function compilePythonPlaceholders(
       group.flatMap((token) => lexNestedFStringStrings(input.code, token)),
       []
     )
+    const nestedTokens = nestedStringGroups.flat()
+    const nestedGroupByToken = new Map(
+      nestedStringGroups.flatMap((nestedGroup) =>
+        nestedGroup.map((nestedToken) => [nestedToken, nestedGroup] as const)
+      )
+    )
+    const isInNestedString = createOffsetRangeLookup(
+      nestedTokens.map(({ start: nestedStart, end: nestedEnd }) => [nestedStart, nestedEnd])
+    )
+    const classifyOccurrences = (tokens: readonly PythonStringToken[]) => {
+      const positions = new Map<CodePlaceholderOccurrence, FStringPosition>()
+      for (const token of tokens) {
+        const tokenItems = occurrencesWithin(items, token.start, token.end)
+        const tokenPositions = getFStringPositions(
+          input.code,
+          token,
+          tokenItems.map((occurrence) => occurrence.start)
+        )
+        tokenItems.forEach((occurrence, index) => positions.set(occurrence, tokenPositions[index]))
+      }
+      return positions
+    }
+    const fStringPositions = classifyOccurrences(group)
+    const nestedFStringPositions = classifyOccurrences(nestedTokens)
     const nestedReplacements = new Map<
       PythonStringToken[],
       Array<{ occurrence: CodePlaceholderOccurrence; accessor: string }>
     >()
     for (const occurrence of items) {
-      const token = group.find(
-        (candidate) => occurrence.start >= candidate.start && occurrence.end <= candidate.end
-      )
-      if (!token) continue
-      const fStringPosition = getFStringPosition(input.code, token, occurrence.start)
-      if (fStringPosition === 'comment') continue
+      const fStringPosition = fStringPositions.get(occurrence)
+      if (!fStringPosition || fStringPosition === 'comment') continue
       if (!context.hasValue(occurrence.name)) continue
       if (fStringPosition === 'nested-string') {
-        const nestedGroup = nestedStringGroups.find((candidate) =>
-          candidate.some(
-            (nestedToken) =>
-              occurrence.start >= nestedToken.start && occurrence.end <= nestedToken.end
-          )
-        )
-        const nestedToken = nestedGroup?.find(
-          (candidate) => occurrence.start >= candidate.start && occurrence.end <= candidate.end
-        )
-        if (
-          nestedGroup &&
-          nestedToken &&
-          getFStringPosition(input.code, nestedToken, occurrence.start) === 'literal'
-        ) {
+        const nestedToken = findContainingToken(nestedTokens, occurrence)
+        const nestedGroup = nestedToken && nestedGroupByToken.get(nestedToken)
+        if (nestedGroup && nestedFStringPositions.get(occurrence) === 'literal') {
           const resolved = context.resolve(occurrence)
           if (!resolved) continue
           const pending = nestedReplacements.get(nestedGroup) ?? []
@@ -739,16 +1077,7 @@ export async function compilePythonPlaceholders(
       if (fStringPosition === 'expression' || fStringPosition === 'format') {
         if (
           fStringPosition === 'expression' &&
-          classifyPythonBarePlaceholder(
-            input.code,
-            occurrence,
-            nestedStringGroups
-              .flat()
-              .map(
-                ({ start: nestedStart, end: nestedEnd }) =>
-                  [nestedStart, nestedEnd] as [number, number]
-              )
-          ) === 'unsupported-name'
+          classifyBarePlaceholder(occurrence, isInNestedString) === 'unsupported-name'
         ) {
           if (input.analysisOnly) {
             context.resolveValue(occurrence)
@@ -816,18 +1145,16 @@ export async function compilePythonPlaceholders(
     })
   }
 
+  const isInComment = createOffsetRangeLookup(lexed.comments)
+  const isInStringOrComment = createOffsetRangeLookup([
+    ...lexed.strings.map(({ start, end }) => [start, end] as [number, number]),
+    ...lexed.comments,
+  ])
   for (const occurrence of context.occurrences) {
-    if (consumed.has(occurrence) || isOffsetInRanges(occurrence.start, lexed.comments)) continue
-    if (
-      lexed.strings.some((token) => occurrence.start >= token.start && occurrence.end <= token.end)
-    ) {
-      continue
-    }
+    if (consumed.has(occurrence) || isInComment(occurrence.start)) continue
+    if (findContainingToken(lexed.strings, occurrence)) continue
     if (!context.hasValue(occurrence.name)) continue
-    const position = classifyPythonBarePlaceholder(input.code, occurrence, [
-      ...lexed.strings.map(({ start, end }) => [start, end] as [number, number]),
-      ...lexed.comments,
-    ])
+    const position = classifyBarePlaceholder(occurrence, isInStringOrComment)
     if (position === 'unsupported-name') {
       if (input.analysisOnly) {
         context.resolveValue(occurrence)
diff --git a/apps/sim/lib/execution/code-placeholders/shared.ts b/apps/sim/lib/execution/code-placeholders/shared.ts
index 8390c10b0d1..177e7d21d5b 100644
--- a/apps/sim/lib/execution/code-placeholders/shared.ts
+++ b/apps/sim/lib/execution/code-placeholders/shared.ts
@@ -291,6 +291,54 @@ export function applySourceEdits(code: string, edits: SourceEdit[]): string {
   return output + code.slice(cursor)
 }
 
-export function isOffsetInRanges(offset: number, ranges: ReadonlyArray<[number, number]>): boolean {
-  return ranges.some(([start, end]) => offset >= start && offset < end)
+/** The first index whose item fails `isBefore`, for items ordered so that it holds on a prefix. */
+export function partitionPoint<T>(items: readonly T[], isBefore: (item: T) => boolean): number {
+  let lower = 0
+  let upper = items.length
+  while (lower < upper) {
+    const middle = (lower + upper) >>> 1
+    if (isBefore(items[middle])) lower = middle + 1
+    else upper = middle
+  }
+  return lower
+}
+
+/**
+ * Builds a membership test over `[start, end)` ranges. Sorting and merging once makes each
+ * lookup a binary search: scanning every range per placeholder is quadratic in user code.
+ */
+export function createOffsetRangeLookup(
+  ranges: ReadonlyArray<readonly [number, number]>
+): (offset: number) => boolean {
+  const merged: Array<[number, number]> = []
+  for (const [start, end] of [...ranges].sort((left, right) => left[0] - right[0])) {
+    if (end <= start) continue
+    const last = merged.at(-1)
+    if (last && start <= last[1]) last[1] = Math.max(last[1], end)
+    else merged.push([start, end])
+  }
+  return (offset) => {
+    const containing = merged[partitionPoint(merged, ([start]) => start <= offset) - 1]
+    return containing !== undefined && offset < containing[1]
+  }
+}
+
+/**
+ * The placeholders lying wholly inside `[start, end]`. Occurrences are ordered and never
+ * overlap, so the matches are one contiguous run found by bisection.
+ */
+export function occurrencesWithin(
+  occurrences: readonly CodePlaceholderOccurrence[],
+  start: number,
+  end: number
+): CodePlaceholderOccurrence[] {
+  const matches: CodePlaceholderOccurrence[] = []
+  for (
+    let index = partitionPoint(occurrences, (occurrence) => occurrence.start < start);
+    index < occurrences.length && occurrences[index].end <= end;
+    index++
+  ) {
+    matches.push(occurrences[index])
+  }
+  return matches
 }
diff --git a/apps/sim/lib/execution/code-placeholders/shell.ts b/apps/sim/lib/execution/code-placeholders/shell.ts
index e01139c64ca..95677620ef2 100644
--- a/apps/sim/lib/execution/code-placeholders/shell.ts
+++ b/apps/sim/lib/execution/code-placeholders/shell.ts
@@ -2,7 +2,9 @@ import {
   applySourceEdits,
   CodePlaceholderCompileError,
   createCodePlaceholderCompilationContext,
-  isOffsetInRanges,
+  createOffsetRangeLookup,
+  occurrencesWithin,
+  partitionPoint,
   type SourceEdit,
 } from '@/lib/execution/code-placeholders/shared'
 import type {
@@ -341,11 +343,42 @@ function parseHeredocHeaders(
   return declarations
 }
 
+/**
+ * Indexes every line by its terminator-comparable text, so a heredoc's terminator is found by
+ * bisection. An unterminated header is skipped and parsing resumes on the next line, so walking
+ * forward to the end of the file per header is quadratic in a file of unterminated headers.
+ */
+function createHeredocTerminatorLookup(
+  code: string
+): (delimiter: string, stripTabs: boolean, from: number) => number | undefined {
+  const lineStartsByText = new Map<string, number[]>()
+  const lineStartsByTabStrippedText = new Map<string, number[]>()
+  const record = (index: Map<string, number[]>, text: string, lineStart: number) => {
+    const lineStarts = index.get(text)
+    if (lineStarts) lineStarts.push(lineStart)
+    else index.set(text, [lineStart])
+  }
+  for (let lineStart = 0; lineStart < code.length; ) {
+    const lineEnd = lineEndAfterNewline(code, lineStart)
+    const rawLine = code.slice(lineStart, lineEnd).replace(/\n$/, '').replace(/\r$/, '')
+    record(lineStartsByText, rawLine, lineStart)
+    record(lineStartsByTabStrippedText, rawLine.replace(/^\t+/, ''), lineStart)
+    lineStart = lineEnd
+  }
+
+  return (delimiter, stripTabs, from) => {
+    if (from >= code.length) return delimiter === '' ? from : undefined
+    const lineStarts = (stripTabs ? lineStartsByTabStrippedText : lineStartsByText).get(delimiter)
+    return lineStarts?.[partitionPoint(lineStarts, (lineStart) => lineStart < from)]
+  }
+}
+
 function collectHeredocs(code: string): HeredocDeclaration[] {
   const declarations: HeredocDeclaration[] = []
   const frames: ShellScanFrame[] = [
     { kind: 'root', quote: 'none', parenthesisDepth: 0, literalRoot: false },
   ]
+  let findTerminator: ReturnType<typeof createHeredocTerminatorLookup> | undefined
   let cursor = 0
   while (cursor < code.length) {
     const headerEnd = logicalLineEndAfterContinuations(code, cursor)
@@ -355,33 +388,23 @@ function collectHeredocs(code: string): HeredocDeclaration[] {
       continue
     }
 
+    findTerminator ??= createHeredocTerminatorLookup(code)
     let bodyCursor = headerEnd
     let complete = true
     for (const header of headers) {
-      const bodyStart = bodyCursor
-      let found = false
-      while (bodyCursor <= code.length) {
-        const candidateEnd = lineEndAfterNewline(code, bodyCursor)
-        const rawLine = code.slice(bodyCursor, candidateEnd).replace(/\n$/, '').replace(/\r$/, '')
-        const comparable = header.stripTabs ? rawLine.replace(/^\t+/, '') : rawLine
-        if (comparable === header.delimiter) {
-          declarations.push({
-            ...header,
-            bodyStart,
-            bodyEnd: bodyCursor,
-            removalEnd: candidateEnd,
-          })
-          bodyCursor = candidateEnd
-          found = true
-          break
-        }
-        if (candidateEnd === code.length) break
-        bodyCursor = candidateEnd
-      }
-      if (!found) {
+      const terminatorStart = findTerminator(header.delimiter, header.stripTabs, bodyCursor)
+      if (terminatorStart === undefined) {
         complete = false
         break
       }
+      const removalEnd = lineEndAfterNewline(code, terminatorStart)
+      declarations.push({
+        ...header,
+        bodyStart: bodyCursor,
+        bodyEnd: terminatorStart,
+        removalEnd,
+      })
+      bodyCursor = removalEnd
     }
     cursor = complete ? bodyCursor : headerEnd
   }
@@ -456,9 +479,9 @@ function collectShellOccurrenceContexts(
   skippedRanges: Array<[number, number]> = []
 ): Map<CodePlaceholderOccurrence, ShellOccurrenceContext> {
   const occurrenceByStart = new Map(
-    occurrences
-      .filter((occurrence) => occurrence.start >= start && occurrence.end <= end)
-      .map((occurrence) => [occurrence.start, occurrence] as const)
+    occurrencesWithin(occurrences, start, end).map(
+      (occurrence) => [occurrence.start, occurrence] as const
+    )
   )
   const contexts = new Map<CodePlaceholderOccurrence, ShellOccurrenceContext>()
   const frames: ShellScanFrame[] = [
@@ -737,9 +760,10 @@ export async function compileShellPlaceholders(
     excludedRanges.push([heredoc.operatorStart, heredoc.operatorEnd])
     excludedRanges.push([heredoc.bodyStart, heredoc.removalEnd])
 
-    const delimiterOccurrences = shellOccurrences.filter(
-      (occurrence) =>
-        occurrence.start >= heredoc.operatorStart && occurrence.end <= heredoc.operatorEnd
+    const delimiterOccurrences = occurrencesWithin(
+      shellOccurrences,
+      heredoc.operatorStart,
+      heredoc.operatorEnd
     )
     for (const occurrence of delimiterOccurrences) {
       if (context.hasValue(occurrence.name)) {
@@ -755,9 +779,7 @@ export async function compileShellPlaceholders(
       }
     }
 
-    const bodyOccurrences = shellOccurrences.filter(
-      (occurrence) => occurrence.start >= heredoc.bodyStart && occurrence.end <= heredoc.bodyEnd
-    )
+    const bodyOccurrences = occurrencesWithin(shellOccurrences, heredoc.bodyStart, heredoc.bodyEnd)
     if (heredoc.quoted) {
       const bodyEdits: SourceEdit[] = []
       let hasResolvedPlaceholder = false
@@ -852,9 +874,8 @@ export async function compileShellPlaceholders(
     }
   }
 
-  const rootOccurrences = shellOccurrences.filter(
-    (occurrence) => !isOffsetInRanges(occurrence.start, excludedRanges)
-  )
+  const isExcluded = createOffsetRangeLookup(excludedRanges)
+  const rootOccurrences = shellOccurrences.filter((occurrence) => !isExcluded(occurrence.start))
   const rootContexts = collectShellOccurrenceContexts(
     input.code,
     rootOccurrences,
diff --git a/apps/sim/lib/execution/mounted-file-secret-provenance.test.ts b/apps/sim/lib/execution/mounted-file-secret-provenance.test.ts
index 2404d29e1a9..ae2dcf537a9 100644
--- a/apps/sim/lib/execution/mounted-file-secret-provenance.test.ts
+++ b/apps/sim/lib/execution/mounted-file-secret-provenance.test.ts
@@ -12,7 +12,7 @@ describe('mounted file output provenance scanner', () => {
     }))
   })
 
-  it('classifies only mounted secrets present in the exact exported bytes', async () => {
+  it('retains full mounted lineage while narrowing text exports to matching literals', async () => {
     const scanner = await createMountedFileSecretProvenanceScanner({
       version: 1,
       complete: true,
@@ -23,6 +23,23 @@ describe('mounted file output provenance scanner', () => {
       scope: { userId: 'user-1', workspaceId: 'workspace-1' },
     })
 
+    expect(scanner?.provenance).toEqual({
+      status: 'exact',
+      entries: [
+        {
+          name: 'MOUNTED_FILE_SECRET',
+          encryptedValue: 'encrypted-a',
+          sourceUserId: 'user-1',
+          sourceWorkspaceId: 'workspace-1',
+        },
+        {
+          name: 'ORIGINAL_NAME',
+          encryptedValue: 'encrypted-b',
+          sourceUserId: 'user-1',
+          sourceWorkspaceId: 'workspace-1',
+        },
+      ],
+    })
     expect(scanner?.scan(Buffer.from('ordinary output'))).toEqual({ status: 'exact', entries: [] })
     expect(scanner?.scan(Buffer.from('prefix first secret suffix'))).toEqual({
       status: 'exact',
@@ -48,26 +65,18 @@ describe('mounted file output provenance scanner', () => {
     })
   })
 
-  it('reports whether the mount carried any secret material', async () => {
-    const withSecrets = await createMountedFileSecretProvenanceScanner({
-      version: 1,
-      complete: true,
-      entries: [{ encryptedValue: 'encrypted-a' }],
-      scope: { userId: 'user-1', workspaceId: 'workspace-1' },
-    })
-    expect(withSecrets?.hasSecrets).toBe(true)
-
+  it('keeps a mount without secret material exact-empty', async () => {
     const withoutSecrets = await createMountedFileSecretProvenanceScanner({
       version: 1,
       complete: true,
       entries: [],
       scope: { userId: 'user-1', workspaceId: 'workspace-1' },
     })
-    expect(withoutSecrets?.hasSecrets).toBe(false)
+    expect(withoutSecrets?.provenance).toEqual({ status: 'exact', entries: [] })
     expect(withoutSecrets?.scan(Buffer.from('anything'))).toEqual({ status: 'exact', entries: [] })
   })
 
-  it('keeps hasSecrets true when attested entries yield no scannable plaintext', async () => {
+  it('keeps attested entries unknown when they yield no plaintext', async () => {
     encryptionMockFns.mockDecryptSecret.mockImplementation(async () => ({ decrypted: '' }))
 
     const scanner = await createMountedFileSecretProvenanceScanner({
@@ -77,7 +86,8 @@ describe('mounted file output provenance scanner', () => {
       scope: { userId: 'user-1', workspaceId: 'workspace-1' },
     })
 
-    expect(scanner?.hasSecrets).toBe(true)
+    expect(scanner?.provenance).toEqual({ status: 'unknown' })
+    expect(scanner?.scan(Buffer.from('ordinary output'))).toEqual({ status: 'unknown' })
   })
 
   it.each(['false', 'hunter2', '""""'])(
@@ -96,7 +106,7 @@ describe('mounted file output provenance scanner', () => {
         status: 'exact',
         entries: [],
       })
-      expect(scanner?.hasSecrets).toBe(false)
+      expect(scanner?.provenance).toEqual({ status: 'exact', entries: [] })
     }
   )
 
@@ -112,7 +122,17 @@ describe('mounted file output provenance scanner', () => {
       scope: { userId: 'user-1', workspaceId: 'workspace-1' },
     })
 
-    expect(scanner?.hasSecrets).toBe(true)
+    expect(scanner?.provenance).toEqual({
+      status: 'exact',
+      entries: [
+        {
+          name: 'MOUNTED_FILE_SECRET',
+          encryptedValue: 'encrypted-boundary',
+          sourceUserId: 'user-1',
+          sourceWorkspaceId: 'workspace-1',
+        },
+      ],
+    })
     expect(scanner?.scan(Buffer.from('false hunter22'))).toEqual({
       status: 'exact',
       entries: [
@@ -132,7 +152,7 @@ describe('mounted file output provenance scanner', () => {
       complete: false,
       entries: [],
     })
-    expect(incomplete?.hasSecrets).toBe(true)
+    expect(incomplete?.provenance).toEqual({ status: 'unknown' })
     expect(incomplete?.scan(Buffer.from('raw output'))).toEqual({ status: 'unknown' })
 
     encryptionMockFns.mockDecryptSecret.mockRejectedValueOnce(new Error('decrypt failed'))
@@ -142,7 +162,7 @@ describe('mounted file output provenance scanner', () => {
       entries: [{ encryptedValue: 'encrypted-a' }],
       scope: { userId: 'user-1', workspaceId: 'workspace-1' },
     })
-    expect(unavailable?.hasSecrets).toBe(true)
+    expect(unavailable?.provenance).toEqual({ status: 'unknown' })
     expect(unavailable?.scan(Buffer.from('raw output'))).toEqual({ status: 'unknown' })
   })
 })
diff --git a/apps/sim/lib/execution/mounted-file-secret-provenance.ts b/apps/sim/lib/execution/mounted-file-secret-provenance.ts
index 1bf6003ad6c..19587809553 100644
--- a/apps/sim/lib/execution/mounted-file-secret-provenance.ts
+++ b/apps/sim/lib/execution/mounted-file-secret-provenance.ts
@@ -1,7 +1,10 @@
 import type { WorkspaceFileSecretProvenanceEntry } from '@sim/db/schema'
 import { compareStrings } from '@sim/utils/string'
 import { decryptSecret } from '@/lib/core/security/encryption'
-import type { WorkspaceFileSecretProvenance } from '@/lib/uploads/contexts/workspace/workspace-file-secret-provenance'
+import {
+  mergeWorkspaceFileSecretProvenance,
+  type WorkspaceFileSecretProvenance,
+} from '@/lib/uploads/contexts/workspace/workspace-file-secret-provenance'
 import {
   createResolvedSecretMatcher,
   scanResolvedSecretString,
@@ -13,18 +16,13 @@ const MAX_MOUNTED_FILE_SECRET_MATCH_EVENTS = 1_000_000
 const ANONYMOUS_MOUNTED_FILE_SECRET_NAME = 'MOUNTED_FILE_SECRET'
 
 export interface MountedFileSecretProvenanceScanner {
-  /**
-   * True when the envelope carries material protected by the shared literal policy, or an entry
-   * cannot be inspected. Successfully decrypted short values do not taint derived binary files.
-   * Entries that fail to yield plaintext keep this true: losing the ability to scan them makes
-   * the mount less classifiable, not more.
-   */
-  hasSecrets: boolean
+  /** Complete protected candidates for opaque exports; text exports may narrow them by scanning. */
+  provenance: WorkspaceFileSecretProvenance
   scan(buffer: Buffer): WorkspaceFileSecretProvenance
 }
 
 const UNKNOWN_MOUNTED_FILE_SECRET_PROVENANCE_SCANNER: MountedFileSecretProvenanceScanner = {
-  hasSecrets: true,
+  provenance: { status: 'unknown' },
   scan: () => ({ status: 'unknown' }),
 }
 
@@ -39,17 +37,13 @@ export async function createMountedFileSecretProvenanceScanner(
   if (!provenance.complete) return UNKNOWN_MOUNTED_FILE_SECRET_PROVENANCE_SCANNER
   if (!provenance.scope?.userId) return undefined
 
-  let hasSecrets = false
+  const protectedEntries: WorkspaceFileSecretProvenanceEntry[] = []
   const entriesByScanLiteral = new Map<string, Map<string, WorkspaceFileSecretProvenanceEntry>>()
   try {
     for (const entry of provenance.entries) {
       const { decrypted: plaintext } = await decryptSecret(entry.encryptedValue)
-      if (!plaintext) {
-        hasSecrets = true
-        continue
-      }
+      if (!plaintext) return UNKNOWN_MOUNTED_FILE_SECRET_PROVENANCE_SCANNER
       if (isNonIdentifyingSecretLiteral(plaintext)) continue
-      hasSecrets = true
       const fileEntry: WorkspaceFileSecretProvenanceEntry = {
         name: entry.name || ANONYMOUS_MOUNTED_FILE_SECRET_NAME,
         encryptedValue: entry.encryptedValue,
@@ -58,6 +52,7 @@ export async function createMountedFileSecretProvenanceScanner(
           ? { sourceWorkspaceId: provenance.scope.workspaceId }
           : {}),
       }
+      protectedEntries.push(fileEntry)
       for (const scanLiteral of new Set([plaintext, JSON.stringify(plaintext).slice(1, -1)])) {
         const entries =
           entriesByScanLiteral.get(scanLiteral) ??
@@ -73,8 +68,13 @@ export async function createMountedFileSecretProvenanceScanner(
     return UNKNOWN_MOUNTED_FILE_SECRET_PROVENANCE_SCANNER
   }
 
+  const sourceProvenance = mergeWorkspaceFileSecretProvenance({
+    status: 'exact',
+    entries: protectedEntries,
+  })
+
   if (entriesByScanLiteral.size === 0) {
-    return { hasSecrets, scan: () => ({ status: 'exact', entries: [] }) }
+    return { provenance: sourceProvenance, scan: () => ({ status: 'exact', entries: [] }) }
   }
 
   let matcher
@@ -86,11 +86,11 @@ export async function createMountedFileSecretProvenanceScanner(
     return UNKNOWN_MOUNTED_FILE_SECRET_PROVENANCE_SCANNER
   }
   if (!matcher) {
-    return { hasSecrets, scan: () => ({ status: 'exact', entries: [] }) }
+    return { provenance: sourceProvenance, scan: () => ({ status: 'exact', entries: [] }) }
   }
 
   return {
-    hasSecrets,
+    provenance: sourceProvenance,
     /**
      * A scan that cannot finish yields `unknown` — a taint — where the registry's per-value scan
      * over-approximates instead. The asymmetry is deliberate: that scan only narrows a candidate
diff --git a/apps/sim/lib/function-execution/execute-request.test.ts b/apps/sim/lib/function-execution/execute-request.test.ts
index dd1e8e478b6..653af53e30b 100644
--- a/apps/sim/lib/function-execution/execute-request.test.ts
+++ b/apps/sim/lib/function-execution/execute-request.test.ts
@@ -22,7 +22,6 @@ import {
   workspaceFileReferenceMock,
   workspaceFileReferenceMockFns,
 } from '@sim/testing/mocks/workspace-file-reference.mock'
-import JSZip from 'jszip'
 import { NextRequest } from 'next/server'
 import { afterAll, beforeEach, describe, expect, it, vi } from 'vitest'
 import { functionExecuteBodySchema } from '@/lib/api/contracts'
@@ -1135,67 +1134,6 @@ describe('Function execution request', () => {
       )
     })
 
-    it('excludes short compiled plaintext before JSON escaping even with a protected secret in scope', async () => {
-      const shortValue = '""""'
-      envFlagsMock.isRemoteSandboxEnabled = true
-      mockExecuteInSandbox.mockResolvedValueOnce({
-        result: 'done',
-        stdout: '',
-        sandboxId: 'sandbox-123',
-        exportedFiles: {
-          '/home/user/short.json': JSON.stringify({ value: shortValue }),
-          '/home/user/protected.txt': 'hunter22',
-        },
-      })
-
-      const response = await POST(
-        createMockRequest('POST', {
-          code: 'print({{SHORT_VALUE}}, {{API_KEY}})',
-          language: 'python',
-          workspaceId: 'workspace-1',
-          envVars: { SHORT_VALUE: shortValue, API_KEY: 'hunter22' },
-          outputs: {
-            files: [
-              {
-                path: 'files/short.json',
-                sandboxPath: '/home/user/short.json',
-                mimeType: 'application/json',
-              },
-              {
-                path: 'files/protected.txt',
-                sandboxPath: '/home/user/protected.txt',
-                mimeType: 'text/plain',
-              },
-            ],
-          },
-        })
-      )
-
-      expect(response.status).toBe(200)
-      expect(mockWriteWorkspaceFileByPath).toHaveBeenCalledWith(
-        expect.objectContaining({
-          target: expect.objectContaining({ path: 'files/short.json' }),
-          secretProvenance: { status: 'exact', entries: [] },
-        })
-      )
-      expect(mockWriteWorkspaceFileByPath).toHaveBeenCalledWith(
-        expect.objectContaining({
-          target: expect.objectContaining({ path: 'files/protected.txt' }),
-          secretProvenance: {
-            status: 'exact',
-            entries: [
-              {
-                name: 'API_KEY',
-                encryptedValue: 'encrypted:hunter22',
-                sourceUserId: 'user-123',
-                sourceWorkspaceId: 'workspace-1',
-              },
-            ],
-          },
-        })
-      )
-    })
-
     it('classifies exports exact-empty when the only compiled secret is exempt, still reporting its name', async () => {
       envFlagsMock.isRemoteSandboxEnabled = true
       mockExecuteInSandbox.mockResolvedValueOnce({
@@ -1258,52 +1196,6 @@ describe('Function execution request', () => {
       expect(data.__resolvedSecretNames).toEqual(['API_KEY'])
     })
 
-    it('keeps recording the non-exempt owner when an exempt name shares its plaintext', async () => {
-      envFlagsMock.isRemoteSandboxEnabled = true
-      mockExecuteInSandbox.mockResolvedValueOnce({
-        result: 'done',
-        stdout: '',
-        sandboxId: 'sandbox-123',
-        exportedFiles: { '/home/user/secret.txt': 'Bearer shared-value' },
-      })
-
-      const response = await POST(
-        createMockRequest('POST', {
-          code: 'print("{{EXEMPT_KEY}}", "{{OTHER_KEY}}")',
-          language: 'python',
-          workspaceId: 'workspace-1',
-          envVars: { EXEMPT_KEY: 'shared-value', OTHER_KEY: 'shared-value' },
-          unredactedSecretNames: ['EXEMPT_KEY'],
-          outputs: {
-            files: [
-              {
-                path: 'files/secret.txt',
-                sandboxPath: '/home/user/secret.txt',
-                mimeType: 'text/plain',
-              },
-            ],
-          },
-        })
-      )
-
-      expect(response.status).toBe(200)
-      expect(mockWriteWorkspaceFileByPath).toHaveBeenCalledWith(
-        expect.objectContaining({
-          secretProvenance: {
-            status: 'exact',
-            entries: [
-              {
-                name: 'OTHER_KEY',
-                encryptedValue: 'encrypted:shared-value',
-                sourceUserId: 'user-123',
-                sourceWorkspaceId: 'workspace-1',
-              },
-            ],
-          },
-        })
-      )
-    })
-
     it('classifies text exports against private mounted-file provenance', async () => {
       envFlagsMock.isRemoteSandboxEnabled = true
       mockExecuteInSandbox.mockResolvedValueOnce({
@@ -1396,54 +1288,6 @@ describe('Function execution request', () => {
       expect(mockExecuteInSandbox).not.toHaveBeenCalled()
     })
 
-    it('runs with authenticated incomplete mount provenance and marks exported bytes unknown', async () => {
-      envFlagsMock.isRemoteSandboxEnabled = true
-      mockExecuteInSandbox.mockResolvedValueOnce({
-        result: 'raw result',
-        stdout: '',
-        sandboxId: 'sandbox-123',
-        exportedFiles: { '/home/user/output.txt': 'raw output' },
-      })
-
-      const response = await POST(
-        createMockRequest(
-          'POST',
-          {
-            code: 'print("done")',
-            language: 'python',
-            workspaceId: 'workspace-1',
-            outputs: {
-              files: [
-                {
-                  path: 'files/output.txt',
-                  sandboxPath: '/home/user/output.txt',
-                  mimeType: 'text/plain',
-                },
-              ],
-            },
-            [PRIVATE_SECRET_PROVENANCE_FIELD]: {
-              version: 1,
-              complete: false,
-              selections: [],
-            },
-          },
-          { [PRIVATE_SECRET_PROVENANCE_HEADER]: PRIVATE_SECRET_PROVENANCE_BUNDLE_V1 }
-        )
-      )
-
-      expect(response.status).toBe(200)
-      expect((await response.json()).output.exported.files).toEqual([
-        expect.objectContaining({ fileId: 'wf_output_txt', vfsPath: 'files/output.txt' }),
-      ])
-      expect(mockExecuteInSandbox).toHaveBeenCalledOnce()
-      expect(mockWriteWorkspaceFileByPath).toHaveBeenCalledWith(
-        expect.objectContaining({
-          buffer: Buffer.from('raw output'),
-          secretProvenance: { status: 'unknown' },
-        })
-      )
-    })
-
     it('does not rewrite a static export path that happens to equal a resolved secret', async () => {
       envFlagsMock.isRemoteSandboxEnabled = true
       mockExecuteInSandbox.mockResolvedValueOnce({
@@ -1547,103 +1391,6 @@ describe('Function execution request', () => {
       )
     })
 
-    it.each([
-      { plaintext: 'mounted-secret', expectedStatus: 'unknown' },
-      { plaintext: 'false', expectedStatus: 'exact' },
-      { plaintext: '""""', expectedStatus: 'exact' },
-    ])(
-      'classifies binary exports $expectedStatus with mounted plaintext $plaintext',
-      async ({ plaintext, expectedStatus }) => {
-        mockDecryptSecret.mockResolvedValueOnce({ decrypted: plaintext })
-        envFlagsMock.isRemoteSandboxEnabled = true
-        mockExecuteInSandbox.mockResolvedValueOnce({
-          result: 'done',
-          stdout: '',
-          sandboxId: 'sandbox-123',
-          exportedFiles: { '/home/user/small.jpg': '/9j/4AAQ' },
-        })
-
-        const response = await POST(
-          createMockRequest(
-            'POST',
-            {
-              code: 'print("done")',
-              language: 'python',
-              workspaceId: 'workspace-1',
-              outputs: {
-                files: [
-                  {
-                    path: 'files/small.jpg',
-                    sandboxPath: '/home/user/small.jpg',
-                    mimeType: 'image/jpeg',
-                  },
-                ],
-              },
-              [PRIVATE_SECRET_PROVENANCE_FIELD]: {
-                version: 1,
-                complete: true,
-                selections: [
-                  {
-                    key: MOUNTED_WORKSPACE_FILES_PROVENANCE_KEY,
-                    provenance: {
-                      version: 1,
-                      complete: true,
-                      entries: [{ encryptedValue: 'encrypted:mounted-secret' }],
-                      scope: { userId: 'user-123', workspaceId: 'workspace-1' },
-                    },
-                  },
-                ],
-              },
-            },
-            {
-              [PRIVATE_SECRET_PROVENANCE_HEADER]: PRIVATE_SECRET_PROVENANCE_BUNDLE_V1,
-            }
-          )
-        )
-
-        expect(response.status).toBe(200)
-        expect(mockWriteWorkspaceFileByPath).toHaveBeenCalledWith(
-          expect.objectContaining({
-            secretProvenance:
-              expectedStatus === 'exact' ? { status: 'exact', entries: [] } : { status: 'unknown' },
-          })
-        )
-      }
-    )
-
-    it('marks binary exports unknown without failing the Function execution', async () => {
-      envFlagsMock.isRemoteSandboxEnabled = true
-      mockExecuteInSandbox.mockResolvedValueOnce({
-        result: 'done',
-        stdout: '',
-        sandboxId: 'sandbox-123',
-        exportedFiles: { '/home/user/archive.zip': 'UEsDBA==' },
-      })
-
-      const response = await POST(
-        createMockRequest('POST', {
-          code: 'print("{{API_KEY}}")',
-          language: 'python',
-          workspaceId: 'workspace-1',
-          envVars: { API_KEY: 'secret-value' },
-          outputs: {
-            files: [
-              {
-                path: 'files/archive.zip',
-                sandboxPath: '/home/user/archive.zip',
-                mimeType: 'application/zip',
-              },
-            ],
-          },
-        })
-      )
-
-      expect(response.status).toBe(200)
-      expect(mockWriteWorkspaceFileByPath).toHaveBeenCalledWith(
-        expect.objectContaining({ secretProvenance: { status: 'unknown' } })
-      )
-    })
-
     it('rejects one oversized sandbox output before creating a workspace file buffer', async () => {
       envFlagsMock.isRemoteSandboxEnabled = true
       mockExecuteInSandbox.mockResolvedValueOnce({
@@ -2014,87 +1761,6 @@ describe('Function execution request', () => {
       expect(data.error).toContain('21 files')
     })
 
-    it.each([
-      { name: 'report.zip', secret: undefined, expectedStatus: 'exact' },
-      { name: 'report.zip', secret: 'super-secret-value', expectedStatus: 'unknown' },
-      { name: 'report.txt', secret: 'super-secret-value', expectedStatus: 'unknown' },
-    ])(
-      'preserves binary provenance for harvested $name with secret=$secret',
-      async ({ name, secret, expectedStatus }) => {
-        envFlagsMock.isRemoteSandboxEnabled = true
-        const zip = new JSZip()
-        zip.file('report.txt', secret ?? 'ordinary report')
-        const buffer = await zip.generateAsync({ type: 'nodebuffer', compression: 'DEFLATE' })
-        expect(buffer.includes('super-secret-value')).toBe(false)
-        mockExecuteInSandbox.mockResolvedValueOnce({
-          result: null,
-          stdout: '',
-          sandboxId: 'sbx',
-          collectedFiles: [
-            {
-              relativePath: name,
-              path: `/tmp/sim/outputs/${name}`,
-              contentBase64: buffer.toString('base64'),
-              byteLength: buffer.length,
-            },
-          ],
-        })
-
-        const response = await POST(
-          createMockRequest('POST', {
-            code: secret ? 'token = {{MY_SECRET}}' : 'x = 1',
-            language: 'python',
-            workspaceId: 'workspace-1',
-            workflowId: 'workflow-1',
-            executionId: 'execution-1',
-            ...(secret ? { envVars: { MY_SECRET: secret } } : {}),
-          })
-        )
-
-        expect(response.status).toBe(200)
-        expect(mockUploadExecutionFile).toHaveBeenCalledWith(
-          expect.any(Object),
-          buffer,
-          name,
-          expect.any(String),
-          'user-123',
-          expectedStatus === 'exact' ? { status: 'exact', entries: [] } : { status: 'unknown' }
-        )
-        const data = await response.json()
-        expect(data.output.files[0]).not.toHaveProperty('secretProvenance')
-      }
-    )
-
-    it('keeps text-looking bytes opaque when their declared format is an archive', async () => {
-      envFlagsMock.isRemoteSandboxEnabled = true
-      const buffer = Buffer.from('ASCII archive placeholder')
-      mockExecuteInSandbox.mockResolvedValueOnce({
-        result: null,
-        stdout: '',
-        sandboxId: 'sbx',
-        collectedFiles: [
-          {
-            relativePath: 'report.zip',
-            path: '/tmp/sim/outputs/report.zip',
-            contentBase64: buffer.toString('base64'),
-            byteLength: buffer.length,
-          },
-        ],
-      })
-      const response = await POST(
-        createMockRequest('POST', {
-          code: 'token = {{MY_SECRET}}',
-          language: 'python',
-          workspaceId: 'workspace-1',
-          workflowId: 'workflow-1',
-          executionId: 'execution-1',
-          envVars: { MY_SECRET: 'super-secret-value' },
-        })
-      )
-      expect(response.status).toBe(200)
-      expect(mockUploadExecutionFile.mock.calls[0][5]).toEqual({ status: 'unknown' })
-    })
-
     it('refuses an unknown tracked execution mount before running code', async () => {
       envFlagsMock.isRemoteSandboxEnabled = true
       const updatedAt = new Date('2026-01-01T00:00:00Z')
@@ -2131,49 +1797,92 @@ describe('Function execution request', () => {
       expect(mockUploadExecutionFile).not.toHaveBeenCalled()
     })
 
-    it('imports exact mount secrets into the trusted result registry and binary export classifier', async () => {
+    it('refuses a plaintext harvest carrying a secret from context variables', async () => {
+      envFlagsMock.isRemoteSandboxEnabled = true
+      const plaintext = 'table-input-secret-value'
+      const registry = new ResolvedSecretTraceRegistry(
+        [
+          {
+            name: 'API_KEY',
+            plaintext,
+            encryptedValue: plaintext,
+            scope: 'workspace',
+          },
+        ],
+        { userId: 'user-123', workspaceId: 'workspace-1' }
+      )
+      registry.recordResolvedAtInputPath('API_KEY', plaintext, ['contextVariables', 'token'])
+      const buffer = Buffer.from(plaintext)
+      mockExecuteInSandbox.mockResolvedValueOnce({
+        result: null,
+        stdout: '',
+        sandboxId: 'sbx',
+        collectedFiles: [
+          {
+            relativePath: 'report.txt',
+            path: '/tmp/sim/outputs/report.txt',
+            contentBase64: buffer.toString('base64'),
+            byteLength: buffer.length,
+          },
+        ],
+      })
+
+      const response = await POST(
+        createMockRequest('POST', {
+          code: 'x = token',
+          language: 'python',
+          workspaceId: 'workspace-1',
+          workflowId: 'workflow-1',
+          executionId: 'execution-1',
+          contextVariables: { token: plaintext },
+        }),
+        registry
+      )
+      const data = await response.json()
+
+      expect(response.status).toBe(400)
+      expect(data.success).toBe(false)
+      expect(data.error).toContain('report.txt')
+      expect(data.error).toContain('contains a resolved secret value and was not returned')
+      expect(data.output.result).toBeNull()
+      expect(data.output).not.toHaveProperty('files')
+      expect(JSON.stringify(data)).not.toContain(plaintext)
+    })
+
+    it('refuses a harvested file when runtime provenance has a decryption fault', async () => {
       envFlagsMock.isRemoteSandboxEnabled = true
-      const updatedAt = new Date('2026-01-01T00:00:00Z')
       const registry = new ResolvedSecretTraceRegistry([], {
         userId: 'user-123',
         workspaceId: 'workspace-1',
       })
-      const completePending = registry.beginPendingActivation()
+      registry.markIncomplete('entry-decrypt-failed')
+      const contentUpdatedAt = new Date('2026-01-01T00:00:00Z')
       mockMountContributors.mockReturnValue([
         {
-          fileId: 'execution-file-1',
+          fileId: 'legacy-file',
           key: 'execution/workspace-1/workflow-1/execution-1/a/input.txt',
           context: 'execution',
-          contentUpdatedAt: updatedAt,
+          contentUpdatedAt,
         },
       ])
       dbChainMockFns.limit.mockResolvedValue([
         {
-          fileContentUpdatedAt: updatedAt,
-          secretProvenanceVersion: 1,
-          provenanceContentUpdatedAt: updatedAt,
-          status: 'exact',
-          entries: [
-            {
-              name: 'API_KEY',
-              encryptedValue: 'encrypted:mounted-secret',
-              sourceUserId: 'user-123',
-              sourceWorkspaceId: 'workspace-1',
-            },
-          ],
+          fileContentUpdatedAt: contentUpdatedAt,
+          secretProvenanceVersion: null,
+          provenanceContentUpdatedAt: null,
+          status: null,
+          entries: null,
         },
       ])
-      const zip = new JSZip()
-      zip.file('result.txt', 'mounted-secret')
-      const buffer = await zip.generateAsync({ type: 'nodebuffer', compression: 'DEFLATE' })
-      mockExecuteInSandbox.mockResolvedValueOnce({
-        result: 'mounted-secret',
+      const buffer = Buffer.from('ordinary file')
+      mockExecuteInSandbox.mockResolvedValue({
+        result: null,
         stdout: '',
         sandboxId: 'sbx',
         collectedFiles: [
           {
-            relativePath: 'result.zip',
-            path: '/tmp/sim/outputs/result.zip',
+            relativePath: 'report.zip',
+            path: '/tmp/sim/outputs/report.zip',
             contentBase64: buffer.toString('base64'),
             byteLength: buffer.length,
           },
@@ -2189,184 +1898,15 @@ describe('Function execution request', () => {
         }),
         registry
       )
-      completePending()
-      expect(response.status).toBe(200)
-      expect(registry.exportProvenance().entries).toEqual([
-        expect.objectContaining({ encryptedValue: 'encrypted:mounted-secret' }),
-      ])
-      expect(mockUploadExecutionFile.mock.calls[0][5]).toEqual({ status: 'unknown' })
-    })
-
-    it.each([
-      { input: 'contextVariables', archive: true, unredacted: false },
-      { input: 'params', archive: true, unredacted: false },
-      { input: 'contextVariables', archive: false, unredacted: false },
-      { input: 'contextVariables', archive: true, unredacted: true },
-    ] as const)(
-      'classifies secret-bearing $input with archive=$archive and unredacted=$unredacted',
-      async ({ input, archive, unredacted }) => {
-        envFlagsMock.isRemoteSandboxEnabled = true
-        const plaintext = 'table-input-secret-value'
-        const registry = new ResolvedSecretTraceRegistry(
-          [
-            {
-              name: 'API_KEY',
-              plaintext,
-              encryptedValue: plaintext,
-              scope: 'workspace',
-              ...(unredacted ? { unredacted: true as const } : {}),
-            },
-          ],
-          { userId: 'user-123', workspaceId: 'workspace-1' }
-        )
-        registry.recordResolvedAtInputPath('API_KEY', plaintext, [input, 'token'])
-        const zip = new JSZip()
-        zip.file('report.txt', plaintext)
-        const buffer = archive
-          ? await zip.generateAsync({ type: 'nodebuffer', compression: 'DEFLATE' })
-          : Buffer.from(plaintext)
-        const name = archive ? 'report.zip' : 'report.txt'
-        mockExecuteInSandbox.mockResolvedValueOnce({
-          result: null,
-          stdout: '',
-          sandboxId: 'sbx',
-          collectedFiles: [
-            {
-              relativePath: name,
-              path: `/tmp/sim/outputs/${name}`,
-              contentBase64: buffer.toString('base64'),
-              byteLength: buffer.length,
-            },
-          ],
-        })
-
-        const response = await POST(
-          createMockRequest('POST', {
-            code: input === 'params' ? "x = params['token']" : 'x = token',
-            language: 'python',
-            workspaceId: 'workspace-1',
-            workflowId: 'workflow-1',
-            executionId: 'execution-1',
-            [input]: { token: plaintext },
-          }),
-          registry
-        )
-
-        expect(response.status).toBe(archive || unredacted ? 200 : 400)
-        if (archive) {
-          expect(mockUploadExecutionFile.mock.calls[0][5]).toEqual(
-            unredacted ? { status: 'exact', entries: [] } : { status: 'unknown' }
-          )
-        } else {
-          expect(mockUploadExecutionFile).not.toHaveBeenCalled()
-        }
-      }
-    )
+      const data = await response.json()
 
-    it.each([
-      { reason: 'source-provenance-incomplete', status: 200, knownMount: false, text: false },
-      { reason: 'source-provenance-incomplete', status: 200, knownMount: true, text: false },
-      { reason: 'source-provenance-incomplete', status: 200, knownMount: true, text: true },
-      { reason: 'entry-decrypt-failed', status: 400, knownMount: false, text: false },
-    ] as const)(
-      'distinguishes historical absence from provenance faults: $reason knownMount=$knownMount text=$text',
-      async ({ reason, status, knownMount, text }) => {
-        envFlagsMock.isRemoteSandboxEnabled = true
-        const registry = new ResolvedSecretTraceRegistry([], {
-          userId: 'user-123',
-          workspaceId: 'workspace-1',
-        })
-        registry.markIncomplete(reason)
-        const contentUpdatedAt = new Date('2026-01-01T00:00:00Z')
-        mockMountContributors.mockReturnValue([
-          {
-            fileId: knownMount ? 'known-file' : 'legacy-file',
-            key: 'execution/workspace-1/workflow-1/execution-1/a/input.txt',
-            context: 'execution',
-            contentUpdatedAt,
-          },
-        ])
-        dbChainMockFns.limit.mockResolvedValue([
-          {
-            fileContentUpdatedAt: contentUpdatedAt,
-            secretProvenanceVersion: knownMount ? 1 : null,
-            provenanceContentUpdatedAt: knownMount ? contentUpdatedAt : null,
-            status: knownMount ? 'exact' : null,
-            entries: knownMount
-              ? [
-                  {
-                    name: 'API_KEY',
-                    encryptedValue: 'encrypted:mounted-secret',
-                    sourceUserId: 'user-123',
-                    sourceWorkspaceId: 'workspace-1',
-                  },
-                ]
-              : null,
-          },
-        ])
-        const buffer = Buffer.from(text ? 'Bearer mounted-secret' : 'ordinary file')
-        mockExecuteInSandbox.mockResolvedValue({
-          result: null,
-          stdout: '',
-          sandboxId: 'sbx',
-          ...(text
-            ? { exportedFiles: { '/home/user/report.txt': buffer.toString('utf8') } }
-            : {
-                collectedFiles: [
-                  {
-                    relativePath: 'report.zip',
-                    path: '/tmp/sim/outputs/report.zip',
-                    contentBase64: buffer.toString('base64'),
-                    byteLength: buffer.length,
-                  },
-                ],
-              }),
-        })
-        const response = await POST(
-          createMockRequest('POST', {
-            code: 'x = 1',
-            language: 'python',
-            workspaceId: 'workspace-1',
-            workflowId: 'workflow-1',
-            executionId: 'execution-1',
-            ...(text
-              ? {
-                  outputs: {
-                    files: [
-                      {
-                        path: 'files/report.txt',
-                        sandboxPath: '/home/user/report.txt',
-                        mimeType: 'text/plain',
-                      },
-                    ],
-                  },
-                }
-              : {}),
-          }),
-          registry
-        )
-        expect(response.status).toBe(status)
-        if (status === 200) {
-          if (text) {
-            expect(mockWriteWorkspaceFileByPath.mock.calls[0][0].secretProvenance).toEqual({
-              status: 'exact',
-              entries: [
-                {
-                  name: 'API_KEY',
-                  encryptedValue: 'encrypted:mounted-secret',
-                  sourceUserId: 'user-123',
-                  sourceWorkspaceId: 'workspace-1',
-                },
-              ],
-            })
-          } else {
-            expect(mockUploadExecutionFile.mock.calls[0][5]).toEqual({
-              status: knownMount ? 'unknown' : 'unrecorded',
-            })
-          }
-        } else expect(mockUploadExecutionFile).not.toHaveBeenCalled()
-      }
-    )
+      expect(response.status).toBe(400)
+      expect(data.success).toBe(false)
+      expect(data.error).toContain('report.zip')
+      expect(data.error).toContain('was not returned')
+      expect(data.output.result).toBeNull()
+      expect(data.output).not.toHaveProperty('files')
+    })
 
     it('does not taint a secret-free mounted file with unrelated secrets from an earlier block', async () => {
       envFlagsMock.isRemoteSandboxEnabled = true
diff --git a/apps/sim/lib/function-execution/execute-request.ts b/apps/sim/lib/function-execution/execute-request.ts
index 69a74ea8737..5471b566be2 100644
--- a/apps/sim/lib/function-execution/execute-request.ts
+++ b/apps/sim/lib/function-execution/execute-request.ts
@@ -73,6 +73,8 @@ import {
   RESOLVED_SECRET_NAMES_METADATA_V1,
   requestsPrivateToolMetadata,
 } from '@/lib/execution/private-tool-metadata'
+import { SecretProvenanceBudget } from '@/lib/execution/provenance-budget'
+import { PROVENANCE_MAX_SERIALIZED_BYTES } from '@/lib/execution/provenance-limits'
 import {
   executeInSandbox,
   executeShellInSandbox,
@@ -1022,6 +1024,7 @@ interface FunctionRouteExecutionContext {
   outputSecretMatcher?: ResolvedSecretMatcher
   outputSecretNamesByScanLiteral: Map<string, string[]>
   outputSecretPlaintextsByName: Map<string, string>
+  compiledBinaryFileProvenance?: WorkspaceFileSecretProvenance
   /**
    * In-scope names the caller's registry certified as redaction-exempt. They stay in
    * `outputSecretPlaintextsByName` — the response's resolved-name reporting and the usage
@@ -1325,51 +1328,21 @@ function activateReferencedSecretProvenance(context: FunctionRouteExecutionConte
   }
 }
 
-/**
- * Compiled secret names that still demand redaction, and whose value a scan could
- * actually find. Exempt names don't count.
- *
- * Non-identifying literals are excluded on the same predicate
- * {@link createResolvedSecretMatcher} uses to drop them, because the two decisions
- * have to agree. When every in-scope value is shorter than the substitutable-literal
- * minimum, the matcher builds nothing and returns `undefined`; a counter that still
- * reported those names would send
- * {@link getOutputFileSecretProvenance} down its no-matcher branch and classify
- * every output as `unknown` — failing an export while claiming it contains a
- * secret that, by that very policy, is too short to be attributed to anything.
- */
-function countProtectedOutputSecretNames(context: FunctionRouteExecutionContext): number {
-  let count = 0
+/** Compiled candidates subject to the shared literal and exemption policies. */
+function getProtectedOutputSecretNames(context: FunctionRouteExecutionContext): string[] {
+  const names: string[] = []
   for (const [name, plaintext] of context.outputSecretPlaintextsByName) {
     if (context.unredactedSecretNames.has(name)) continue
     if (isNonIdentifyingSecretLiteral(plaintext)) continue
-    count += 1
+    names.push(name)
   }
-  return count
+  return names
 }
 
 /**
- * True when this execution compiled a secret placeholder or received a mounted file with verified
- * secret provenance. Ordinary mounts without a provenance envelope are user data, not evidence that
- * a Sim secret was resolved in this call. Exempt names don't count: a binary export whose only
- * in-scope secrets are redaction-exempt is deliberately classified exact-empty rather than locked.
- */
-function hasSecretMaterialInScope(context: FunctionRouteExecutionContext): boolean {
-  if (countProtectedOutputSecretNames(context) > 0) return true
-  return Boolean(
-    context.mountedFileSecretProvenanceScanner?.hasSecrets ||
-      context.runtimeFileSecretProvenanceScanner?.hasSecrets
-  )
-}
-
-/**
- * Classifies the secret provenance of one exported sandbox file.
- *
- * Text exports are scanned for the exact resolved-secret plaintexts in scope. Binary exports cannot
- * be scanned soundly — re-encoding can carry a secret without leaving a literal substring — so they
- * are classified only when no secret material was in scope at all; with nothing available to embed,
- * the bytes are provably secret-free. Otherwise they stay unknown, which fails closed at every
- * model and runtime boundary that later reads the file.
+ * Text exports narrow known candidates to matching literals. Opaque exports retain the complete
+ * encrypted candidate set, so runtime consumers can protect decoded output. Direct opaque model
+ * delivery still requires an empty set at its own boundary.
  */
 async function getOutputFileSecretProvenance(
   buffer: Buffer,
@@ -1384,63 +1357,77 @@ async function getOutputFileSecretProvenance(
       await createMountedFileSecretProvenanceScanner(provenance)
     if (!context.runtimeFileSecretProvenanceScanner && provenance.entries.length > 0) {
       context.runtimeFileSecretProvenanceScanner = {
-        hasSecrets: true,
+        provenance: { status: 'unknown' },
         scan: () => ({ status: 'unknown' }),
       }
     }
   }
-  if (isBinary) {
-    return hasSecretMaterialInScope(context)
-      ? { status: 'unknown' }
-      : context.runtimeInputProvenanceUnrecorded
-        ? { status: 'unrecorded' }
-        : EXACT_EMPTY_WORKSPACE_FILE_SECRET_PROVENANCE
-  }
   const mountedFileProvenance = mergeWorkspaceFileSecretProvenance(
-    context.mountedFileSecretProvenanceScanner?.scan(buffer) ??
+    (isBinary
+      ? context.mountedFileSecretProvenanceScanner?.provenance
+      : context.mountedFileSecretProvenanceScanner?.scan(buffer)) ??
       EXACT_EMPTY_WORKSPACE_FILE_SECRET_PROVENANCE,
-    context.runtimeFileSecretProvenanceScanner?.scan(buffer) ??
+    (isBinary
+      ? context.runtimeFileSecretProvenanceScanner?.provenance
+      : context.runtimeFileSecretProvenanceScanner?.scan(buffer)) ??
       EXACT_EMPTY_WORKSPACE_FILE_SECRET_PROVENANCE,
     context.runtimeInputProvenanceUnrecorded
       ? { status: 'unrecorded' }
       : EXACT_EMPTY_WORKSPACE_FILE_SECRET_PROVENANCE
   )
-  if (countProtectedOutputSecretNames(context) === 0) {
+  if (isBinary && context.compiledBinaryFileProvenance) {
+    return mergeWorkspaceFileSecretProvenance(
+      context.compiledBinaryFileProvenance,
+      mountedFileProvenance
+    )
+  }
+  const protectedNames = getProtectedOutputSecretNames(context)
+  if (protectedNames.length === 0 || mountedFileProvenance.status === 'unknown') {
     return mountedFileProvenance
   }
-  if (!context.outputSecretMatcher) return { status: 'unknown' }
 
-  const matchedNames = new Set<string>()
-  try {
-    scanResolvedSecretString(
-      buffer.toString('utf8'),
-      context.outputSecretMatcher,
-      (scanLiteral) => {
-        for (const name of context.outputSecretNamesByScanLiteral.get(scanLiteral) ?? []) {
-          matchedNames.add(name)
-        }
-      },
-      MAX_PRIVATE_FILE_SECRET_MATCH_EVENTS
-    )
-  } catch {
-    return { status: 'unknown' }
+  const matchedNames = new Set(isBinary ? protectedNames : [])
+  if (!isBinary) {
+    if (!context.outputSecretMatcher) return { status: 'unknown' }
+    try {
+      scanResolvedSecretString(
+        buffer.toString('utf8'),
+        context.outputSecretMatcher,
+        (scanLiteral) => {
+          for (const name of context.outputSecretNamesByScanLiteral.get(scanLiteral) ?? []) {
+            matchedNames.add(name)
+          }
+        },
+        MAX_PRIVATE_FILE_SECRET_MATCH_EVENTS
+      )
+    } catch {
+      return { status: 'unknown' }
+    }
   }
 
   try {
-    const entries = await Promise.all(
-      [...matchedNames].sort().map(async (name) => {
-        const plaintext = context.outputSecretPlaintextsByName.get(name)
-        if (plaintext === undefined) {
-          throw new Error('Resolved secret provenance name is outside the scoped catalog')
-        }
-        return {
-          name,
-          encryptedValue: (await encryptSecret(plaintext)).encrypted,
-          sourceUserId: scope.userId,
-          sourceWorkspaceId: scope.workspaceId,
-        }
-      })
-    )
+    const entries = []
+    const budget = new SecretProvenanceBudget()
+    for (const name of [...matchedNames].sort()) {
+      const plaintext = context.outputSecretPlaintextsByName.get(name)
+      if (plaintext === undefined) {
+        throw new Error('Resolved secret provenance name is outside the scoped catalog')
+      }
+      if (Buffer.byteLength(plaintext, 'utf8') > PROVENANCE_MAX_SERIALIZED_BYTES) {
+        return { status: 'unknown' }
+      }
+      const entry = {
+        name,
+        encryptedValue: (await encryptSecret(plaintext)).encrypted,
+        sourceUserId: scope.userId,
+        sourceWorkspaceId: scope.workspaceId,
+      }
+      if (!budget.add(entry.encryptedValue, Buffer.byteLength(JSON.stringify(entry), 'utf8'))) {
+        return { status: 'unknown' }
+      }
+      entries.push(entry)
+    }
+    if (isBinary) context.compiledBinaryFileProvenance = { status: 'exact', entries }
     return mergeWorkspaceFileSecretProvenance({ status: 'exact', entries }, mountedFileProvenance)
   } catch {
     return { status: 'unknown' }
diff --git a/apps/sim/lib/knowledge/__integration__/execution-archive-provenance.integration.ts b/apps/sim/lib/knowledge/__integration__/execution-archive-provenance.integration.ts
index 3a3332a2569..b72f5b74471 100644
--- a/apps/sim/lib/knowledge/__integration__/execution-archive-provenance.integration.ts
+++ b/apps/sim/lib/knowledge/__integration__/execution-archive-provenance.integration.ts
@@ -1,10 +1,12 @@
-/** Real execution-file storage, ZIP extraction, durable provenance, and KB indexing. */
+/** Real Function file exports, ZIP extraction, durable provenance, and KB indexing. */
 import { mkdtempSync } from 'node:fs'
 import { rm } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import path from 'node:path'
+import * as audit from '@sim/audit'
 import { db } from '@sim/db'
 import {
+  auditLog,
   document,
   documentSecretProvenance,
   knowledgeBase,
@@ -14,12 +16,26 @@ import {
   workspace,
   workspaceFiles,
 } from '@sim/db/schema'
+import { remoteSandboxMock, remoteSandboxMockFns } from '@sim/testing/mocks/remote-sandbox.mock'
 import { generateId } from '@sim/utils/id'
 import { eq, inArray, sql } from 'drizzle-orm'
 import JSZip from 'jszip'
 import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest'
 
 const fixtureStorage = vi.hoisted(() => ({ root: '' }))
+const sandboxEnvironment = vi.hoisted(() => {
+  const fixture = {
+    SANDBOX_PROVIDER: 'e2b',
+    E2B_ENABLED: 'true',
+    E2B_API_KEY: 'integration-provider-fixture-not-a-real-key',
+    E2B_FUNCTION_TEMPLATE_ID: 'fixture:11111111-1111-4111-8111-111111111111',
+    E2B_FUNCTION_TEMPLATE_GENERATION: '1785792000000',
+  }
+  const previous = Object.entries(fixture).map(([key]) => [key, process.env[key]] as const)
+  Object.assign(process.env, fixture)
+  return previous
+})
+vi.mock('@/lib/execution/remote-sandbox', () => remoteSandboxMock)
 vi.mock('@/lib/uploads/core/setup.server', () => ({
   get UPLOAD_DIR_SERVER() {
     return fixtureStorage.root
@@ -38,10 +54,21 @@ vi.mock('@/lib/embeddings', async () => ({
   }),
 }))
 
+import { functionExecuteBodySchema } from '@/lib/api/contracts'
 import { fileManageDecompressBodySchema } from '@/lib/api/contracts/tools/file'
 import { processOutboxEventById } from '@/lib/core/outbox/service'
-import { encryptSecret } from '@/lib/core/security/encryption'
+import { decryptSecret, encryptSecret } from '@/lib/core/security/encryption'
 import { isUserFile } from '@/lib/core/utils/user-file'
+import {
+  MOUNTED_WORKSPACE_FILES_PROVENANCE_KEY,
+  PRIVATE_SECRET_PROVENANCE_BUNDLE_V1,
+  PRIVATE_SECRET_PROVENANCE_FIELD,
+  PRIVATE_SECRET_PROVENANCE_HEADER,
+  PRIVATE_TOOL_METADATA_REQUEST_HEADER,
+  RESOLVED_SECRET_NAMES_FIELD,
+  RESOLVED_SECRET_NAMES_METADATA_V1,
+} from '@/lib/execution/private-tool-metadata'
+import { executeFunctionRequest } from '@/lib/function-execution/execute-request'
 import { executeFileManageOperation } from '@/lib/internal/file/operations'
 import {
   createKnowledgeAclFixtureIds,
@@ -62,16 +89,22 @@ import {
 import {
   filterModelSafeWorkspaceFileAttachments,
   getBoundWorkspaceFileSecretProvenance,
+  importWorkspaceFileSecretProvenanceForRuntime,
   isModelSafeWorkspaceFileKey,
   isOpaqueWorkspaceFileEgressSafe,
   type WorkspaceFileSecretProvenance,
+  type WorkspaceFileSecretProvenanceIdentity,
 } from '@/lib/uploads/contexts/workspace/workspace-file-secret-provenance'
 import { deleteFile, downloadFile } from '@/lib/uploads/core/storage-service'
 import { createWorkspaceFileDelegatedPrincipal } from '@/lib/workspace-files/application/delegated-principal'
 import type { UserFile } from '@/executor/types'
+import { projectResolvedSecretModelContent } from '@/executor/utils/resolved-secret-content-projection'
+import { ResolvedSecretTraceRegistry } from '@/executor/utils/resolved-secret-trace-registry'
 
 const fixtures: ReturnType<typeof createKnowledgeAclFixtureIds>[] = []
 const trackedEventIds: string[] = []
+const fixtureAuditCounts = new Map<string, number>()
+let restoreAuditObservation: (() => void) | undefined
 const REPORT_TEXT =
   'Orion archive import retains verified source bytes through every durable surface.'
 const REPORT_CSV = `name,description\nOrion,${REPORT_TEXT}\n`
@@ -80,6 +113,7 @@ const FIXTURE_SECRET = 'fixture-resolved-secret-not-a-live-key'
 async function seed() {
   const ids = createKnowledgeAclFixtureIds()
   fixtures.push(ids)
+  fixtureAuditCounts.set(ids.workspaceId, 0)
   await seedKnowledgeAclFixture(ids)
   return { ...ids, workflowId: generateId(), executionId: generateId() }
 }
@@ -166,19 +200,498 @@ async function assertBlockedConsumers(ids: Fixture, source: Awaited<ReturnType<t
 
 beforeAll(() => {
   fixtureStorage.root = mkdtempSync(path.join(tmpdir(), 'sim-execution-archive-provenance-'))
+  const observe = (entry: audit.AuditLogParams) => {
+    if (!entry.workspaceId) return
+    const count = fixtureAuditCounts.get(entry.workspaceId)
+    if (count !== undefined) fixtureAuditCounts.set(entry.workspaceId, count + 1)
+  }
+  const recordAudit = audit.recordAudit
+  const recordAuditBatch = audit.recordAuditBatch
+  const observation = vi.spyOn(audit, 'recordAudit').mockImplementation((entry) => {
+    observe(entry)
+    recordAudit(entry)
+  })
+  const batchObservation = vi.spyOn(audit, 'recordAuditBatch').mockImplementation((entries) => {
+    for (const entry of entries) observe(entry)
+    recordAuditBatch(entries)
+  })
+  restoreAuditObservation = () => {
+    observation.mockRestore()
+    batchObservation.mockRestore()
+  }
 })
 afterAll(async () => {
-  if (trackedEventIds.length) {
-    await db.delete(outboxEvent).where(inArray(outboxEvent.id, trackedEventIds))
+  try {
+    /** Drain actual asynchronous inserts before deleting fixture ownership rows. */
+    for (const [workspaceId, expected] of fixtureAuditCounts) {
+      await vi.waitFor(async () =>
+        expect(
+          await db.select().from(auditLog).where(eq(auditLog.workspaceId, workspaceId))
+        ).toHaveLength(expected)
+      )
+    }
+  } finally {
+    restoreAuditObservation?.()
+    try {
+      if (trackedEventIds.length) {
+        await db.delete(outboxEvent).where(inArray(outboxEvent.id, trackedEventIds))
+      }
+      for (const ids of fixtures) {
+        await db.delete(auditLog).where(eq(auditLog.workspaceId, ids.workspaceId))
+        await db.delete(knowledgeBase).where(eq(knowledgeBase.id, ids.knowledgeBaseId))
+        await db.delete(workspace).where(eq(workspace.id, ids.workspaceId))
+        await db.delete(organization).where(eq(organization.id, ids.organizationId))
+        await db.delete(user).where(inArray(user.id, [ids.aliceId, ids.bobId]))
+      }
+      await rm(fixtureStorage.root, { recursive: true, force: true })
+    } finally {
+      for (const [key, value] of sandboxEnvironment) {
+        if (value === undefined) Reflect.deleteProperty(process.env, key)
+        else process.env[key] = value
+      }
+      await db.$client.end()
+    }
   }
-  for (const ids of fixtures) {
-    await db.delete(knowledgeBase).where(eq(knowledgeBase.id, ids.knowledgeBaseId))
-    await db.delete(workspace).where(eq(workspace.id, ids.workspaceId))
-    await db.delete(organization).where(eq(organization.id, ids.organizationId))
-    await db.delete(user).where(inArray(user.id, [ids.aliceId, ids.bobId]))
+})
+
+async function executeFunction(
+  ids: Fixture,
+  body: Record<string, unknown>,
+  headers = new Headers(),
+  registry = new ResolvedSecretTraceRegistry([], {
+    userId: ids.aliceId,
+    workspaceId: ids.workspaceId,
+  })
+) {
+  return executeFunctionRequest(
+    { headers, signal: AbortSignal.timeout(15_000) },
+    functionExecuteBodySchema.parse({
+      workspaceId: ids.workspaceId,
+      workflowId: ids.workflowId,
+      executionId: ids.executionId,
+      language: 'python',
+      ...body,
+    }),
+    {
+      attributedUserId: ids.aliceId,
+      fileAccessUserId: ids.aliceId,
+      principal: createWorkspaceFileDelegatedPrincipal({
+        serviceId: 'executor',
+        subjectUserId: ids.aliceId,
+        workspaceId: ids.workspaceId,
+        delegationId: generateId(),
+        executionId: ids.executionId,
+      }),
+      resolvedSecretTraceRegistry: registry,
+    }
+  )
+}
+
+async function readFunctionFile(ids: Fixture, fileId: string) {
+  const [record] = await db.select().from(workspaceFiles).where(eq(workspaceFiles.id, fileId))
+  if (!record || record.workspaceId !== ids.workspaceId) {
+    throw new Error('Function export has no canonical record in its workspace')
+  }
+  if (record.context !== 'workspace' && record.context !== 'execution') {
+    throw new Error('Function export has an unexpected storage context')
   }
-  await rm(fixtureStorage.root, { recursive: true, force: true })
-  await db.$client.end()
+  const identity: WorkspaceFileSecretProvenanceIdentity = {
+    fileId: record.id,
+    key: record.key,
+    context: record.context,
+    contentUpdatedAt: record.contentUpdatedAt,
+  }
+  const provenance = await getBoundWorkspaceFileSecretProvenance(ids.workspaceId, identity)
+  const bytes = await downloadFile({ key: record.key, context: record.context, maxBytes: 8192 })
+  const registry = new ResolvedSecretTraceRegistry([], {
+    userId: ids.aliceId,
+    workspaceId: ids.workspaceId,
+  })
+  const imported = await importWorkspaceFileSecretProvenanceForRuntime({
+    workspaceId: ids.workspaceId,
+    identity,
+    registry,
+  })
+  return { identity, provenance, bytes, registry, imported }
+}
+
+async function readArchiveReport(bytes: Buffer): Promise<string> {
+  const archive = await JSZip.loadAsync(bytes)
+  const report = archive.file('report.txt')
+  if (!report) throw new Error('Stored archive is missing report.txt')
+  return report.async('string')
+}
+
+/** The provider supplies bytes; Function classification, both writers and consumer admission stay real. */
+describe('Function export provenance in PostgreSQL', () => {
+  it.each([false, true])(
+    'persists compiled binary candidates without broadening short or exempt values (protected=%s)',
+    async (protectedValues) => {
+      const ids = await seed()
+      const boundary = 'eight888'
+      const short = 'short77'
+      const shortEscaped = '""""'
+      const shortJson = JSON.stringify({ value: shortEscaped })
+      const content = `${FIXTURE_SECRET}\n${boundary}\n${short}`
+      const zip = new JSZip()
+      zip.file('report.txt', content)
+      const bytes = await zip.generateAsync({ type: 'nodebuffer', compression: 'DEFLATE' })
+      expect(bytes.includes(FIXTURE_SECRET)).toBe(false)
+      remoteSandboxMockFns.mockExecuteInSandbox.mockResolvedValueOnce({
+        result: 'done',
+        stdout: '',
+        sandboxId: 'fixture',
+        exportedFiles: {
+          '/home/user/report.zip': bytes.toString('base64'),
+          ...(protectedValues
+            ? { '/home/user/narrow.txt': boundary, '/home/user/short.json': shortJson }
+            : {}),
+        },
+      })
+      const response = await executeFunction(
+        ids,
+        {
+          code: `exempt = {{EXEMPT_KEY}}\nshort = {{SHORT}}\nshort_escaped = {{SHORT_ESCAPED}}${
+            protectedValues ? '\nprotected = {{PROTECTED_KEY}}\nboundary = {{BOUNDARY}}' : ''
+          }`,
+          envVars: {
+            EXEMPT_KEY: FIXTURE_SECRET,
+            SHORT: short,
+            SHORT_ESCAPED: shortEscaped,
+            ...(protectedValues ? { PROTECTED_KEY: FIXTURE_SECRET, BOUNDARY: boundary } : {}),
+          },
+          unredactedSecretNames: ['EXEMPT_KEY'],
+          outputs: {
+            files: [
+              {
+                path: 'files/report.zip',
+                sandboxPath: '/home/user/report.zip',
+                mimeType: 'application/zip',
+              },
+              ...(protectedValues
+                ? [
+                    { path: 'files/narrow.txt', sandboxPath: '/home/user/narrow.txt' },
+                    {
+                      path: 'files/short.json',
+                      sandboxPath: '/home/user/short.json',
+                      mimeType: 'application/json',
+                    },
+                  ]
+                : []),
+            ],
+          },
+        },
+        new Headers({ [PRIVATE_TOOL_METADATA_REQUEST_HEADER]: RESOLVED_SECRET_NAMES_METADATA_V1 })
+      )
+      const body = await response.json()
+      expect(response.status, JSON.stringify(body)).toBe(200)
+      expect(body[RESOLVED_SECRET_NAMES_FIELD].sort()).toEqual(
+        protectedValues
+          ? ['BOUNDARY', 'EXEMPT_KEY', 'PROTECTED_KEY', 'SHORT', 'SHORT_ESCAPED']
+          : ['EXEMPT_KEY', 'SHORT', 'SHORT_ESCAPED']
+      )
+      expect(JSON.stringify(body)).not.toContain('encryptedValue')
+      const exported = body.output.exported.files
+      expect(exported).toHaveLength(protectedValues ? 3 : 1)
+      const archive = await readFunctionFile(ids, exported[0].fileId)
+      expect(archive.bytes).toEqual(bytes)
+      expect(archive.provenance.status).toBe('exact')
+      if (archive.provenance.status !== 'exact')
+        throw new Error('Function export lost known lineage')
+      const decrypted = await Promise.all(
+        archive.provenance.entries.map(async (entry) => ({
+          name: entry.name,
+          value: (await decryptSecret(entry.encryptedValue)).decrypted,
+        }))
+      )
+      expect(decrypted).toEqual(
+        protectedValues
+          ? [
+              { name: 'BOUNDARY', value: boundary },
+              { name: 'PROTECTED_KEY', value: FIXTURE_SECRET },
+            ]
+          : []
+      )
+      expect(archive.imported).toBe(true)
+      const readback = await readArchiveReport(archive.bytes)
+      expect(readback).toBe(content)
+      expect(projectResolvedSecretModelContent(readback, archive.registry)).toMatchObject({
+        safe: true,
+        value: protectedValues ? `{{PROTECTED_KEY}}\n{{BOUNDARY}}\n${short}` : content,
+      })
+      expect(await isOpaqueWorkspaceFileEgressSafe(ids.workspaceId, archive.identity)).toBe(
+        !protectedValues
+      )
+      if (protectedValues) {
+        const narrowed = await readFunctionFile(ids, exported[1].fileId)
+        expect(narrowed.bytes.toString()).toBe(boundary)
+        expect(narrowed.provenance).toMatchObject({
+          status: 'exact',
+          entries: [{ name: 'BOUNDARY' }],
+        })
+        expect(narrowed.imported).toBe(true)
+        expect(
+          projectResolvedSecretModelContent(narrowed.bytes.toString(), narrowed.registry)
+        ).toMatchObject({
+          safe: true,
+          value: '{{BOUNDARY}}',
+        })
+        const shortOutput = await readFunctionFile(ids, exported[2].fileId)
+        expect(shortOutput.bytes.toString()).toBe(shortJson)
+        expect(shortOutput.provenance).toEqual({ status: 'exact', entries: [] })
+        expect(shortOutput.imported).toBe(true)
+        expect(
+          projectResolvedSecretModelContent(shortOutput.bytes.toString(), shortOutput.registry)
+        ).toMatchObject({ safe: true, value: shortJson })
+      }
+    }
+  )
+
+  it.each([
+    { name: 'report.zip', compressed: true, known: true, absent: false },
+    { name: 'report.txt', compressed: true, known: true, absent: false },
+    { name: 'report.zip', compressed: false, known: true, absent: false },
+    { name: 'report.zip', compressed: true, known: true, absent: true },
+    { name: 'report.zip', compressed: true, known: false, absent: true },
+  ])(
+    'persists harvested $name lineage (compressed=$compressed, known=$known, absent=$absent)',
+    async ({ name, compressed, known, absent }) => {
+      const ids = await seed()
+      const provenance: WorkspaceFileSecretProvenance = {
+        status: 'exact',
+        entries: [
+          {
+            name: 'MOUNT_TOKEN',
+            encryptedValue: (await encryptSecret(FIXTURE_SECRET)).encrypted,
+            sourceUserId: ids.aliceId,
+            sourceWorkspaceId: ids.workspaceId,
+          },
+        ],
+      }
+      const input = await uploadExecutionFile(
+        ids,
+        Buffer.from(FIXTURE_SECRET),
+        'input.txt',
+        'text/plain',
+        ids.aliceId,
+        known ? provenance : undefined
+      )
+      const zip = new JSZip()
+      zip.file('report.txt', FIXTURE_SECRET)
+      const bytes = compressed
+        ? await zip.generateAsync({ type: 'nodebuffer', compression: 'DEFLATE' })
+        : Buffer.from('Ordinary UTF-8 bytes declared as an archive')
+      expect(bytes.includes(FIXTURE_SECRET)).toBe(false)
+      remoteSandboxMockFns.mockExecuteInSandbox.mockResolvedValueOnce({
+        result: 'done',
+        stdout: '',
+        sandboxId: 'fixture',
+        collectedFiles: [
+          {
+            relativePath: name,
+            path: `/tmp/sim/outputs/${name}`,
+            contentBase64: bytes.toString('base64'),
+            byteLength: bytes.length,
+          },
+        ],
+      })
+      const registry = new ResolvedSecretTraceRegistry([], {
+        userId: ids.aliceId,
+        workspaceId: ids.workspaceId,
+      })
+      if (absent) registry.markIncomplete('source-provenance-incomplete')
+      const finishActivation = registry.beginPendingActivation()
+      let response: Awaited<ReturnType<typeof executeFunction>>
+      try {
+        response = await executeFunction(
+          ids,
+          {
+            code: 'print("done")',
+            files: [input],
+            fileKeys: [input.key],
+          },
+          new Headers(),
+          registry
+        )
+      } finally {
+        finishActivation()
+      }
+      const body = await response.json()
+      expect(response.status, JSON.stringify(body)).toBe(200)
+      expect(body.output.files).toHaveLength(1)
+      expect(JSON.stringify(body)).not.toContain('encryptedValue')
+      const exported = await readFunctionFile(ids, body.output.files[0].id)
+      expect(exported.identity.context).toBe('execution')
+      expect(exported.bytes).toEqual(bytes)
+      expect(exported.provenance).toEqual(known ? provenance : { status: 'unrecorded' })
+      expect(exported.imported).toBe(true)
+      const value = compressed ? await readArchiveReport(exported.bytes) : exported.bytes.toString()
+      expect(projectResolvedSecretModelContent(value, exported.registry)).toMatchObject({
+        safe: true,
+        value: compressed ? (known ? '{{MOUNT_TOKEN}}' : FIXTURE_SECRET) : bytes.toString(),
+      })
+      expect(await isOpaqueWorkspaceFileEgressSafe(ids.workspaceId, exported.identity)).toBe(!known)
+    }
+  )
+
+  it.each([
+    { input: 'params', unredacted: false },
+    { input: 'contextVariables', unredacted: false },
+    { input: 'contextVariables', unredacted: true },
+  ] as const)(
+    'persists runtime $input candidates with trusted exemption=$unredacted',
+    async ({ input, unredacted }) => {
+      const ids = await seed()
+      const registry = new ResolvedSecretTraceRegistry(
+        [
+          {
+            name: 'INPUT_TOKEN',
+            plaintext: FIXTURE_SECRET,
+            encryptedValue: (await encryptSecret(FIXTURE_SECRET)).encrypted,
+            ...(unredacted ? { unredacted: true as const } : {}),
+          },
+        ],
+        { userId: ids.aliceId, workspaceId: ids.workspaceId }
+      )
+      expect(
+        registry.recordResolvedAtInputPath('INPUT_TOKEN', FIXTURE_SECRET, [input, 'token'])
+      ).toBe(true)
+      const zip = new JSZip()
+      zip.file('report.txt', FIXTURE_SECRET)
+      const bytes = await zip.generateAsync({ type: 'nodebuffer', compression: 'DEFLATE' })
+      remoteSandboxMockFns.mockExecuteInSandbox.mockResolvedValueOnce({
+        result: 'done',
+        stdout: '',
+        sandboxId: 'fixture',
+        collectedFiles: [
+          {
+            relativePath: 'report.zip',
+            path: '/tmp/sim/outputs/report.zip',
+            contentBase64: bytes.toString('base64'),
+            byteLength: bytes.length,
+          },
+        ],
+      })
+      const response = await executeFunction(
+        ids,
+        {
+          code: input === 'params' ? 'value = params["token"]' : 'value = token',
+          [input]: { token: FIXTURE_SECRET },
+        },
+        new Headers(),
+        registry
+      )
+      const body = await response.json()
+      expect(response.status, JSON.stringify(body)).toBe(200)
+      const exported = await readFunctionFile(ids, body.output.files[0].id)
+      expect(exported.bytes).toEqual(bytes)
+      expect(exported.provenance).toMatchObject({
+        status: 'exact',
+        entries: unredacted ? [] : [{ name: 'INPUT_TOKEN' }],
+      })
+      expect(exported.imported).toBe(true)
+      const readback = await readArchiveReport(exported.bytes)
+      expect(projectResolvedSecretModelContent(readback, exported.registry)).toMatchObject({
+        safe: true,
+        value: unredacted ? FIXTURE_SECRET : '{{INPUT_TOKEN}}',
+      })
+      expect(await isOpaqueWorkspaceFileEgressSafe(ids.workspaceId, exported.identity)).toBe(
+        unredacted
+      )
+    }
+  )
+
+  it.each([
+    { extension: 'txt', evidence: 'incomplete' },
+    { extension: 'zip', evidence: 'incomplete' },
+    { extension: 'zip', evidence: 'complete' },
+    { extension: 'zip', evidence: 'corrupt' },
+  ] as const)(
+    'persists $evidence private mounted evidence for a declared $extension export',
+    async ({ extension, evidence }) => {
+      const ids = await seed()
+      const { encrypted } = await encryptSecret(FIXTURE_SECRET)
+      const encryptedValue =
+        evidence === 'corrupt'
+          ? `${encrypted.slice(0, -1)}${encrypted.endsWith('0') ? '1' : '0'}`
+          : encrypted
+      const zip = new JSZip()
+      zip.file('report.txt', FIXTURE_SECRET)
+      const bytes =
+        extension === 'zip'
+          ? await zip.generateAsync({ type: 'nodebuffer', compression: 'DEFLATE' })
+          : Buffer.from('ordinary output')
+      expect(bytes.includes(FIXTURE_SECRET)).toBe(false)
+      remoteSandboxMockFns.mockExecuteInSandbox.mockResolvedValueOnce({
+        result: 'done',
+        stdout: '',
+        sandboxId: 'fixture',
+        exportedFiles: {
+          [`/home/user/output.${extension}`]: bytes.toString(
+            extension === 'zip' ? 'base64' : 'utf8'
+          ),
+        },
+      })
+      const response = await executeFunction(
+        ids,
+        {
+          code: 'print("done")',
+          outputs: {
+            files: [
+              { path: `files/output.${extension}`, sandboxPath: `/home/user/output.${extension}` },
+            ],
+          },
+          [PRIVATE_SECRET_PROVENANCE_FIELD]: {
+            version: 1,
+            complete: evidence !== 'incomplete',
+            selections:
+              evidence === 'incomplete'
+                ? []
+                : [
+                    {
+                      key: MOUNTED_WORKSPACE_FILES_PROVENANCE_KEY,
+                      provenance: {
+                        version: 1,
+                        complete: true,
+                        entries: [{ encryptedValue }],
+                        scope: { userId: ids.aliceId, workspaceId: ids.workspaceId },
+                      },
+                    },
+                  ],
+          },
+        },
+        new Headers({ [PRIVATE_SECRET_PROVENANCE_HEADER]: PRIVATE_SECRET_PROVENANCE_BUNDLE_V1 })
+      )
+      const body = await response.json()
+      expect(response.status, JSON.stringify(body)).toBe(200)
+      expect(JSON.stringify(body)).not.toContain(encryptedValue)
+      const output = await readFunctionFile(ids, body.output.exported.files[0].fileId)
+      expect(output.bytes).toEqual(bytes)
+      expect(output.imported).toBe(evidence === 'complete')
+      expect(await isOpaqueWorkspaceFileEgressSafe(ids.workspaceId, output.identity)).toBe(false)
+      if (evidence === 'complete') {
+        expect(output.provenance).toEqual({
+          status: 'exact',
+          entries: [
+            {
+              name: 'MOUNTED_FILE_SECRET',
+              encryptedValue,
+              sourceUserId: ids.aliceId,
+              sourceWorkspaceId: ids.workspaceId,
+            },
+          ],
+        })
+        const readback = await readArchiveReport(output.bytes)
+        expect(readback).toBe(FIXTURE_SECRET)
+        expect(projectResolvedSecretModelContent(readback, output.registry)).toMatchObject({
+          safe: true,
+          value: '{{MOUNTED_FILE_SECRET}}',
+        })
+      } else {
+        expect(output.provenance).toEqual({ status: 'unknown' })
+      }
+    }
+  )
 })
 
 describe('execution archive durable provenance', () => {
@@ -258,34 +771,61 @@ describe('execution archive durable provenance', () => {
     expect(await getBoundWorkspaceFileSecretProvenance(ids.workspaceId, source.identity)).toEqual({
       status: 'unknown',
     })
+    expect(
+      await importWorkspaceFileSecretProvenanceForRuntime({
+        workspaceId: ids.workspaceId,
+        identity: source.identity,
+        registry: new ResolvedSecretTraceRegistry([], {
+          userId: ids.aliceId,
+          workspaceId: ids.workspaceId,
+        }),
+      })
+    ).toBe(false)
     await assertBlockedConsumers(ids, source)
   })
 
-  it('does not infer safe extracted bytes from a secret-bearing archive or expose private metadata', async () => {
+  it('retains extracted secret lineage for protected runtime readback without permitting opaque delivery', async () => {
     const ids = await seed()
     const { encrypted } = await encryptSecret(FIXTURE_SECRET)
-    const archive = await uploadArchive(
-      ids,
-      {
-        status: 'exact',
-        entries: [
-          {
-            name: 'FIXTURE_SECRET',
-            encryptedValue: encrypted,
-            sourceUserId: ids.aliceId,
-            sourceWorkspaceId: ids.workspaceId,
-          },
-        ],
-      },
-      `name,description\nOrion,${FIXTURE_SECRET}\n`
-    )
+    const provenance: WorkspaceFileSecretProvenance = {
+      status: 'exact',
+      entries: [
+        {
+          name: 'FIXTURE_SECRET',
+          encryptedValue: encrypted,
+          sourceUserId: ids.aliceId,
+          sourceWorkspaceId: ids.workspaceId,
+        },
+      ],
+    }
+    const content = `name,description\nOrion,${FIXTURE_SECRET}\n`
+    const archive = await uploadArchive(ids, provenance, content)
     const source = await extract(ids, archive)
     expect(source.publicMetadata).not.toContain(FIXTURE_SECRET)
     expect(source.publicMetadata).not.toContain(encrypted)
     expect(source.publicMetadata).not.toContain('encryptedValue')
-    expect(await getBoundWorkspaceFileSecretProvenance(ids.workspaceId, source.identity)).toEqual({
-      status: 'unknown',
+    expect(await getBoundWorkspaceFileSecretProvenance(ids.workspaceId, source.identity)).toEqual(
+      provenance
+    )
+    const registry = new ResolvedSecretTraceRegistry([], {
+      userId: ids.aliceId,
+      workspaceId: ids.workspaceId,
     })
+    expect(
+      await importWorkspaceFileSecretProvenanceForRuntime({
+        workspaceId: ids.workspaceId,
+        identity: source.identity,
+        registry,
+      })
+    ).toBe(true)
+    const storedContent = (
+      await downloadFile({ key: source.child.key, context: 'workspace' })
+    ).toString()
+    expect(storedContent).toBe(content)
+    const projected = projectResolvedSecretModelContent(storedContent, registry)
+    expect(projected.safe).toBe(true)
+    if (!projected.safe) throw new Error('Known extracted lineage withheld runtime readback')
+    expect(projected.value).toBe('name,description\nOrion,{{FIXTURE_SECRET}}\n')
     await assertBlockedConsumers(ids, source)
   })
 
diff --git a/apps/sim/lib/mothership/persistence/tool-confirm/index.ts b/apps/sim/lib/mothership/persistence/tool-confirm/index.ts
index 5c15be12bde..800e162c265 100644
--- a/apps/sim/lib/mothership/persistence/tool-confirm/index.ts
+++ b/apps/sim/lib/mothership/persistence/tool-confirm/index.ts
@@ -11,6 +11,7 @@ import {
 } from '@/lib/mothership/async-runs/lifecycle'
 import {
   getAsyncToolCalls,
+  getClaimedWorkflowExecutionId,
   revokeExpiredSimToolExecutions,
 } from '@/lib/mothership/async-runs/repository'
 import { MothershipStreamV1ToolOutcome } from '@/lib/mothership/generated/mothership-stream-v1'
@@ -51,8 +52,10 @@ export async function getToolConfirmation(
   })
   if (!row) return null
   if (row.status === ASYNC_TOOL_STATUS.delivered) {
+    const executionId = getClaimedWorkflowExecutionId(row.claimedBy)
     return {
       status: ASYNC_TOOL_CONFIRMATION_STATUS.background,
+      ...(executionId ? { data: { executionId } } : {}),
       timestamp: row.updatedAt?.toISOString?.(),
     }
   }
diff --git a/apps/sim/lib/mothership/request/tools/workflow-client-settlement.integration.ts b/apps/sim/lib/mothership/request/tools/workflow-client-settlement.integration.ts
index de69ea80969..a67cdf1e019 100644
--- a/apps/sim/lib/mothership/request/tools/workflow-client-settlement.integration.ts
+++ b/apps/sim/lib/mothership/request/tools/workflow-client-settlement.integration.ts
@@ -36,6 +36,7 @@ import {
   detachAsyncToolCall,
   settleClientWorkflowToolExecution,
 } from '@/lib/mothership/async-runs/repository'
+import { getToolConfirmation } from '@/lib/mothership/persistence/tool-confirm'
 import { waitForWorkflowToolCompletion } from '@/lib/mothership/request/tools/client'
 import {
   reportQueuedClientWorkflowTool,
@@ -288,6 +289,10 @@ describe.runIf(Boolean(redisUrl))('settled client-claimed workflow tools', () =>
 
     await reportQueuedClientWorkflowTool({ toolCallId, executionId, workflowId })
 
+    expect(await getToolConfirmation(toolCallId)).toMatchObject({
+      status: 'background',
+      data: { executionId },
+    })
     expect(await waiting).toMatchObject({
       status: 'background',
       data: { workflowId, executionId },
diff --git a/apps/sim/lib/mothership/tools/handlers/workbench-confidentiality.live.test.ts b/apps/sim/lib/mothership/tools/handlers/workbench-confidentiality.live.test.ts
index 94cf2baa8c8..4e0f61e889a 100644
--- a/apps/sim/lib/mothership/tools/handlers/workbench-confidentiality.live.test.ts
+++ b/apps/sim/lib/mothership/tools/handlers/workbench-confidentiality.live.test.ts
@@ -1,4 +1,5 @@
 import { execFile } from 'node:child_process'
+import { createHash } from 'node:crypto'
 import { createReadStream } from 'node:fs'
 import { mkdir, mkdtemp, readdir, readFile, rm, stat, writeFile } from 'node:fs/promises'
 import { dirname, join } from 'node:path'
@@ -943,6 +944,84 @@ describe('persistent workbench output confidentiality', () => {
     expect(saved.buffer).toEqual(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0, 1]))
     expect(saved.secretProvenance).toEqual({ status: 'exact', entries: [] })
   })
+  it('retains export lineage for archive inspection and redaction in a fresh workbench', async () => {
+    const initial = await run('printf "%s" "$TOKEN" > payload.txt', ['TOKEN'])
+    expect(initial.projected.safe).toBe(true)
+    const result = await inResourceScope(() =>
+      executeFunctionExecute(
+        {
+          code: `python3 - <<'PYTHON'
+import zipfile
+with zipfile.ZipFile('bundle.zip', 'w', compression=zipfile.ZIP_DEFLATED) as archive:
+    archive.write('payload.txt')
+    archive.writestr('operations.json', '[]')
+PYTHON`,
+          language: 'shell',
+          outputs: { files: [{ path: 'files/bundle.zip', sandboxPath: 'bundle.zip' }] },
+        },
+        context()
+      )
+    )
+    expect(result.success).toBe(true)
+    const saved = io.write.mock.calls.at(-1)?.[0]
+    if (!saved) throw new Error('Archive export did not persist a file')
+    expect(saved.buffer.includes(Buffer.from(canary))).toBe(false)
+    expect(saved.secretProvenance).toMatchObject({
+      status: 'exact',
+      entries: [expect.objectContaining({ name: 'TOKEN', sourceUserId: scope.userId })],
+    })
+    expect(JSON.stringify(saved.secretProvenance)).not.toContain(canary)
+
+    root = await mkdtemp('/private/tmp/sim-workbench-test-')
+    roots.push(root)
+    await mkdir(workerPath('/home/user'), { recursive: true })
+    chatId = `review-${generateShortId(12)}`
+    machine = localWorker()
+    io.find.mockResolvedValue(machine)
+    parent = new ResolvedSecretTraceRegistry([], scope)
+    const identity = { providerId: 'e2b' as const, sandboxId: machine.sandboxId }
+    await initializeSessionFileProvenance(chatSandboxSessionKey(chatId), identity)
+    const file = createWorkbenchFileProvenance({
+      ...scope,
+      sessionKey: chatSandboxSessionKey(chatId),
+    })
+    const stream = new Blob([saved.buffer]).stream()
+    file.trackDownload(stream, saved.secretProvenance)
+    await machine.writeFile(
+      '/home/user/bundle.zip',
+      Buffer.from(await new Response(file.observeDownload(identity, stream)).arrayBuffer())
+    )
+    const listing = await run(`python3 - <<'PYTHON'
+import hashlib, zipfile
+with open('bundle.zip', 'rb') as source:
+    print(hashlib.sha256(source.read()).hexdigest())
+with zipfile.ZipFile('bundle.zip') as archive:
+    print(','.join(archive.namelist()))
+    archive.extractall()
+PYTHON`)
+    expect(listing.projected.safe).toBe(true)
+    expect(listing.projected.result).toMatchObject({
+      success: true,
+      output: {
+        stdout: `${createHash('sha256').update(saved.buffer).digest('hex')}\npayload.txt,operations.json`,
+      },
+    })
+    const readback = await run('cat payload.txt')
+    expect(readback.projected.safe).toBe(true)
+    expect(readback.projected.result).toMatchObject({
+      success: true,
+      output: { stdout: '{{TOKEN}}' },
+    })
+    expect(JSON.stringify(readback.projected.result)).not.toContain(canary)
+    const ordinary = await run('printf ready')
+    expect(ordinary.projected.result).toMatchObject({
+      success: true,
+      output: { stdout: 'ready' },
+    })
+    expect(
+      (await readCliInputFile(chatSandboxSessionKey(chatId), 'operations.json')).toString()
+    ).toBe('[]')
+  })
   it('retains historical secret provenance on a text export', async () => {
     await run('printf "%s" "$TOKEN" > saved.txt', ['TOKEN'])
     const current = context()
diff --git a/apps/sim/lib/uploads/archive.test.ts b/apps/sim/lib/uploads/archive.test.ts
index 83dc60ee911..8dffaf3009b 100644
--- a/apps/sim/lib/uploads/archive.test.ts
+++ b/apps/sim/lib/uploads/archive.test.ts
@@ -261,30 +261,6 @@ describe('decompressArchiveBufferToWorkspaceFiles', () => {
     expect(mockPurge).not.toHaveBeenCalled()
   })
 
-  it('marks extracted files unknown when an archive has secret provenance', async () => {
-    const buffer = await buildZip({ 'one.txt': 'one', 'two.txt': 'two' })
-    const secretProvenance = {
-      status: 'exact' as const,
-      entries: [{ name: 'TOKEN', encryptedValue: 'encrypted-token' }],
-    }
-
-    await decompressArchiveBufferToWorkspaceFiles(buffer, {
-      workspaceId: 'ws',
-      principal: TEST_PRINCIPAL,
-      secretProvenance,
-    })
-
-    expect(mockUpload).toHaveBeenCalledTimes(2)
-    for (const call of mockUpload.mock.calls) {
-      expect(call[0].input).toEqual(
-        expect.objectContaining({
-          secretProvenance: { status: 'unknown' },
-          notifyWorkspaceChange: false,
-        })
-      )
-    }
-  })
-
   it('rejects an archive with more central-directory records than the cap, before parsing', async () => {
     // A structurally valid central directory (EOCD-anchored) with one record more
     // than the parse-graph cap. JSZip would build one entry per record in the
diff --git a/apps/sim/lib/uploads/archive.ts b/apps/sim/lib/uploads/archive.ts
index 27675986a12..7762193915a 100644
--- a/apps/sim/lib/uploads/archive.ts
+++ b/apps/sim/lib/uploads/archive.ts
@@ -291,8 +291,8 @@ function throwInflateCapError(reason: 'entry' | 'total', entryName: string): nev
  * Filesystem-noise entries (`__MACOSX/`, `.DS_Store`, `Thumbs.db`) are extracted
  * verbatim unless `skipNoiseEntries` is set — the HTTP decompress route preserves
  * them; the agent-facing extract path drops them. Decompression is not byte-preserving,
- * so known secret contributions become unknown on extracted files. Exact-empty and unrecorded
- * classifications retain their existing input policy without changing the extracted bytes.
+ * so every extracted file inherits the archive's full candidate set. Runtime consumers redact
+ * decoded content; direct opaque delivery still refuses known secret contributions.
  */
 export async function decompressArchiveBufferToWorkspaceFiles(
   buffer: Buffer,
@@ -321,11 +321,6 @@ export async function decompressArchiveBufferToWorkspaceFiles(
     secretProvenance = { status: 'unknown' },
     notifyWorkspaceChange = true,
   } = opts
-  const extractedSecretProvenance: WorkspaceFileSecretProvenance =
-    secretProvenance.status === 'unrecorded' ||
-    (secretProvenance.status === 'exact' && secretProvenance.entries.length === 0)
-      ? secretProvenance
-      : { status: 'unknown' }
 
   assertCentralDirWithinCaps(buffer)
 
@@ -491,7 +486,7 @@ export async function decompressArchiveBufferToWorkspaceFiles(
             // Auto-suffix on collision: one leaf name that already exists must not
             // roll back an otherwise valid extraction.
             exactName: false,
-            secretProvenance: extractedSecretProvenance,
+            secretProvenance,
             notifyWorkspaceChange: false,
           },
         })