refactor(copilot): remove the plan/changelog VFS artifacts and workflow aliases

These beta surfaces are not a direction we are taking, so they come out rather
than staying behind a flag. Gone: the workflow alias modules (path resolution,
DB-backed resolver, .plans/.changelogs backing provisioning), the alias
materialization in the copilot VFS, the alias write paths in resource-writer
and workspace_file, the sandbox alias mounts in function_execute, the reserved
backing-path guards across mkdir/mv/create, and the alias resolution in the
chat home file picker.

xlsx survives but changes owner. It was gated twice across the repo boundary:
mothership's xlsx-writing flag gates the skill and prompt, while Sim gated the
compile path on mothership-beta. Those live in separate AppConfig applications,
so an operator had to flip two flags in two consoles, and off-hosted Sim fell
back to the MOTHERSHIP_BETA_FEATURES secret while the mothership half stayed in
Sim Cloud's AppConfig — split-brain across an ownership boundary. Mothership
controls whether the model ever learns xlsx exists, so if it is never offered
it is never requested and the second chokepoint only created a way for the two
halves to disagree. Sim's gate is removed; xlsx-writing is now the single owner.

With its last consumer gone, the mothership-beta flag and the
MOTHERSHIP_BETA_FEATURES secret are deleted. The two entries in the infra repo
are harmless until removed separately: they only inject an env var nothing
reads, and createEnv runs with skipValidation.

The reserved-system-file/folder concept goes with the aliases, since it existed
only to hide the backing rows. includeReservedSystemFiles and
includeReservedSystemFolders are removed rather than left as options every
caller passes true to. backingVfsPath is removed for the same reason — nothing
sets it once aliases are gone, so it was an always-undefined field on tool
results.

Test coverage is preserved rather than deleted with the feature.
resource-writer.test.ts looked alias-only but three of its eleven cases cover
the generic create path that survives; those are kept and the file retitled.
Two open_resource tests and one output-path test used alias-shaped strings
while asserting generic behavior; retargeted or dropped where a sibling already
covers it.

Author: Sg312

apps/sim/app/api/function/execute/route.ts

