fix(files): report a reference dependency from the isolated-VM compile path

The isolated-VM fallback returns before the static reference scan, so a document
it compiled never reported one — yet that path reads workspace files live through
its broker, which is what `onWorkspaceFileAccess` records. A versioned request for
such a document therefore still took a one-year immutable lifetime, and changing a
referenced file left the browser serving a stale render.

Fixed at the root rather than in that one branch: the flag is now required on
CompiledDocResult, so every compile path must declare it and a new one cannot
inherit a cacheable-forever answer by staying silent. Each site reports the union
of what the source references statically and what the compile actually touched —
neither alone is sufficient, since a failed read records no access and the broker
reaches files the static scan cannot see.

Making it required immediately surfaced a second case: the process-local compile
cache is shared with compiles that carried a workspace, so a cached entry can hold
contributor identities even when the reading call passes none. That branch now
reads the cached identities instead of assuming independence.

Author: waleedlatif1

apps/sim/lib/copilot/tools/server/files/doc-compile.test.ts

@@ -169,6 +169,7 @@ describe('collectReferencedFileIds', () => {
     ).resolves.toEqual({
       buffer: Buffer.from('%PDF-built'),
       contentType: 'application/pdf',
+      dependsOnReferencedFiles: true,
       contributingFiles: [
         {
           fileId: ID,
@@ -219,6 +220,7 @@ describe('collectReferencedFileIds', () => {
     ).resolves.toEqual({
       buffer: Buffer.from('%PDF-cached'),
       contentType: 'application/pdf',
+      dependsOnReferencedFiles: true,
       contributingFiles: [
         {
           fileId: ID,

apps/sim/lib/copilot/tools/server/files/doc-compile.ts

@@ -152,8 +152,24 @@ export interface CompiledDocResult {
    * function of this file's stored source alone: the same storage key compiles to different bytes
    * once a referenced file changes, with nothing about this file changing. A caller that assigns
    * the response a cache lifetime must not promise immutability for it.
+   *
+   * Required, so a compile path added or changed later cannot omit it and silently inherit a
+   * cacheable-forever answer — which is exactly what the isolated-VM fallback did while this was
+   * optional, despite reading workspace files live through its broker.
    */
-  dependsOnReferencedFiles?: boolean
+  dependsOnReferencedFiles: boolean
+}
+
+/**
+ * Whether a compile result must be treated as resolved against other files.
+ *
+ * The union of what the source ASKS for and what the compile actually TOUCHED. Neither alone is
+ * sufficient: a statically detectable reference whose read failed records no access, and the
+ * isolated-VM broker reaches files the static scan cannot see. Either one means these bytes can
+ * change while this file's own stored source does not.
+ */
+function touchesReferencedFiles(source: string, accessedCount: number): boolean {
+  return accessedCount > 0 || collectReferencedFileIds(source).size > 0
 }
 
 function referencedImageIdentities(
@@ -574,6 +590,7 @@ async function buildCompiledDoc(
   return {
     buffer,
     contentType: fmt.contentType,
+    dependsOnReferencedFiles: touchesReferencedFiles(args.source, contributingFiles.length),
     ...(contributingFiles.length > 0 ? { contributingFiles } : {}),
   }
 }
@@ -664,6 +681,10 @@ async function compileDocInLegacySandbox(
     return {
       buffer: cached.buffer,
       contentType: fmt.contentType,
+      dependsOnReferencedFiles: touchesReferencedFiles(
+        args.source,
+        cached.contributingFiles?.length ?? 0
+      ),
       ...(cached.contributingFiles && cached.contributingFiles.length > 0
         ? { contributingFiles: cached.contributingFiles }
         : {}),
@@ -686,6 +707,7 @@ async function compileDocInLegacySandbox(
   return {
     buffer,
     contentType: fmt.contentType,
+    dependsOnReferencedFiles: touchesReferencedFiles(args.source, contributingFiles.size),
     ...(contributingFiles.size > 0 ? { contributingFiles: [...contributingFiles.values()] } : {}),
   }
 }
@@ -729,6 +751,7 @@ export async function compileDoc(args: CompileArgs): Promise<CompiledDocResult>
     return {
       buffer: existing,
       contentType: fmt.contentType,
+      dependsOnReferencedFiles: touchesReferencedFiles(source, contributingFiles.length),
       ...(contributingFiles.length > 0 ? { contributingFiles } : {}),
     }
   }
@@ -898,11 +921,19 @@ export async function resolveServableDocBytes(args: {
   // explicitly alongside the table-driven formats.
   const magic = format?.magic ?? (extNoDot === 'xlsx' ? ZIP_MAGIC : undefined)
   if (magic && bufferStartsWith(rawBuffer, magic)) {
-    return { buffer: rawBuffer, contentType: getContentType(fileName) }
+    return {
+      buffer: rawBuffer,
+      contentType: getContentType(fileName),
+      dependsOnReferencedFiles: false,
+    }
   }
 
   if (!format && extNoDot !== 'xlsx') {
-    return { buffer: rawBuffer, contentType: getContentType(fileName) }
+    return {
+      buffer: rawBuffer,
+      contentType: getContentType(fileName),
+      dependsOnReferencedFiles: false,
+    }
   }
 
   const source = rawBuffer.toString('utf-8')
@@ -924,21 +955,15 @@ export async function resolveServableDocBytes(args: {
           'Referenced document resolution requires an authorized workspace file principal'
         )
       }
-      const compiled = await compileDoc({
-        source,
-        fileName,
-        workspaceId,
-        filePrincipal,
-        ownerKey,
-        signal,
-      })
-      return { ...compiled, dependsOnReferencedFiles: true }
+      return compileDoc({ source, fileName, workspaceId, filePrincipal, ownerKey, signal })
     }
     const stored = await loadCompiledDocByExt(workspaceId, source, extNoDot, {
       allowLegacyReferencedArtifact: true,
       filePrincipal,
     })
-    if (stored) return stored
+    // Reached only where the source references nothing, so the artifact is keyed by the source
+    // alone and cannot change while that source does not.
+    if (stored) return { ...stored, dependsOnReferencedFiles: false }
     throw new DocCompileUserError('Document is still being generated', { pending: true })
   }
 
@@ -952,6 +977,12 @@ export async function resolveServableDocBytes(args: {
     return {
       buffer: cached.buffer,
       contentType: format.contentType,
+      // The process-local cache is shared with compiles that DID carry a workspace, so a cached
+      // entry can hold contributor identities even though this call passed none.
+      dependsOnReferencedFiles: touchesReferencedFiles(
+        source,
+        cached.contributingFiles?.length ?? 0
+      ),
       ...(cached.contributingFiles && cached.contributingFiles.length > 0
         ? { contributingFiles: cached.contributingFiles }
         : {}),
@@ -964,5 +995,9 @@ export async function resolveServableDocBytes(args: {
     { ownerKey, signal }
   )
   compiledCacheSet(cacheKey, compiled)
-  return { buffer: compiled, contentType: format.contentType }
+  return {
+    buffer: compiled,
+    contentType: format.contentType,
+    dependsOnReferencedFiles: touchesReferencedFiles(source, 0),
+  }
 }

apps/sim/lib/copilot/tools/server/files/doc-servable.test.ts

@@ -379,11 +379,49 @@ describe('resolveServableDocBytes', () => {
         fileName: 'report.pdf',
         workspaceId: WORKSPACE_ID,
       })
-    ).resolves.toEqual({ buffer: compiled, contentType: 'application/pdf' })
+    ).resolves.toEqual({
+      buffer: compiled,
+      contentType: 'application/pdf',
+      // The isolated-VM path, but this source references nothing and the compile touched
+      // nothing — so it stays cacheable. The flag tracks dependency, not which backend ran.
+      dependsOnReferencedFiles: false,
+    })
     expect(mockLoadCompiledDoc).not.toHaveBeenCalled()
     expect(mockStoreCompiledDoc).not.toHaveBeenCalled()
   })
 
+  it('reports a reference dependency when the isolated-VM broker reads a workspace file', async () => {
+    /**
+     * The isolated-VM fallback returns before the static reference scan, so nothing about the
+     * SOURCE marks it as dependent — only the broker access does. Missing that is what let a
+     * versioned request take a one-year immutable lifetime for bytes that change when the
+     * referenced file changes.
+     */
+    const compiled = Buffer.from('%PDF-broker-read')
+    const contributor = {
+      fileId: 'broker-reference-1',
+      key: 'workspace/workspace-1/broker-reference-1.png',
+      context: 'workspace' as const,
+      contentUpdatedAt: new Date('2026-08-07T01:00:00.000Z'),
+    }
+    setEnvFlags({ isDocSandboxEnabled: false })
+    mockRunSandboxTask.mockImplementationOnce((...args: unknown[]) => {
+      const options = args[2] as {
+        onWorkspaceFileAccess?: (identity: typeof contributor) => void
+      }
+      options.onWorkspaceFileAccess?.(contributor)
+      return Promise.resolve(compiled)
+    })
+
+    const result = await resolveServableDocBytes({
+      rawBuffer: Buffer.from('const viaBroker = true'),
+      fileName: 'report.pdf',
+      workspaceId: WORKSPACE_ID,
+    })
+
+    expect(result.dependsOnReferencedFiles).toBe(true)
+  })
+
   it('preserves contributor identities when a servable document hits the local compile cache', async () => {
     const source = 'const cacheContributor = true'
     const compiled = Buffer.from('%PDF-cached-with-contributor')
@@ -413,6 +451,7 @@ describe('resolveServableDocBytes', () => {
     ).resolves.toEqual({
       buffer: compiled,
       contentType: 'application/pdf',
+      dependsOnReferencedFiles: true,
       contributingFiles: [contributor],
     })
 
@@ -425,6 +464,7 @@ describe('resolveServableDocBytes', () => {
     ).resolves.toEqual({
       buffer: compiled,
       contentType: 'application/pdf',
+      dependsOnReferencedFiles: true,
       contributingFiles: [contributor],
     })
     expect(mockRunSandboxTask).toHaveBeenCalledTimes(1)
@@ -443,7 +483,11 @@ describe('resolveServableDocBytes', () => {
       workspaceId: WORKSPACE_ID,
     })
 
-    expect(result).toEqual({ buffer: compiled, contentType: 'application/pdf' })
+    expect(result).toEqual({
+      buffer: compiled,
+      contentType: 'application/pdf',
+      dependsOnReferencedFiles: true,
+    })
     expect(mockExecuteInSandbox).not.toHaveBeenCalled()
     expect(mockRunSandboxTask).toHaveBeenCalledWith(
       'pdf-generate',
@@ -467,7 +511,11 @@ describe('resolveServableDocBytes', () => {
         fileName: 'report.pdf',
         workspaceId: WORKSPACE_ID,
       })
-    ).resolves.toEqual({ buffer: compiled, contentType: 'application/pdf' })
+    ).resolves.toEqual({
+      buffer: compiled,
+      contentType: 'application/pdf',
+      dependsOnReferencedFiles: true,
+    })
     expect(mockRunSandboxTask).toHaveBeenCalledTimes(1)
     expect(mockReadWorkspaceFileMetadata).not.toHaveBeenCalled()
     expect(mockStoreCompiledDoc).not.toHaveBeenCalled()