@@ -1343,7 +1343,6 @@ async function maybeExportSandboxFilesToWorkspace(args: {
           fileId: file.id,
           fileName: file.name,
           vfsPath: file.vfsPath,
-          backingVfsPath: file.backingVfsPath,
           downloadUrl: file.downloadUrl,
           sandboxPath: file.sandboxPath,
           size: file.exportedBytes,

apps/sim/app/workspace/[workspaceId]/home/home.tsx

@@ -20,11 +20,6 @@ import { usePostHog } from 'posthog-js/react'
 import { requestJson } from '@/lib/api/client/request'
 import { createWorkflowContract } from '@/lib/api/contracts'
 import { canonicalWorkspaceFilePath } from '@/lib/copilot/vfs/path-utils'
-import {
-  buildWorkflowAliasWorkflowEntries,
-  resolveWorkflowAliasPath,
-  resolveWorkspacePlanAliasPath,
-} from '@/lib/copilot/vfs/workflow-aliases'
 import {
   LandingPromptStorage,
   type LandingWorkflowSeed,
@@ -379,54 +374,28 @@ export function Home({ chatId, userName, userId }: HomeProps) {
     removeResource(resolved.type, resolved.id)
   }
 
-  const workflowAliasEntries = useMemo(
-    () =>
-      buildWorkflowAliasWorkflowEntries(
-        workflows.map((workflow) => ({
-          id: workflow.id,
-          name: workflow.name,
-          folderId: workflow.folderId ?? null,
-        })),
-        folders.map((folder) => ({
-          folderId: folder.id,
-          folderName: folder.name,
-          parentId: folder.parentId ?? null,
-        }))
-      ),
-    [folders, workflows]
-  )
-
   const resolveFileResource = useCallback(
     (resource: MothershipResource): MothershipResource => {
       if (resource.type !== 'file') return resource
 
       const reference = (resource.path || resource.id).trim()
-      const workspacePlanAlias = resolveWorkspacePlanAliasPath(reference)
-      const workflowAlias = workspacePlanAlias
-        ? null
-        : resolveWorkflowAliasPath(reference, workflowAliasEntries)
-      const alias = workspacePlanAlias || workflowAlias
-      const targetPath = alias && alias.kind !== 'plans_dir' ? alias.backingPath : reference
 
       const file = workspaceFiles.find((candidate) => {
         const candidatePath = canonicalWorkspaceFilePath({
           folderPath: candidate.folderPath,
           name: candidate.name,
         })
-        return (
-          candidate.id === reference || candidatePath === reference || candidatePath === targetPath
-        )
+        return candidate.id === reference || candidatePath === reference
       })
 
       if (!file) return resource
       return {
         ...resource,
         id: file.id,
         title: resource.title || file.name,
-        path: alias ? reference : resource.path,
       }
     },
-    [workflowAliasEntries, workspaceFiles]
+    [workspaceFiles]
   )
 
   function handleWorkspaceResourceSelect(resource: MothershipResource) {

apps/sim/lib/copilot/request/tools/files.test.ts

@@ -93,12 +93,10 @@ describe('serializeOutputForFile (json / txt / md)', () => {
 })
 
 describe('normalizeOutputWorkspaceFileName', () => {
-  it('derives the leaf file name from workflow alias output paths', () => {
-    expect(normalizeOutputWorkspaceFileName('workflows/My%20Workflow/changelog.md')).toBe(
-      'changelog.md'
-    )
+  it('derives the leaf file name from nested, percent-encoded output paths', () => {
+    expect(normalizeOutputWorkspaceFileName('files/My%20Folder/notes.md')).toBe('notes.md')
     expect(
-      normalizeOutputWorkspaceFileName('workflows/My%20Workflow/.plans/phase%201/implementation.md')
+      normalizeOutputWorkspaceFileName('files/My%20Folder/phase%201/implementation.md')
     ).toBe('implementation.md')
   })
 

apps/sim/lib/copilot/tools/handlers/function-execute.test.ts

@@ -64,13 +64,6 @@ vi.mock('@/lib/copilot/vfs/path-utils', () => ({
   decodeVfsPathSegments: (p: string) => p.split('/'),
   encodeVfsPathSegments: (s: string[]) => s.join('/'),
 }))
-vi.mock('@/lib/copilot/vfs/workflow-alias-resolver', () => ({
-  resolveWorkflowAliasForWorkspace: vi.fn().mockResolvedValue(null),
-}))
-vi.mock('@/lib/copilot/vfs/workflow-aliases', () => ({
-  isPlanAliasPath: () => false,
-  workflowAliasSandboxPath: (p: string) => p,
-}))
 
 import { executeFunctionExecute } from '@/lib/copilot/tools/handlers/function-execute'
 

apps/sim/lib/copilot/tools/handlers/function-execute.ts

@@ -1,7 +1,5 @@
 import { createLogger } from '@sim/logger'
 import { decodeVfsPathSegments, encodeVfsPathSegments } from '@/lib/copilot/vfs/path-utils'
-import { resolveWorkflowAliasForWorkspace } from '@/lib/copilot/vfs/workflow-alias-resolver'
-import { isPlanAliasPath, workflowAliasSandboxPath } from '@/lib/copilot/vfs/workflow-aliases'
 import { isFeatureEnabled } from '@/lib/core/config/feature-flags'
 import { getColumnId } from '@/lib/table/column-keys'
 import { formatCsvValue, neutralizeCsvFormula, toCsvRow } from '@/lib/table/export-format'
@@ -174,17 +172,14 @@ export async function resolveInputFiles(
 ): Promise<SandboxFile[]> {
   const sandboxFiles: SandboxFile[] = []
   const mounted: MountedBytes = { buffered: 0, url: 0 }
-  const betaEnabled = await isFeatureEnabled('mothership-beta')
 
   if (inputFiles?.length && workspaceId) {
     if (inputFiles.length > MAX_MOUNTED_FILES) {
       throw new Error(
         `Too many input files (${inputFiles.length}). Maximum is ${MAX_MOUNTED_FILES}. Mount fewer files.`
       )
     }
-    const allFiles = await listWorkspaceFiles(workspaceId, {
-      includeReservedSystemFiles: betaEnabled,
-    })
+    const allFiles = await listWorkspaceFiles(workspaceId)
     for (const fileRef of inputFiles) {
       const filePath =
         typeof fileRef === 'string'
@@ -193,16 +188,7 @@ export async function resolveInputFiles(
             ? (fileRef as CanonicalFileInput).path
             : undefined
       if (!filePath) continue
-      const alias = await resolveWorkflowAliasForWorkspace({ workspaceId, path: filePath })
-      if (!alias && isPlanAliasPath(filePath)) {
-        logger.warn('Unsupported plan alias input file path', { filePath })
-        continue
-      }
-      if (alias?.kind === 'plans_dir') {
-        logger.warn('Input file is a plan alias directory', { filePath })
-        continue
-      }
-      const record = findWorkspaceFileRecord(allFiles, alias?.backingPath ?? filePath)
+      const record = findWorkspaceFileRecord(allFiles, filePath)
       if (!record) {
         if (filePath.startsWith('uploads/')) {
           throw new Error(
@@ -217,21 +203,14 @@ export async function resolveInputFiles(
         typeof fileRef === 'object' && fileRef !== null
           ? (fileRef as CanonicalFileInput).sandboxPath
           : undefined
-      const mountPath =
-        explicitSandboxPath ||
-        (alias ? workflowAliasSandboxPath(alias.aliasPath) : getSandboxWorkspaceFilePath(record))
+      const mountPath = explicitSandboxPath || getSandboxWorkspaceFilePath(record)
       await pushWorkspaceFileMount(sandboxFiles, record, mountPath, mounted)
     }
   }
 
   if (inputDirectories?.length && workspaceId) {
-    const folders = await listWorkspaceFileFolders(workspaceId, {
-      includeReservedSystemFolders: betaEnabled,
-    })
-    const allFiles = await listWorkspaceFiles(workspaceId, {
-      folders,
-      includeReservedSystemFiles: betaEnabled,
-    })
+    const folders = await listWorkspaceFileFolders(workspaceId)
+    const allFiles = await listWorkspaceFiles(workspaceId, { folders })
     for (const dirRef of inputDirectories) {
       const dirPath =
         typeof dirRef === 'string'
@@ -240,15 +219,7 @@ export async function resolveInputFiles(
             ? (dirRef as CanonicalDirectoryInput).path
             : undefined
       if (!dirPath) continue
-      const alias = await resolveWorkflowAliasForWorkspace({ workspaceId, path: dirPath })
-      if (alias && alias.kind !== 'plans_dir') {
-        throw new Error(`Input directory is a plan alias file, not a directory: ${dirPath}`)
-      }
-      if (!alias && isPlanAliasPath(dirPath)) {
-        throw new Error(`Unsupported plan alias directory: ${dirPath}`)
-      }
-      const backingDirPath = alias?.backingPath ?? dirPath
-      const folderSegments = decodeVfsPathSegments(backingDirPath.replace(/^\/?files\/?/, ''))
+      const folderSegments = decodeVfsPathSegments(dirPath.replace(/^\/?files\/?/, ''))
       const folderDisplayPath = folderSegments.join('/')
       const folder = folders.find((candidate) => candidate.path === folderDisplayPath)
       if (!folder) {
@@ -259,9 +230,7 @@ export async function resolveInputFiles(
         dirRef !== null &&
         (dirRef as CanonicalDirectoryInput).sandboxPath
           ? (dirRef as CanonicalDirectoryInput).sandboxPath!
-          : alias
-            ? workflowAliasSandboxPath(alias.aliasPath)
-            : `/home/user/files/${encodeVfsPathSegments(folder.path.split('/'))}`
+          : `/home/user/files/${encodeVfsPathSegments(folder.path.split('/'))}`
       const descendants = allFiles.filter((file) => {
         if (!file.folderPath) return false
         return file.folderPath === folder.path || file.folderPath.startsWith(`${folder.path}/`)
@@ -300,11 +269,7 @@ export async function resolveInputFiles(
       for (const record of descendants) {
         const relativeFolder =
           record.folderPath?.slice(folder.path.length).replace(/^\/+/, '') ?? ''
-        const relativePath = alias
-          ? encodeVfsPathSegments(
-              [relativeFolder, record.name].filter(Boolean).join('/').split('/')
-            )
-          : [relativeFolder, record.name].filter(Boolean).join('/')
+        const relativePath = [relativeFolder, record.name].filter(Boolean).join('/')
         await pushWorkspaceFileMount(sandboxFiles, record, `${mountRoot}/${relativePath}`, mounted)
       }
     }

apps/sim/lib/copilot/tools/handlers/resources.test.ts

@@ -104,62 +104,4 @@ describe('executeOpenResource', () => {
     })
   })
 
-  it('opens workflow alias file paths through workspace file reference resolution', async () => {
-    resolveWorkspaceFileReferenceMock.mockResolvedValue({
-      id: 'wf_plan_file',
-      name: 'implementation.md',
-      folderPath: 'system/workflows/My Workflow/.plans',
-    })
-
-    const result = await executeOpenResource(
-      {
-        resources: [{ type: 'file', path: 'workflows/My%20Workflow/.plans/implementation.md' }],
-      },
-      { userId: 'user-1', workflowId: 'workflow-1', workspaceId: 'workspace-1' }
-    )
-
-    expect(resolveWorkspaceFileReferenceMock).toHaveBeenCalledWith(
-      'workspace-1',
-      'workflows/My%20Workflow/.plans/implementation.md'
-    )
-    expect(result).toMatchObject({
-      success: true,
-      resources: [
-        {
-          type: 'file',
-          id: 'wf_plan_file',
-          title: 'implementation.md',
-          path: 'files/system/workflows/My%20Workflow/.plans/implementation.md',
-        },
-      ],
-    })
-  })
-
-  it('opens root plan alias file paths through workspace file reference resolution', async () => {
-    resolveWorkspaceFileReferenceMock.mockResolvedValue({
-      id: 'wf_root_plan',
-      name: 'root.md',
-      folderPath: 'system/.plans',
-    })
-
-    const result = await executeOpenResource(
-      {
-        resources: [{ type: 'file', path: '.plans/root.md' }],
-      },
-      { userId: 'user-1', workflowId: 'workflow-1', workspaceId: 'workspace-1' }
-    )
-
-    expect(resolveWorkspaceFileReferenceMock).toHaveBeenCalledWith('workspace-1', '.plans/root.md')
-    expect(result).toMatchObject({
-      success: true,
-      resources: [
-        {
-          type: 'file',
-          id: 'wf_root_plan',
-          title: 'root.md',
-          path: 'files/system/.plans/root.md',
-        },
-      ],
-    })
-  })
 })

apps/sim/lib/copilot/tools/handlers/vfs-mutate.test.ts

@@ -273,15 +273,6 @@ describe('vfs mv/cp', () => {
       })
       expect(result.success).toBe(true)
     })
-
-    it('rejects reserved alias backing paths', async () => {
-      const result = await executeVfsMv(
-        { sources: ['files/.plans/wf_1/launch.md'], destination: 'files/launch.md' },
-        context
-      )
-      expect(result.success).toBe(false)
-      expect(result.error).toContain('Reserved system paths')
-    })
   })
 
   describe('workflows', () => {
@@ -420,14 +411,11 @@ describe('vfs mv/cp', () => {
       })
     })
 
-    it('rejects flat namespaces and reserved paths', async () => {
-      const result = await executeVfsMkdir({ paths: ['tables/CRM', 'files/.plans/wf_1'] }, context)
+    it('rejects flat namespaces', async () => {
+      const result = await executeVfsMkdir({ paths: ['tables/CRM'] }, context)
       expect(result.success).toBe(false)
       expect(result.output).toMatchObject({
-        results: [
-          { from: 'tables/CRM', error: expect.stringContaining('flat namespace') },
-          { from: 'files/.plans/wf_1', error: expect.stringContaining('Reserved') },
-        ],
+        results: [{ from: 'tables/CRM', error: expect.stringContaining('flat namespace') }],
       })
       expect(mocks.ensureWorkspaceFileFolderPath).not.toHaveBeenCalled()
     })

apps/sim/lib/copilot/tools/handlers/vfs-mutate.ts

@@ -16,7 +16,6 @@ import {
   decodeVfsPathSegments,
   encodeVfsPathSegments,
 } from '@/lib/copilot/vfs/path-utils'
-import { isWorkflowAliasBackingPath } from '@/lib/copilot/vfs/workflow-aliases'
 import { generateRequestId } from '@/lib/core/utils/request'
 import { getKnowledgeBases, updateKnowledgeBase } from '@/lib/knowledge/service'
 import { listTables, renameTable } from '@/lib/table/service'
@@ -161,11 +160,6 @@ export async function executeVfsMkdir(
         outcomes.push({ from: path, kind, error: 'Path must include at least one folder segment' })
         continue
       }
-      if (top === 'files' && isWorkflowAliasBackingPath(path)) {
-        outcomes.push({ from: path, kind, error: `Reserved system path: ${path}` })
-        continue
-      }
-
       try {
         assertMutationNotAborted(context)
         let folderId: string | null
@@ -348,15 +342,6 @@ async function mutateWorkspaceFiles(
       error: 'Workspace files cannot be copied — cp only duplicates workflows.',
     }
   }
-  for (const path of [...sources, destination]) {
-    if (isWorkflowAliasBackingPath(path)) {
-      return {
-        success: false,
-        error: `Reserved system paths cannot be moved or renamed: ${path}`,
-      }
-    }
-  }
-
   const dest = await planDestination({
     destination,
     sourceCount: sources.length,

apps/sim/lib/copilot/tools/server/files/create-file.ts

@@ -6,7 +6,6 @@ import {
   type ServerToolContext,
 } from '@/lib/copilot/tools/server/base-tool'
 import { writeWorkspaceFileByPath } from '@/lib/copilot/vfs/resource-writer'
-import { isPlanAliasPath } from '@/lib/copilot/vfs/workflow-aliases'
 import { inferContentType } from './workspace-file'
 
 const logger = createLogger('CreateFileServerTool')
@@ -27,7 +26,6 @@ interface CreateFileResult {
     name: string
     contentType: string
     vfsPath: string
-    backingVfsPath?: string
   }
 }
 
@@ -52,13 +50,6 @@ export const createFileServerTool: BaseServerTool<CreateFileArgs, CreateFileResu
     }
     const outputPath =
       outputFile?.path ?? (fileName.startsWith('files/') ? fileName : `files/${fileName}`)
-    if (isPlanAliasPath(outputPath)) {
-      return {
-        success: false,
-        message:
-          'create_file does not initialize plan aliases; changelog.md is created automatically per workflow.',
-      }
-    }
     const contentType = outputFile?.mimeType ?? inferContentType(outputPath, explicitType)
     const emptyBuffer = Buffer.from('', 'utf-8')
 
@@ -90,7 +81,6 @@ export const createFileServerTool: BaseServerTool<CreateFileArgs, CreateFileResu
         name: result.name,
         contentType,
         vfsPath: result.vfsPath,
-        backingVfsPath: result.backingVfsPath,
       },
     }
   },