diff --git a/apps/code/src/main/services/context-menu/schemas.ts b/apps/code/src/main/services/context-menu/schemas.ts
index 9620d3ba87..c72bcbcac0 100644
--- a/apps/code/src/main/services/context-menu/schemas.ts
+++ b/apps/code/src/main/services/context-menu/schemas.ts
@@ -8,6 +8,9 @@ export const taskContextMenuInput = z.object({
   isSuspended: z.boolean().optional(),
   isInCommandCenter: z.boolean().optional(),
   hasEmptyCommandCenterCell: z.boolean().optional(),
+  fileToFolders: z
+    .array(z.object({ id: z.string(), path: z.string() }))
+    .optional(),
 });
 
 export const bulkTaskContextMenuInput = z.object({
@@ -47,6 +50,7 @@ const taskAction = z.discriminatedUnion("type", [
   z.object({ type: z.literal("delete") }),
   z.object({ type: z.literal("add-to-command-center") }),
   z.object({ type: z.literal("external-app"), action: externalAppAction }),
+  z.object({ type: z.literal("file-to"), folderPath: z.string() }),
 ]);
 
 const bulkTaskAction = z.discriminatedUnion("type", [
diff --git a/apps/code/src/main/services/context-menu/service.ts b/apps/code/src/main/services/context-menu/service.ts
index 93376654c7..ba5e5a13a8 100644
--- a/apps/code/src/main/services/context-menu/service.ts
+++ b/apps/code/src/main/services/context-menu/service.ts
@@ -113,13 +113,32 @@ export class ContextMenuService {
       isSuspended,
       isInCommandCenter,
       hasEmptyCommandCenterCell,
+      fileToFolders,
     } = input;
     const { apps, lastUsedAppId } = await this.getExternalAppsData();
     const hasPath = worktreePath || folderPath;
+    const fileToItems: MenuItemDef<TaskAction>[] =
+      fileToFolders && fileToFolders.length > 0
+        ? [
+            this.separator(),
+            {
+              type: "submenu",
+              label: "File to...",
+              items: fileToFolders.map((folder) => ({
+                label: folder.path,
+                action: {
+                  type: "file-to" as const,
+                  folderPath: folder.path,
+                },
+              })),
+            },
+          ]
+        : [];
 
     return this.showMenu<TaskAction>([
       this.item(isPinned ? "Unpin" : "Pin", { type: "pin" }),
       this.item("Rename", { type: "rename" }),
+      ...fileToItems,
       ...(worktreePath
         ? [
             this.separator(),
diff --git a/apps/code/src/renderer/api/posthogClient.ts b/apps/code/src/renderer/api/posthogClient.ts
index 1647e1e136..41c4cf9b14 100644
--- a/apps/code/src/renderer/api/posthogClient.ts
+++ b/apps/code/src/renderer/api/posthogClient.ts
@@ -134,6 +134,52 @@ export interface ExternalDataSource {
   schemas?: ExternalDataSourceSchema[] | string;
 }
 
+export interface FolderInstructionsUser {
+  id?: number;
+  uuid?: string;
+  first_name?: string;
+  last_name?: string | null;
+  email?: string;
+}
+
+export interface FolderInstructions {
+  id: string;
+  content: string;
+  version: number;
+  is_latest: boolean;
+  created_by: FolderInstructionsUser | null;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface FolderInstructionsVersion {
+  id: string;
+  version: number;
+  is_latest: boolean;
+  created_by: FolderInstructionsUser | null;
+  created_at: string;
+}
+
+interface PaginatedFolderInstructionsVersions {
+  count: number;
+  next: string | null;
+  previous: string | null;
+  results: FolderInstructionsVersion[];
+}
+
+// Thrown when PUT /instructions/ rejects a publish because the caller's
+// `base_version` is older than the current latest. Callers can re-fetch and
+// retry against the new latest.
+export class FolderInstructionsConflictError extends Error {
+  status = 409;
+  constructor(
+    message = "Folder instructions changed since you started editing",
+  ) {
+    super(message);
+    this.name = "FolderInstructionsConflictError";
+  }
+}
+
 export interface TaskArtifactUploadRequest {
   name: string;
   type: "user_attachment";
@@ -958,6 +1004,223 @@ export class PostHogAPIClient {
     return all;
   }
 
+  // The desktop file system tree lives on its own server-controlled "desktop"
+  // surface, served from a route that is not in the generated OpenAPI client,
+  // so we use the raw fetcher and follow pagination manually.
+  async getDesktopFileSystem(): Promise<Schemas.FileSystem[]> {
+    const DESKTOP_FILE_SYSTEM_MAX_PAGES = 50;
+    const teamId = await this.getTeamId();
+    const all: Schemas.FileSystem[] = [];
+    let urlPath: string = `/api/projects/${teamId}/desktop_file_system/`;
+    for (let i = 0; i < DESKTOP_FILE_SYSTEM_MAX_PAGES; i++) {
+      const url = new URL(`${this.api.baseUrl}${urlPath}`);
+      const response = await this.api.fetcher.fetch({
+        method: "get",
+        url,
+        path: urlPath,
+      });
+      if (!response.ok) {
+        throw new Error(
+          `Failed to fetch desktop file system: ${response.statusText}`,
+        );
+      }
+      const page = (await response.json()) as Schemas.PaginatedFileSystemList;
+      all.push(...page.results);
+      if (!page.next) return all;
+      const nextUrl = new URL(page.next);
+      urlPath = `${nextUrl.pathname}${nextUrl.search}`;
+    }
+    log.warn(
+      `getDesktopFileSystem hit MAX_PAGES (${DESKTOP_FILE_SYSTEM_MAX_PAGES}); returning partial results`,
+      { returned: all.length },
+    );
+    return all;
+  }
+
+  // Create a top-level channel (a folder row whose path is a single segment) on
+  // the desktop file system surface. Uses the raw fetcher for the same reason as
+  // getDesktopFileSystem: this route is not in the generated OpenAPI client.
+  async createDesktopFileSystemChannel(
+    name: string,
+  ): Promise<Schemas.FileSystem> {
+    const teamId = await this.getTeamId();
+    const urlPath = `/api/projects/${teamId}/desktop_file_system/`;
+    const url = new URL(`${this.api.baseUrl}${urlPath}`);
+    const response = await this.api.fetcher.fetch({
+      method: "post",
+      url,
+      path: urlPath,
+      overrides: {
+        body: JSON.stringify({ path: name, type: "folder", depth: 1 }),
+      },
+    });
+    if (!response.ok) {
+      throw new Error(
+        `Failed to create desktop file system channel: ${response.statusText}`,
+      );
+    }
+    return (await response.json()) as Schemas.FileSystem;
+  }
+
+  // Create a leaf file system entry (e.g. filing a task under a channel folder)
+  // on the desktop surface. `path` is slash-delimited and includes the parent
+  // folder path; `ref` links the entry back to its source domain object.
+  async createDesktopFileSystemEntry(input: {
+    path: string;
+    type: string;
+    ref?: string;
+    href?: string;
+  }): Promise<Schemas.FileSystem> {
+    const teamId = await this.getTeamId();
+    const urlPath = `/api/projects/${teamId}/desktop_file_system/`;
+    const url = new URL(`${this.api.baseUrl}${urlPath}`);
+    const depth = input.path.split("/").filter((s) => s.length > 0).length;
+    const response = await this.api.fetcher.fetch({
+      method: "post",
+      url,
+      path: urlPath,
+      overrides: {
+        body: JSON.stringify({
+          path: input.path,
+          type: input.type,
+          depth,
+          ref: input.ref,
+          href: input.href,
+        }),
+      },
+    });
+    if (!response.ok) {
+      throw new Error(
+        `Failed to create desktop file system entry: ${response.statusText}`,
+      );
+    }
+    return (await response.json()) as Schemas.FileSystem;
+  }
+
+  // Delete a desktop file system entry by id (used to remove top-level channels).
+  async deleteDesktopFileSystem(id: string): Promise<void> {
+    const teamId = await this.getTeamId();
+    const urlPath = `/api/projects/${teamId}/desktop_file_system/${encodeURIComponent(id)}/`;
+    const url = new URL(`${this.api.baseUrl}${urlPath}`);
+    const response = await this.api.fetcher.fetch({
+      method: "delete",
+      url,
+      path: urlPath,
+    });
+    if (!response.ok && response.status !== 404) {
+      throw new Error(
+        `Failed to delete desktop file system channel: ${response.statusText}`,
+      );
+    }
+  }
+
+  // Per-folder, versioned markdown instructions for a desktop folder. The
+  // endpoint is keyed on the FileSystem row id (must be `type === "folder"`).
+  // Returns the current latest version or null when none has been published.
+  async getDesktopFolderInstructions(
+    folderId: string,
+  ): Promise<FolderInstructions | null> {
+    const teamId = await this.getTeamId();
+    const urlPath = `/api/projects/${teamId}/desktop_file_system/${encodeURIComponent(folderId)}/instructions/`;
+    const url = new URL(`${this.api.baseUrl}${urlPath}`);
+    const response = await this.api.fetcher.fetch({
+      method: "get",
+      url,
+      path: urlPath,
+    });
+    if (response.status === 404) return null;
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch folder instructions: ${response.statusText}`,
+      );
+    }
+    return (await response.json()) as FolderInstructions;
+  }
+
+  // Publish a new version of the folder's instructions. Pass `base_version`
+  // (the latest version the editor was started from) for optimistic
+  // concurrency; use 0 when no instructions exist yet. A 409 turns into a
+  // typed `FolderInstructionsConflictError` so the UI can prompt to reload.
+  async putDesktopFolderInstructions(
+    folderId: string,
+    input: { content: string; base_version?: number },
+  ): Promise<FolderInstructions> {
+    const teamId = await this.getTeamId();
+    const urlPath = `/api/projects/${teamId}/desktop_file_system/${encodeURIComponent(folderId)}/instructions/`;
+    const url = new URL(`${this.api.baseUrl}${urlPath}`);
+    const response = await this.api.fetcher.fetch({
+      method: "put",
+      url,
+      path: urlPath,
+      overrides: {
+        body: JSON.stringify(input),
+      },
+    });
+    if (response.status === 409) {
+      throw new FolderInstructionsConflictError();
+    }
+    if (!response.ok) {
+      throw new Error(
+        `Failed to publish folder instructions: ${response.statusText}`,
+      );
+    }
+    return (await response.json()) as FolderInstructions;
+  }
+
+  // Soft-delete all versions of this folder's instructions. The folder row
+  // itself is not affected.
+  async deleteDesktopFolderInstructions(folderId: string): Promise<void> {
+    const teamId = await this.getTeamId();
+    const urlPath = `/api/projects/${teamId}/desktop_file_system/${encodeURIComponent(folderId)}/instructions/`;
+    const url = new URL(`${this.api.baseUrl}${urlPath}`);
+    const response = await this.api.fetcher.fetch({
+      method: "delete",
+      url,
+      path: urlPath,
+    });
+    if (!response.ok && response.status !== 404) {
+      throw new Error(
+        `Failed to delete folder instructions: ${response.statusText}`,
+      );
+    }
+  }
+
+  // List version metadata (no content) newest-first. Single page is enough for
+  // the typical UI; we cap follow-up pages to avoid runaway pagination on
+  // pathological histories.
+  async listDesktopFolderInstructionVersions(
+    folderId: string,
+  ): Promise<FolderInstructionsVersion[]> {
+    const VERSIONS_MAX_PAGES = 20;
+    const teamId = await this.getTeamId();
+    const all: FolderInstructionsVersion[] = [];
+    let urlPath = `/api/projects/${teamId}/desktop_file_system/${encodeURIComponent(folderId)}/instructions/versions/`;
+    for (let i = 0; i < VERSIONS_MAX_PAGES; i++) {
+      const url = new URL(`${this.api.baseUrl}${urlPath}`);
+      const response = await this.api.fetcher.fetch({
+        method: "get",
+        url,
+        path: urlPath,
+      });
+      if (!response.ok) {
+        throw new Error(
+          `Failed to fetch folder instruction versions: ${response.statusText}`,
+        );
+      }
+      const page =
+        (await response.json()) as PaginatedFolderInstructionsVersions;
+      all.push(...page.results);
+      if (!page.next) return all;
+      const nextUrl = new URL(page.next);
+      urlPath = `${nextUrl.pathname}${nextUrl.search}`;
+    }
+    log.warn(
+      `listDesktopFolderInstructionVersions hit MAX_PAGES (${VERSIONS_MAX_PAGES}); returning partial results`,
+      { folderId, returned: all.length },
+    );
+    return all;
+  }
+
   async getTask(taskId: string) {
     const teamId = await this.getTeamId();
     const data = await this.api.get(`/api/projects/{project_id}/tasks/{id}/`, {
diff --git a/apps/code/src/renderer/features/folder-context/components/FolderContextView.tsx b/apps/code/src/renderer/features/folder-context/components/FolderContextView.tsx
new file mode 100644
index 0000000000..dbe1f5b499
--- /dev/null
+++ b/apps/code/src/renderer/features/folder-context/components/FolderContextView.tsx
@@ -0,0 +1,349 @@
+import { MarkdownRenderer } from "@features/editor/components/MarkdownRenderer";
+import {
+  useFolderInstructions,
+  useFolderInstructionsMutations,
+  useFolderInstructionsVersions,
+} from "@features/folder-context/hooks/useFolderInstructions";
+import { useDesktopFileSystem } from "@features/sidebar/hooks/useDesktopFileSystem";
+import { useSetHeaderContent } from "@hooks/useSetHeaderContent";
+import { FileText, Hash } from "@phosphor-icons/react";
+import {
+  Box,
+  Button,
+  Callout,
+  Flex,
+  ScrollArea,
+  SegmentedControl,
+  Select,
+  Spinner,
+  Text,
+  TextArea,
+} from "@radix-ui/themes";
+import { FolderInstructionsConflictError } from "@renderer/api/posthogClient";
+import { useEffect, useMemo, useState } from "react";
+
+type Mode = "rendered" | "edit";
+
+// Initial markdown shown when a folder has no instructions yet — gives both
+// humans and agents a structural starting point instead of a blank screen.
+const EMPTY_TEMPLATE = "# Folder context\n\nDescribe what lives here.\n";
+
+interface FolderContextViewProps {
+  folderId: string;
+}
+
+export function FolderContextView({ folderId }: FolderContextViewProps) {
+  // Resolve the folder display name from the cached desktop file system list,
+  // so we don't make a second network call just for the header label.
+  const { data: items = [] } = useDesktopFileSystem();
+  const folder = useMemo(
+    () => items.find((item) => item.id === folderId) ?? null,
+    [items, folderId],
+  );
+
+  const {
+    data: latest,
+    isLoading: isLoadingLatest,
+    isFetching: isFetchingLatest,
+    error: latestError,
+  } = useFolderInstructions(folderId);
+
+  const { data: versions = [], isLoading: isLoadingVersions } =
+    useFolderInstructionsVersions(folderId);
+
+  const { publish, isPublishing, publishError } =
+    useFolderInstructionsMutations(folderId);
+
+  const [mode, setMode] = useState<Mode>("rendered");
+  const [draft, setDraft] = useState("");
+  const [hasDraft, setHasDraft] = useState(false);
+
+  // Seed the editor draft from the latest content the first time we land on
+  // edit mode (or whenever latest changes while we're not actively editing).
+  // We don't blow away an in-flight edit just because the cache refetched.
+  useEffect(() => {
+    if (hasDraft) return;
+    setDraft(latest?.content ?? "");
+  }, [latest?.content, hasDraft]);
+
+  const headerContent = useMemo(
+    () => (
+      <Flex align="center" gap="2" className="w-full min-w-0">
+        <Hash size={12} className="shrink-0 text-gray-10" />
+        <Text
+          className="truncate whitespace-nowrap font-medium text-[13px]"
+          title={folder?.path ?? "Folder"}
+        >
+          {folder?.path ?? "Folder"}
+        </Text>
+        <Text className="shrink-0 text-[13px] text-gray-9">/</Text>
+        <FileText size={12} className="shrink-0 text-gray-10" />
+        <Text className="shrink-0 whitespace-nowrap text-[13px] text-gray-11">
+          CONTEXT.md
+        </Text>
+      </Flex>
+    ),
+    [folder?.path],
+  );
+  useSetHeaderContent(headerContent);
+
+  const onSave = async () => {
+    try {
+      await publish({
+        content: draft,
+        // base_version=0 signals "no prior version" to the optimistic
+        // concurrency check; otherwise we send the version we started from.
+        baseVersion: latest?.version ?? 0,
+      });
+      setHasDraft(false);
+      setMode("rendered");
+    } catch {
+      // Errors surface through `publishError` below; nothing to do here.
+    }
+  };
+
+  const isConflict = publishError instanceof FolderInstructionsConflictError;
+
+  // Allow inspecting an older version read-only. When `null`, we're showing
+  // either the latest (rendered/edit) or the empty state.
+  const [selectedVersionId, setSelectedVersionId] = useState<string | null>(
+    null,
+  );
+
+  // Picking a past version forces rendered mode and shows that version's
+  // metadata; we don't currently fetch the historical content body, so the
+  // viewer falls back to "Open latest in editor" when there is no body.
+  // (Backend exposes content only via the `latest` endpoint today.)
+  const selectedVersion = useMemo(() => {
+    if (!selectedVersionId) return null;
+    return versions.find((v) => v.id === selectedVersionId) ?? null;
+  }, [selectedVersionId, versions]);
+
+  if (isLoadingLatest) {
+    return (
+      <Flex align="center" justify="center" className="h-full">
+        <Spinner size="2" />
+      </Flex>
+    );
+  }
+
+  if (latestError) {
+    return (
+      <Flex direction="column" gap="3" p="4">
+        <Callout.Root color="red" size="1">
+          <Callout.Text>
+            Failed to load folder instructions: {latestError.message}
+          </Callout.Text>
+        </Callout.Root>
+      </Flex>
+    );
+  }
+
+  // Treat `null` (404: never published), `undefined` (query disabled), AND a
+  // row with whitespace-only content as "no instructions" so we render the
+  // empty state — otherwise MarkdownRenderer paints an invisible empty block
+  // and the page looks blank.
+  const renderedContent = latest?.content ?? "";
+  const hasInstructions = renderedContent.trim().length > 0;
+
+  return (
+    <Flex direction="column" height="100%" className="overflow-hidden">
+      <Flex
+        align="center"
+        justify="between"
+        gap="3"
+        px="4"
+        py="2"
+        className="shrink-0 border-b border-b-(--gray-5)"
+      >
+        <Flex align="center" gap="3">
+          <SegmentedControl.Root
+            value={mode}
+            onValueChange={(value) => setMode(value as Mode)}
+            size="1"
+          >
+            <SegmentedControl.Item value="rendered">
+              Rendered
+            </SegmentedControl.Item>
+            <SegmentedControl.Item value="edit">Edit</SegmentedControl.Item>
+          </SegmentedControl.Root>
+
+          {/* Background-refetch indicator: the initial load uses the full-screen
+              spinner below; this only fires on revalidations (every mount, plus
+              after publish/delete invalidations) so the user knows the view is
+              live and not just stale cache. */}
+          {isFetchingLatest && !isLoadingLatest ? (
+            <Flex align="center" gap="1">
+              <Spinner size="1" />
+              <Text className="text-[12px] text-gray-10">Refreshing…</Text>
+            </Flex>
+          ) : null}
+
+          {versions.length > 0 ? (
+            <Select.Root
+              size="1"
+              value={selectedVersionId ?? "latest"}
+              onValueChange={(value) => {
+                if (value === "latest") {
+                  setSelectedVersionId(null);
+                } else {
+                  setSelectedVersionId(value);
+                  setMode("rendered");
+                }
+              }}
+              disabled={isLoadingVersions}
+            >
+              <Select.Trigger />
+              <Select.Content>
+                <Select.Item value="latest">
+                  Latest (v{latest?.version ?? "—"})
+                </Select.Item>
+                {versions
+                  .filter((v) => !v.is_latest)
+                  .map((v) => (
+                    <Select.Item key={v.id} value={v.id}>
+                      v{v.version} · {formatTimestamp(v.created_at)}
+                    </Select.Item>
+                  ))}
+              </Select.Content>
+            </Select.Root>
+          ) : null}
+        </Flex>
+
+        {mode === "edit" ? (
+          <Flex align="center" gap="2">
+            {hasDraft ? (
+              <Button
+                size="1"
+                variant="soft"
+                color="gray"
+                onClick={() => {
+                  setDraft(latest?.content ?? "");
+                  setHasDraft(false);
+                }}
+                disabled={isPublishing}
+              >
+                Discard
+              </Button>
+            ) : null}
+            <Button
+              size="1"
+              variant="solid"
+              onClick={onSave}
+              disabled={isPublishing || (!hasDraft && hasInstructions)}
+            >
+              {isPublishing ? <Spinner size="1" /> : null}
+              Save new version
+            </Button>
+          </Flex>
+        ) : null}
+      </Flex>
+
+      {publishError ? (
+        <Box px="4" pt="3">
+          <Callout.Root color={isConflict ? "amber" : "red"} size="1">
+            <Callout.Text>
+              {isConflict
+                ? "Someone else saved a newer version. Reload to merge your changes."
+                : `Save failed: ${publishError.message}`}
+            </Callout.Text>
+          </Callout.Root>
+        </Box>
+      ) : null}
+
+      <ScrollArea
+        type="auto"
+        scrollbars="vertical"
+        className="scroll-area-constrain-width min-h-0 flex-1"
+      >
+        <Box p="4">
+          {selectedVersion ? (
+            <Callout.Root color="gray" size="1">
+              <Callout.Text>
+                Viewing v{selectedVersion.version} metadata. Past content is not
+                fetched today — switch to "Latest" to read or edit current
+                content.
+              </Callout.Text>
+            </Callout.Root>
+          ) : mode === "rendered" ? (
+            hasInstructions ? (
+              <Box className="text-[13px]">
+                <MarkdownRenderer content={renderedContent} />
+              </Box>
+            ) : (
+              <EmptyState
+                folderName={folder?.path ?? "this folder"}
+                onCreate={() => {
+                  setDraft(EMPTY_TEMPLATE);
+                  setHasDraft(true);
+                  setMode("edit");
+                }}
+              />
+            )
+          ) : (
+            <TextArea
+              value={draft}
+              onChange={(e) => {
+                setDraft(e.target.value);
+                setHasDraft(true);
+              }}
+              size="2"
+              rows={24}
+              placeholder={
+                "# Folder context\n\nWrite markdown describing this folder…"
+              }
+              className="font-[var(--code-font-family)]"
+            />
+          )}
+        </Box>
+      </ScrollArea>
+    </Flex>
+  );
+}
+
+function EmptyState({
+  folderName,
+  onCreate,
+}: {
+  folderName: string;
+  onCreate: () => void;
+}) {
+  return (
+    <Flex
+      direction="column"
+      align="center"
+      gap="4"
+      className="mx-auto max-w-[440px] py-16 text-center"
+    >
+      <Box className="rounded-lg border border-gray-6 border-dashed p-4">
+        <FileText size={28} className="text-gray-8" />
+      </Box>
+      <Flex direction="column" gap="2" align="center">
+        <Text className="font-medium text-[14px] text-gray-12">
+          No CONTEXT.md yet
+        </Text>
+        <Text className="text-[13px] text-gray-10 leading-relaxed">
+          CONTEXT.md tells agents the specific details they need to know when
+          working in <strong>{folderName}</strong> — conventions, gotchas, key
+          files, and anything else that isn't obvious from the code.
+        </Text>
+      </Flex>
+      <Button size="2" variant="solid" onClick={onCreate}>
+        Create CONTEXT.md
+      </Button>
+    </Flex>
+  );
+}
+
+// `created_at` is an ISO timestamp; we render it as a short local string for
+// the version dropdown. Falls back to the raw string if Date parsing fails.
+function formatTimestamp(iso: string): string {
+  const d = new Date(iso);
+  if (Number.isNaN(d.getTime())) return iso;
+  return d.toLocaleString(undefined, {
+    month: "short",
+    day: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+  });
+}
diff --git a/apps/code/src/renderer/features/folder-context/hooks/useFolderInstructions.ts b/apps/code/src/renderer/features/folder-context/hooks/useFolderInstructions.ts
new file mode 100644
index 0000000000..11b7d86b96
--- /dev/null
+++ b/apps/code/src/renderer/features/folder-context/hooks/useFolderInstructions.ts
@@ -0,0 +1,120 @@
+import { useOptionalAuthenticatedClient } from "@features/auth/hooks/authClient";
+import { useAuthenticatedQuery } from "@hooks/useAuthenticatedQuery";
+import type {
+  FolderInstructions,
+  FolderInstructionsVersion,
+} from "@renderer/api/posthogClient";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { useCallback } from "react";
+
+const FOLDER_INSTRUCTIONS_QUERY_KEY = (folderId: string) =>
+  ["folder-instructions", folderId] as const;
+
+const FOLDER_INSTRUCTIONS_VERSIONS_QUERY_KEY = (folderId: string) =>
+  ["folder-instructions", folderId, "versions"] as const;
+
+// Latest published version, or `null` when none exists yet. The latest
+// content is what the editor opens with; the editor never edits an old
+// version in-place, it republishes from current latest.
+export function useFolderInstructions(
+  folderId: string | null,
+  options?: { enabled?: boolean },
+) {
+  return useAuthenticatedQuery<FolderInstructions | null>(
+    folderId
+      ? FOLDER_INSTRUCTIONS_QUERY_KEY(folderId)
+      : (["folder-instructions", "none"] as const),
+    async (client) => {
+      if (!folderId) return null;
+      return client.getDesktopFolderInstructions(folderId);
+    },
+    {
+      enabled: Boolean(folderId) && (options?.enabled ?? true),
+      // Always refetch on mount so opening CONTEXT.md after another user (or
+      // an agent) edited it from elsewhere shows the current content, not the
+      // last-cached body.
+      staleTime: 0,
+      refetchOnMount: "always",
+    },
+  );
+}
+
+// Newest-first list of version metadata (no content) — used by the version
+// dropdown. The list refetches after every publish/delete via the same key
+// invalidation in the mutations hook below.
+export function useFolderInstructionsVersions(
+  folderId: string | null,
+  options?: { enabled?: boolean },
+) {
+  return useAuthenticatedQuery<FolderInstructionsVersion[]>(
+    folderId
+      ? FOLDER_INSTRUCTIONS_VERSIONS_QUERY_KEY(folderId)
+      : (["folder-instructions", "none", "versions"] as const),
+    async (client) => {
+      if (!folderId) return [];
+      return client.listDesktopFolderInstructionVersions(folderId);
+    },
+    {
+      enabled: Boolean(folderId) && (options?.enabled ?? true),
+    },
+  );
+}
+
+// publish + delete mutations. Both invalidate the latest + versions queries
+// so the editor and history dropdown refresh immediately. The publish
+// mutation surfaces `FolderInstructionsConflictError` from the client
+// unchanged so the UI can show a "reload" prompt.
+export function useFolderInstructionsMutations(folderId: string | null) {
+  const client = useOptionalAuthenticatedClient();
+  const queryClient = useQueryClient();
+
+  const invalidate = useCallback(() => {
+    if (!folderId) return;
+    void queryClient.invalidateQueries({
+      queryKey: FOLDER_INSTRUCTIONS_QUERY_KEY(folderId),
+    });
+    void queryClient.invalidateQueries({
+      queryKey: FOLDER_INSTRUCTIONS_VERSIONS_QUERY_KEY(folderId),
+    });
+  }, [folderId, queryClient]);
+
+  const publishMutation = useMutation({
+    mutationFn: async (input: { content: string; baseVersion: number }) => {
+      if (!client) throw new Error("Not authenticated");
+      if (!folderId) throw new Error("No folder id");
+      return client.putDesktopFolderInstructions(folderId, {
+        content: input.content,
+        base_version: input.baseVersion,
+      });
+    },
+    onSuccess: invalidate,
+  });
+
+  const deleteMutation = useMutation({
+    mutationFn: async () => {
+      if (!client) throw new Error("Not authenticated");
+      if (!folderId) throw new Error("No folder id");
+      return client.deleteDesktopFolderInstructions(folderId);
+    },
+    onSuccess: invalidate,
+  });
+
+  const publish = useCallback(
+    (input: { content: string; baseVersion: number }) =>
+      publishMutation.mutateAsync(input),
+    [publishMutation],
+  );
+
+  const remove = useCallback(
+    () => deleteMutation.mutateAsync(),
+    [deleteMutation],
+  );
+
+  return {
+    publish,
+    remove,
+    isPublishing: publishMutation.isPending,
+    isDeleting: deleteMutation.isPending,
+    publishError: publishMutation.error,
+  };
+}
diff --git a/apps/code/src/renderer/features/sidebar/components/ChannelsHeader.tsx b/apps/code/src/renderer/features/sidebar/components/ChannelsHeader.tsx
new file mode 100644
index 0000000000..869e94d2c0
--- /dev/null
+++ b/apps/code/src/renderer/features/sidebar/components/ChannelsHeader.tsx
@@ -0,0 +1,31 @@
+import { Plus } from "@phosphor-icons/react";
+import { Flex, IconButton, Text } from "@radix-ui/themes";
+import { useState } from "react";
+import { CreateChannelModal } from "./CreateChannelModal";
+
+// Header above the channel tree with an "add channel" affordance that opens a
+// Slack-style create-channel modal.
+export function ChannelsHeader() {
+  const [isModalOpen, setIsModalOpen] = useState(false);
+
+  return (
+    <Flex direction="column" className="px-2 pb-1">
+      <Flex align="center" justify="between" className="h-[22px]">
+        <Text className="font-medium text-[11px] text-gray-10 uppercase tracking-wide">
+          Channels
+        </Text>
+        <IconButton
+          type="button"
+          variant="ghost"
+          color="gray"
+          size="1"
+          aria-label="Create channel"
+          onClick={() => setIsModalOpen(true)}
+        >
+          <Plus size={12} />
+        </IconButton>
+      </Flex>
+      <CreateChannelModal open={isModalOpen} onOpenChange={setIsModalOpen} />
+    </Flex>
+  );
+}
diff --git a/apps/code/src/renderer/features/sidebar/components/CreateChannelModal.tsx b/apps/code/src/renderer/features/sidebar/components/CreateChannelModal.tsx
new file mode 100644
index 0000000000..8d4a8d4716
--- /dev/null
+++ b/apps/code/src/renderer/features/sidebar/components/CreateChannelModal.tsx
@@ -0,0 +1,118 @@
+import { Button } from "@components/ui/Button";
+import { Hash, X } from "@phosphor-icons/react";
+import { Dialog, Flex, IconButton, Text, TextField } from "@radix-ui/themes";
+import { useEffect, useState } from "react";
+import { useDesktopFileSystemMutations } from "../hooks/useDesktopFileSystem";
+
+// Matches Slack's "Create a channel" naming constraint.
+const MAX_CHANNEL_NAME_LENGTH = 80;
+
+interface CreateChannelModalProps {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+}
+
+export function CreateChannelModal({
+  open,
+  onOpenChange,
+}: CreateChannelModalProps) {
+  const { createChannel, isCreating } = useDesktopFileSystemMutations();
+  const [name, setName] = useState("");
+
+  // Reset the field each time the modal opens so a previous draft never lingers.
+  useEffect(() => {
+    if (open) setName("");
+  }, [open]);
+
+  const trimmed = name.trim();
+  const remaining = MAX_CHANNEL_NAME_LENGTH - name.length;
+
+  const submit = async () => {
+    if (!trimmed) return;
+    try {
+      await createChannel(trimmed);
+      onOpenChange(false);
+    } catch {
+      // Keep the modal open so the user can retry; the mutation surfaces the error.
+    }
+  };
+
+  return (
+    <Dialog.Root
+      open={open}
+      onOpenChange={(next) => {
+        if (!isCreating) onOpenChange(next);
+      }}
+    >
+      <Dialog.Content maxWidth="560px">
+        <Flex align="start" justify="between" gap="3">
+          <Dialog.Title>
+            <Text className="font-bold text-lg">Create a channel</Text>
+          </Dialog.Title>
+          <Dialog.Close>
+            <IconButton
+              variant="ghost"
+              color="gray"
+              size="2"
+              aria-label="Close"
+              disabled={isCreating}
+            >
+              <X size={18} />
+            </IconButton>
+          </Dialog.Close>
+        </Flex>
+
+        <Flex direction="column" gap="2" mt="4">
+          <Text
+            as="label"
+            htmlFor="channel-name"
+            className="font-medium text-sm"
+          >
+            Name
+          </Text>
+          <TextField.Root
+            id="channel-name"
+            autoFocus
+            size="3"
+            value={name}
+            placeholder="e.g. plan-budget"
+            maxLength={MAX_CHANNEL_NAME_LENGTH}
+            disabled={isCreating}
+            onChange={(e) => setName(e.target.value)}
+            onKeyDown={(e) => {
+              if (e.key === "Enter") {
+                e.preventDefault();
+                void submit();
+              }
+            }}
+          >
+            <TextField.Slot>
+              <Hash size={16} className="text-gray-10" />
+            </TextField.Slot>
+            <TextField.Slot side="right">
+              <Text className="text-gray-9 text-sm tabular-nums">
+                {remaining}
+              </Text>
+            </TextField.Slot>
+          </TextField.Root>
+          <Text className="text-gray-10 text-sm">
+            Channels are where conversations happen around a topic. Use a name
+            that is easy to find and understand.
+          </Text>
+        </Flex>
+
+        <Flex gap="3" mt="5" justify="end">
+          <Button
+            variant="solid"
+            disabled={!trimmed || isCreating}
+            disabledReason={!trimmed ? "enter a channel name" : null}
+            loading={isCreating}
+            onClick={submit}
+          >
+            Create
+          </Button>
+        </Flex>
+      </Dialog.Content>
+    </Dialog.Root>
+  );
+}
diff --git a/apps/code/src/renderer/features/sidebar/components/FileSystemTreeView.tsx b/apps/code/src/renderer/features/sidebar/components/FileSystemTreeView.tsx
new file mode 100644
index 0000000000..549c71598a
--- /dev/null
+++ b/apps/code/src/renderer/features/sidebar/components/FileSystemTreeView.tsx
@@ -0,0 +1,188 @@
+import { Code, FileText, Hash } from "@phosphor-icons/react";
+import { AlertDialog, Button, Flex, Spinner, Text } from "@radix-ui/themes";
+import {
+  navigateToFolderContext,
+  navigateToTaskDetail,
+} from "@renderer/navigationBridge";
+import { useState } from "react";
+import { useDesktopFileSystemMutations } from "../hooks/useDesktopFileSystem";
+import { useSidebarStore } from "../stores/sidebarStore";
+import type { FileSystemTreeNode } from "../utils/fileSystemTree";
+import { SidebarItem } from "./SidebarItem";
+import { SidebarSection } from "./SidebarSection";
+
+const CONTEXT_LEAF_LABEL = "CONTEXT.md";
+
+// Persisted collapse state is shared with the task view's repo groups; namespace
+// file system keys so the two never collide.
+const collapseKey = (path: string) => `fs:${path}`;
+
+// Cap the visual indent so deeply nested paths don't push labels off-screen,
+// while keeping the true depth available for keys.
+const MAX_VISUAL_DEPTH = 6;
+
+interface FileSystemTreeNodeRowProps {
+  node: FileSystemTreeNode;
+  depth: number;
+  collapsedSections: Set<string>;
+  toggleSection: (id: string) => void;
+  onDeleteChannel: (node: FileSystemTreeNode) => void;
+}
+
+function FileSystemTreeNodeRow({
+  node,
+  depth,
+  collapsedSections,
+  toggleSection,
+  onDeleteChannel,
+}: FileSystemTreeNodeRowProps) {
+  const visualDepth = Math.min(depth, MAX_VISUAL_DEPTH);
+
+  if (!node.isFolder) {
+    // Task leaves (filed via the task context menu) carry `ref = taskId`;
+    // clicking navigates to the task detail in the main pane.
+    const isTask = node.item?.type === "task";
+    const taskRef = isTask && node.item?.ref ? node.item.ref : null;
+    return (
+      <SidebarItem
+        depth={Math.min(visualDepth + 1, MAX_VISUAL_DEPTH)}
+        label={node.name}
+        icon={isTask ? <Code size={14} className="text-gray-10" /> : undefined}
+        onClick={taskRef ? () => navigateToTaskDetail(taskRef) : undefined}
+      />
+    );
+  }
+
+  const key = collapseKey(node.path);
+  const isExpanded = !collapsedSections.has(key);
+  // Only real top-level channel rows are deletable: depth 0 with a backing cloud
+  // row (derived intermediate folders have no item/id and can't be removed).
+  const isDeletableChannel = depth === 0 && Boolean(node.item?.id);
+  // CONTEXT.md hangs off any folder that has a real FileSystem row id; derived
+  // intermediate folders (no `item`) have no id to attach instructions to.
+  const folderId = node.item?.id ?? null;
+  const showContextLeaf = folderId !== null;
+
+  return (
+    <SidebarSection
+      id={key}
+      label={node.name}
+      icon={<Hash size={14} className="text-gray-10" />}
+      depth={visualDepth}
+      isExpanded={isExpanded}
+      onToggle={() => toggleSection(key)}
+      addSpacingBefore={false}
+      tooltipContent={node.path}
+      onDelete={isDeletableChannel ? () => onDeleteChannel(node) : undefined}
+      deleteTooltip="Delete channel"
+    >
+      {showContextLeaf && folderId ? (
+        // Child rows recurse through FileSystemTreeNodeRow with depth+1, and
+        // the leaf branch adds another +1 — so sibling leaves end up at
+        // visualDepth+2. CONTEXT.md is rendered directly here without that
+        // recursion, so we mirror the same offset to keep it aligned.
+        <SidebarItem
+          depth={Math.min(visualDepth + 2, MAX_VISUAL_DEPTH)}
+          label={CONTEXT_LEAF_LABEL}
+          icon={<FileText size={14} className="text-gray-10" />}
+          onClick={() => navigateToFolderContext(folderId)}
+        />
+      ) : null}
+      {node.children.map((child) => (
+        <FileSystemTreeNodeRow
+          key={child.id}
+          node={child}
+          depth={depth + 1}
+          collapsedSections={collapsedSections}
+          toggleSection={toggleSection}
+          onDeleteChannel={onDeleteChannel}
+        />
+      ))}
+    </SidebarSection>
+  );
+}
+
+export function FileSystemTreeView({ nodes }: { nodes: FileSystemTreeNode[] }) {
+  const collapsedSections = useSidebarStore((state) => state.collapsedSections);
+  const toggleSection = useSidebarStore((state) => state.toggleSection);
+  const { deleteChannel, isDeleting } = useDesktopFileSystemMutations();
+  const [pendingDelete, setPendingDelete] = useState<FileSystemTreeNode | null>(
+    null,
+  );
+
+  const confirmDelete = async () => {
+    const id = pendingDelete?.item?.id;
+    if (!id) return;
+    try {
+      await deleteChannel(id);
+    } finally {
+      setPendingDelete(null);
+    }
+  };
+
+  if (nodes.length === 0) {
+    return (
+      <Flex direction="column" align="center" className="px-4 pt-6 pb-4">
+        <Text className="text-[13px] text-gray-10">No channels yet</Text>
+      </Flex>
+    );
+  }
+
+  return (
+    <>
+      <Flex direction="column">
+        {nodes.map((node) => (
+          <FileSystemTreeNodeRow
+            key={node.id}
+            node={node}
+            depth={0}
+            collapsedSections={collapsedSections}
+            toggleSection={toggleSection}
+            onDeleteChannel={setPendingDelete}
+          />
+        ))}
+      </Flex>
+
+      <AlertDialog.Root
+        open={pendingDelete !== null}
+        onOpenChange={(open) => {
+          if (!open && !isDeleting) setPendingDelete(null);
+        }}
+      >
+        <AlertDialog.Content maxWidth="420px" size="1">
+          <AlertDialog.Title className="text-sm">
+            Delete channel "{pendingDelete?.name}"?
+          </AlertDialog.Title>
+          <AlertDialog.Description>
+            <Text color="gray" className="text-[13px]">
+              This removes the channel for everyone in your project. This can't
+              be undone here.
+            </Text>
+          </AlertDialog.Description>
+          <Flex justify="end" gap="3" mt="3">
+            <AlertDialog.Cancel>
+              <Button
+                variant="soft"
+                color="gray"
+                size="1"
+                disabled={isDeleting}
+              >
+                Cancel
+              </Button>
+            </AlertDialog.Cancel>
+            <Button
+              variant="solid"
+              color="red"
+              size="1"
+              disabled={isDeleting}
+              onClick={confirmDelete}
+            >
+              {isDeleting ? <Spinner size="1" /> : null}
+              Delete
+            </Button>
+          </Flex>
+        </AlertDialog.Content>
+      </AlertDialog.Root>
+    </>
+  );
+}
diff --git a/apps/code/src/renderer/features/sidebar/components/SidebarMenu.tsx b/apps/code/src/renderer/features/sidebar/components/SidebarMenu.tsx
index 9107784ee6..82e3ffc1e3 100644
--- a/apps/code/src/renderer/features/sidebar/components/SidebarMenu.tsx
+++ b/apps/code/src/renderer/features/sidebar/components/SidebarMenu.tsx
@@ -13,6 +13,7 @@ import {
 import { useRenameTask, useTasks } from "@features/tasks/hooks/useTasks";
 import { useWorkspaces } from "@features/workspace/hooks/useWorkspace";
 import { useAppView } from "@hooks/useAppView";
+import { useFeatureFlag } from "@hooks/useFeatureFlag";
 import { openTask, openTaskInput } from "@hooks/useOpenTask";
 import { useTaskContextMenu } from "@hooks/useTaskContextMenu";
 import { Separator } from "@posthog/quill";
@@ -25,6 +26,7 @@ import {
   navigateToTaskDetail,
 } from "@renderer/navigationBridge";
 import { trpcClient } from "@renderer/trpc/client";
+import { FILE_SYSTEM_SIDEBAR_FLAG } from "@shared/constants";
 import type { Task } from "@shared/types";
 import { useCommandMenuStore } from "@stores/commandMenuStore";
 import { useRendererWindowFocusStore } from "@stores/rendererWindowFocusStore";
@@ -32,17 +34,25 @@ import { useQueryClient } from "@tanstack/react-query";
 import { logger } from "@utils/logger";
 import { toast } from "@utils/toast";
 import { memo, useCallback, useEffect, useMemo, useRef } from "react";
+import {
+  useDesktopFileSystem,
+  useDesktopFileSystemMutations,
+} from "../hooks/useDesktopFileSystem";
 import { usePinnedTasks } from "../hooks/usePinnedTasks";
 import { useSidebarData } from "../hooks/useSidebarData";
 import { useTaskViewed } from "../hooks/useTaskViewed";
 import { useSidebarStore } from "../stores/sidebarStore";
 import { useTaskSelectionStore } from "../stores/taskSelectionStore";
+import { buildFileSystemTree } from "../utils/fileSystemTree";
+import { ChannelsHeader } from "./ChannelsHeader";
+import { FileSystemTreeView } from "./FileSystemTreeView";
 import { CommandCenterItem } from "./items/CommandCenterItem";
 import { InboxItem, NewTaskItem } from "./items/HomeItem";
 import { McpServersItem } from "./items/McpServersItem";
 import { SearchItem } from "./items/SearchItem";
 import { SkillsItem } from "./items/SkillsItem";
 import { SidebarItem } from "./SidebarItem";
+import { SidebarPanelToggle } from "./SidebarPanelToggle";
 import { TaskListView } from "./TaskListView";
 import { TasksHeader } from "./TasksHeader";
 
@@ -69,6 +79,30 @@ function SidebarMenuComponent() {
   const sidebarData = useSidebarData({
     activeView: view,
   });
+
+  const fsSidebarEnabled =
+    useFeatureFlag(FILE_SYSTEM_SIDEBAR_FLAG) || import.meta.env.DEV;
+  const activePanel = useSidebarStore((s) => s.activePanel);
+  const setActivePanel = useSidebarStore((s) => s.setActivePanel);
+  // The file-system tree is only ever shown behind the flag; without it we
+  // always fall back to the task list regardless of the persisted panel.
+  const showFiles = fsSidebarEnabled && activePanel === "files";
+  // Keep the file-system list loaded whenever the feature is available, not
+  // only when its panel is active, so the task right-click "File to..." submenu
+  // has the channel list ready immediately.
+  const { data: fsItems = [], isLoading: fsLoading } = useDesktopFileSystem({
+    enabled: fsSidebarEnabled,
+  });
+  const fsTree = useMemo(() => buildFileSystemTree(fsItems), [fsItems]);
+  const { fileEntry } = useDesktopFileSystemMutations();
+  const fileToFolders = useMemo(
+    () =>
+      fsItems
+        .filter((item) => item.type === "folder")
+        .map((item) => ({ id: item.id, path: item.path }))
+        .sort((a, b) => a.path.localeCompare(b.path)),
+    [fsItems],
+  );
   const inboxPollingActive = useRendererWindowFocusStore((s) => s.focused);
   const { data: inboxProbe } = useInboxReports(
     { status: INBOX_PIPELINE_STATUS_FILTER },
@@ -285,6 +319,7 @@ function SidebarMenuComponent() {
         isSuspended: taskData?.isSuspended,
         isInCommandCenter,
         hasEmptyCommandCenterCell,
+        fileToFolders: fsSidebarEnabled ? fileToFolders : undefined,
         onTogglePin: () => togglePin(taskId),
         onArchivePrior: handleArchivePrior,
         onAddToCommandCenter: () => {
@@ -297,6 +332,19 @@ function SidebarMenuComponent() {
             toast.info("Command center is full");
           }
         },
+        onFileTo: async (channelPath) => {
+          try {
+            await fileEntry({
+              path: `${channelPath}/${task.title}`,
+              type: "task",
+              ref: task.id,
+            });
+            toast.success(`Filed to ${channelPath}`);
+          } catch (error) {
+            log.error("Failed to file task", error);
+            toast.error("Failed to file task");
+          }
+        },
       });
     }
   };
@@ -417,11 +465,31 @@ function SidebarMenuComponent() {
 
       <Separator className="mx-2 my-2 shrink-0" />
 
-      <TasksHeader />
+      {fsSidebarEnabled && (
+        <Box px="2">
+          <SidebarPanelToggle
+            activePanel={activePanel}
+            onChange={setActivePanel}
+          />
+        </Box>
+      )}
+
+      {showFiles ? <ChannelsHeader /> : <TasksHeader />}
 
       <div className="min-h-0 flex-1 overflow-y-auto overflow-x-hidden">
         <Flex direction="column" className="gap-px px-2 pb-2">
-          {sidebarData.isLoading ? (
+          {showFiles ? (
+            fsLoading ? (
+              <SidebarItem
+                depth={0}
+                icon={<DotsCircleSpinner size={12} className="text-gray-10" />}
+                label="Loading..."
+                disabled
+              />
+            ) : (
+              <FileSystemTreeView nodes={fsTree} />
+            )
+          ) : sidebarData.isLoading ? (
             <SidebarItem
               depth={0}
               icon={<DotsCircleSpinner size={12} className="text-gray-10" />}
diff --git a/apps/code/src/renderer/features/sidebar/components/SidebarPanelToggle.tsx b/apps/code/src/renderer/features/sidebar/components/SidebarPanelToggle.tsx
new file mode 100644
index 0000000000..e95b8dbedd
--- /dev/null
+++ b/apps/code/src/renderer/features/sidebar/components/SidebarPanelToggle.tsx
@@ -0,0 +1,51 @@
+import { Hash, ListChecks } from "@phosphor-icons/react";
+import { Button, cn } from "@posthog/quill";
+import { Flex } from "@radix-ui/themes";
+
+type SidebarPanel = "tasks" | "files";
+
+// The "files" value is persisted as activePanel in the sidebar store; keep it as
+// "files" so existing persisted state isn't orphaned. Only the visible label is
+// "Channels".
+const PANELS: { value: SidebarPanel; label: string; icon: React.ReactNode }[] =
+  [
+    { value: "files", label: "Channels", icon: <Hash size={14} /> },
+    { value: "tasks", label: "Tasks", icon: <ListChecks size={14} /> },
+  ];
+
+interface SidebarPanelToggleProps {
+  activePanel: SidebarPanel;
+  onChange: (panel: SidebarPanel) => void;
+}
+
+// Segmented control letting the user switch between the file-system tree and
+// their task list when the file-system sidebar flag is on.
+export function SidebarPanelToggle({
+  activePanel,
+  onChange,
+}: SidebarPanelToggleProps) {
+  return (
+    <Flex gap="1" className="mb-2 rounded-md bg-gray-2 p-[2px]">
+      {PANELS.map(({ value, label, icon }) => {
+        const isActive = activePanel === value;
+        return (
+          <Button
+            key={value}
+            type="button"
+            size="xs"
+            className={cn(
+              "flex flex-1 items-center justify-center gap-[6px] font-medium",
+              isActive
+                ? "bg-gray-1 text-gray-12 shadow-sm hover:bg-gray-1"
+                : "bg-transparent text-gray-10 hover:bg-transparent hover:text-gray-12",
+            )}
+            onClick={() => onChange(value)}
+          >
+            {icon}
+            {label}
+          </Button>
+        );
+      })}
+    </Flex>
+  );
+}
diff --git a/apps/code/src/renderer/features/sidebar/components/SidebarSection.tsx b/apps/code/src/renderer/features/sidebar/components/SidebarSection.tsx
index c0efbb7292..a4ce8fd321 100644
--- a/apps/code/src/renderer/features/sidebar/components/SidebarSection.tsx
+++ b/apps/code/src/renderer/features/sidebar/components/SidebarSection.tsx
@@ -1,9 +1,18 @@
 import { Tooltip } from "@components/ui/Tooltip";
-import { CaretDownIcon, CaretRightIcon, Plus } from "@phosphor-icons/react";
+import {
+  CaretDownIcon,
+  CaretRightIcon,
+  Plus,
+  Trash,
+} from "@phosphor-icons/react";
 import { Button } from "@posthog/quill";
 import * as Collapsible from "@radix-ui/react-collapsible";
 import { useState } from "react";
 
+// Mirrors SidebarItem's indent math so folder headers and leaf rows align at
+// each nesting level.
+const INDENT_SIZE = 8;
+
 interface SidebarSectionProps {
   id: string;
   label: string;
@@ -12,10 +21,13 @@ interface SidebarSectionProps {
   onToggle: () => void;
   children: React.ReactNode;
   addSpacingBefore?: boolean;
+  depth?: number;
   onContextMenu?: (e: React.MouseEvent) => void;
   tooltipContent?: string;
   onNewTask?: () => void;
   newTaskTooltip?: string;
+  onDelete?: () => void;
+  deleteTooltip?: string;
   dragHandleRef?: React.RefCallback<HTMLButtonElement>;
 }
 
@@ -26,10 +38,13 @@ export function SidebarSection({
   onToggle,
   children,
   addSpacingBefore,
+  depth = 0,
   onContextMenu,
   tooltipContent,
   onNewTask,
   newTaskTooltip,
+  onDelete,
+  deleteTooltip,
   dragHandleRef,
 }: SidebarSectionProps) {
   const [isHovered, setIsHovered] = useState(false);
@@ -40,8 +55,9 @@ export function SidebarSection({
         <Button
           ref={dragHandleRef}
           type="button"
-          className="flex w-full items-center justify-between pl-2 not-hover:aria-expanded:bg-transparent"
+          className="flex w-full items-center justify-between not-hover:aria-expanded:bg-transparent"
           style={{
+            paddingLeft: `${depth * INDENT_SIZE + 8 + (depth > 0 ? 4 : 0)}px`,
             marginTop: addSpacingBefore ? "12px" : undefined,
           }}
           onContextMenu={onContextMenu}
@@ -99,6 +115,30 @@ export function SidebarSection({
                 </span>
               </Tooltip>
             )}
+            {onDelete && isHovered && (
+              <Tooltip content={deleteTooltip ?? "Delete"} side="left">
+                {/* biome-ignore lint/a11y/useSemanticElements: Cannot use button inside parent button (Collapsible.Trigger) */}
+                <span
+                  role="button"
+                  tabIndex={0}
+                  className="flex h-[18px] w-[18px] items-center justify-center rounded-sm border-0 bg-transparent p-0 hover:bg-gray-3 hover:text-red-9"
+                  onClick={(e) => {
+                    e.preventDefault();
+                    e.stopPropagation();
+                    onDelete();
+                  }}
+                  onKeyDown={(e) => {
+                    if (e.key === "Enter" || e.key === " ") {
+                      e.preventDefault();
+                      e.stopPropagation();
+                      onDelete();
+                    }
+                  }}
+                >
+                  <Trash size={12} />
+                </span>
+              </Tooltip>
+            )}
           </span>
         </Button>
       </Collapsible.Trigger>
diff --git a/apps/code/src/renderer/features/sidebar/hooks/useDesktopFileSystem.ts b/apps/code/src/renderer/features/sidebar/hooks/useDesktopFileSystem.ts
new file mode 100644
index 0000000000..a34879dcdc
--- /dev/null
+++ b/apps/code/src/renderer/features/sidebar/hooks/useDesktopFileSystem.ts
@@ -0,0 +1,87 @@
+import { useOptionalAuthenticatedClient } from "@features/auth/hooks/authClient";
+import { useAuthenticatedQuery } from "@hooks/useAuthenticatedQuery";
+import type { Schemas } from "@renderer/api/generated";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { useCallback } from "react";
+
+const DESKTOP_FILE_SYSTEM_POLL_INTERVAL_MS = 30_000;
+const DESKTOP_FILE_SYSTEM_QUERY_KEY = ["desktop-file-system"] as const;
+
+export function useDesktopFileSystem(options?: { enabled?: boolean }) {
+  return useAuthenticatedQuery<Schemas.FileSystem[]>(
+    DESKTOP_FILE_SYSTEM_QUERY_KEY,
+    (client) => client.getDesktopFileSystem(),
+    {
+      enabled: options?.enabled ?? true,
+      refetchInterval: DESKTOP_FILE_SYSTEM_POLL_INTERVAL_MS,
+    },
+  );
+}
+
+// Create/delete top-level channels on the desktop file system surface. Both
+// mutations invalidate the shared query key so the tree refetches immediately
+// rather than waiting on the 30s poll.
+export function useDesktopFileSystemMutations() {
+  const client = useOptionalAuthenticatedClient();
+  const queryClient = useQueryClient();
+
+  const invalidate = useCallback(() => {
+    void queryClient.invalidateQueries({
+      queryKey: DESKTOP_FILE_SYSTEM_QUERY_KEY,
+    });
+  }, [queryClient]);
+
+  const createMutation = useMutation({
+    mutationFn: async (name: string) => {
+      if (!client) throw new Error("Not authenticated");
+      return client.createDesktopFileSystemChannel(name);
+    },
+    onSuccess: invalidate,
+  });
+
+  const deleteMutation = useMutation({
+    mutationFn: async (id: string) => {
+      if (!client) throw new Error("Not authenticated");
+      return client.deleteDesktopFileSystem(id);
+    },
+    onSuccess: invalidate,
+  });
+
+  const fileEntryMutation = useMutation({
+    mutationFn: async (input: {
+      path: string;
+      type: string;
+      ref?: string;
+      href?: string;
+    }) => {
+      if (!client) throw new Error("Not authenticated");
+      return client.createDesktopFileSystemEntry(input);
+    },
+    onSuccess: invalidate,
+  });
+
+  const createChannel = useCallback(
+    (name: string) => createMutation.mutateAsync(name),
+    [createMutation],
+  );
+
+  const deleteChannel = useCallback(
+    (id: string) => deleteMutation.mutateAsync(id),
+    [deleteMutation],
+  );
+
+  const fileEntry = useCallback(
+    (input: { path: string; type: string; ref?: string; href?: string }) =>
+      fileEntryMutation.mutateAsync(input),
+    [fileEntryMutation],
+  );
+
+  return {
+    createChannel,
+    deleteChannel,
+    fileEntry,
+    isCreating: createMutation.isPending,
+    isDeleting: deleteMutation.isPending,
+    isFiling: fileEntryMutation.isPending,
+  };
+}
diff --git a/apps/code/src/renderer/features/sidebar/stores/sidebarStore.ts b/apps/code/src/renderer/features/sidebar/stores/sidebarStore.ts
index b87d80c2f5..994ab86718 100644
--- a/apps/code/src/renderer/features/sidebar/stores/sidebarStore.ts
+++ b/apps/code/src/renderer/features/sidebar/stores/sidebarStore.ts
@@ -14,6 +14,7 @@ interface SidebarStoreState {
   sortMode: "updated" | "created";
   showAllUsers: boolean;
   showInternal: boolean;
+  activePanel: "tasks" | "files";
 }
 
 interface SidebarStoreActions {
@@ -32,6 +33,7 @@ interface SidebarStoreActions {
   setSortMode: (mode: SidebarStoreState["sortMode"]) => void;
   setShowAllUsers: (showAllUsers: boolean) => void;
   setShowInternal: (showInternal: boolean) => void;
+  setActivePanel: (panel: SidebarStoreState["activePanel"]) => void;
 }
 
 type SidebarStore = SidebarStoreState & SidebarStoreActions;
@@ -50,6 +52,7 @@ export const useSidebarStore = create<SidebarStore>()(
       sortMode: "updated",
       showAllUsers: false,
       showInternal: false,
+      activePanel: "files",
       setOpen: (open) => set({ open, hasUserSetOpen: true }),
       setOpenAuto: (open) =>
         set((state) => (state.hasUserSetOpen ? state : { open })),
@@ -100,6 +103,7 @@ export const useSidebarStore = create<SidebarStore>()(
       setSortMode: (sortMode) => set({ sortMode }),
       setShowAllUsers: (showAllUsers) => set({ showAllUsers }),
       setShowInternal: (showInternal) => set({ showInternal }),
+      setActivePanel: (activePanel) => set({ activePanel }),
     }),
     {
       name: "sidebar-storage",
@@ -114,6 +118,7 @@ export const useSidebarStore = create<SidebarStore>()(
         sortMode: state.sortMode,
         showAllUsers: state.showAllUsers,
         showInternal: state.showInternal,
+        activePanel: state.activePanel,
       }),
       merge: (persisted, current) => {
         const persistedState = persisted as {
@@ -127,6 +132,7 @@ export const useSidebarStore = create<SidebarStore>()(
           sortMode?: SidebarStoreState["sortMode"];
           showAllUsers?: boolean;
           showInternal?: boolean;
+          activePanel?: SidebarStoreState["activePanel"];
         };
         return {
           ...current,
@@ -145,6 +151,7 @@ export const useSidebarStore = create<SidebarStore>()(
           sortMode: persistedState.sortMode ?? current.sortMode,
           showAllUsers: persistedState.showAllUsers ?? current.showAllUsers,
           showInternal: persistedState.showInternal ?? current.showInternal,
+          activePanel: persistedState.activePanel ?? current.activePanel,
         };
       },
     },
diff --git a/apps/code/src/renderer/features/sidebar/utils/fileSystemTree.test.ts b/apps/code/src/renderer/features/sidebar/utils/fileSystemTree.test.ts
new file mode 100644
index 0000000000..4b0b82799e
--- /dev/null
+++ b/apps/code/src/renderer/features/sidebar/utils/fileSystemTree.test.ts
@@ -0,0 +1,101 @@
+import type { Schemas } from "@renderer/api/generated";
+import { describe, expect, it } from "vitest";
+import { buildFileSystemTree } from "./fileSystemTree";
+
+function item(partial: Partial<Schemas.FileSystem>): Schemas.FileSystem {
+  return {
+    id: partial.path ?? "id",
+    path: "",
+    depth: null,
+    created_at: "2026-01-01T00:00:00Z",
+    last_viewed_at: null,
+    ...partial,
+  };
+}
+
+describe("buildFileSystemTree", () => {
+  it("returns an empty array for no items", () => {
+    expect(buildFileSystemTree([])).toEqual([]);
+  });
+
+  it("derives intermediate folder nodes from a leaf path", () => {
+    const tree = buildFileSystemTree([
+      item({ path: "Insights/Web/My insight", type: "insight", href: "/x" }),
+    ]);
+
+    expect(tree).toHaveLength(1);
+    const insights = tree[0];
+    expect(insights.name).toBe("Insights");
+    expect(insights.isFolder).toBe(true);
+    expect(insights.item).toBeUndefined(); // derived, no explicit row
+
+    const web = insights.children[0];
+    expect(web.name).toBe("Web");
+    expect(web.isFolder).toBe(true);
+
+    const leaf = web.children[0];
+    expect(leaf.name).toBe("My insight");
+    expect(leaf.isFolder).toBe(false);
+    expect(leaf.item?.href).toBe("/x");
+  });
+
+  it("attaches explicit folder rows to their node", () => {
+    const tree = buildFileSystemTree([
+      item({ path: "Reports", type: "folder" }),
+      item({ path: "Reports/Sales", type: "dashboard", href: "/d" }),
+    ]);
+
+    expect(tree).toHaveLength(1);
+    const reports = tree[0];
+    expect(reports.isFolder).toBe(true);
+    expect(reports.item?.type).toBe("folder");
+    expect(reports.children.map((c) => c.name)).toEqual(["Sales"]);
+  });
+
+  it("sorts folders first, then alphabetically", () => {
+    const tree = buildFileSystemTree([
+      item({ path: "zeta", type: "insight", href: "/z" }),
+      item({ path: "alpha", type: "insight", href: "/a" }),
+      item({ path: "Mango", type: "folder" }),
+      item({ path: "Apple", type: "folder" }),
+    ]);
+
+    expect(tree.map((n) => n.name)).toEqual([
+      "Apple",
+      "Mango",
+      "alpha",
+      "zeta",
+    ]);
+  });
+
+  it("guards against empty path segments", () => {
+    const tree = buildFileSystemTree([
+      item({ path: "/Leading/slash", type: "insight", href: "/l" }),
+      item({ path: "Trailing/slash/", type: "folder" }),
+    ]);
+
+    const leading = tree.find((n) => n.name === "Leading");
+    expect(leading).toBeDefined();
+    expect(leading?.children[0].name).toBe("slash");
+    // No blank-named nodes anywhere.
+    const names = new Set<string>();
+    const walk = (nodes: ReturnType<typeof buildFileSystemTree>) => {
+      for (const n of nodes) {
+        names.add(n.name);
+        walk(n.children);
+      }
+    };
+    walk(tree);
+    expect(names.has("")).toBe(false);
+  });
+
+  it("keeps folder semantics when a leaf collides with a folder path", () => {
+    const tree = buildFileSystemTree([
+      item({ path: "Shared", type: "folder" }),
+      item({ path: "Shared", type: "insight", href: "/s" }),
+    ]);
+
+    expect(tree).toHaveLength(1);
+    expect(tree[0].isFolder).toBe(true);
+  });
+});
diff --git a/apps/code/src/renderer/features/sidebar/utils/fileSystemTree.ts b/apps/code/src/renderer/features/sidebar/utils/fileSystemTree.ts
new file mode 100644
index 0000000000..036e374df4
--- /dev/null
+++ b/apps/code/src/renderer/features/sidebar/utils/fileSystemTree.ts
@@ -0,0 +1,106 @@
+import type { Schemas } from "@renderer/api/generated";
+
+const FOLDER_TYPE = "folder";
+
+export interface FileSystemTreeNode {
+  /** Stable id/key: the full slash-delimited path. Unique within the tree. */
+  id: string;
+  /** Display label = last path segment. */
+  name: string;
+  /** Full path, e.g. "Insights/Web/My insight". */
+  path: string;
+  isFolder: boolean;
+  /** The originating flat row, if any (absent for derived intermediate folders). */
+  item?: Schemas.FileSystem;
+  children: FileSystemTreeNode[];
+}
+
+/**
+ * Turn the flat list returned by the desktop file system endpoint into a nested
+ * tree. Paths are slash-delimited. Folders may be explicit rows
+ * (`type === "folder"`) or only implied by a leaf's path; intermediate folder
+ * nodes are created on demand. Children are sorted folders-first, then
+ * alphabetically.
+ */
+export function buildFileSystemTree(
+  items: Schemas.FileSystem[],
+): FileSystemTreeNode[] {
+  const root: FileSystemTreeNode = {
+    id: "",
+    name: "",
+    path: "",
+    isFolder: true,
+    children: [],
+  };
+  const byPath = new Map<string, FileSystemTreeNode>();
+  byPath.set("", root);
+
+  // Split on "/" and drop empty segments produced by leading/trailing/double
+  // slashes so we never create blank-named nodes.
+  const segmentsOf = (path: string): string[] =>
+    path.split("/").filter((segment) => segment.length > 0);
+
+  // Ensure a folder node exists for the given segment list, creating ancestors
+  // as needed. An empty list resolves to the root.
+  function ensureFolder(segments: string[]): FileSystemTreeNode {
+    const path = segments.join("/");
+    const existing = byPath.get(path);
+    if (existing) return existing;
+    const parent = ensureFolder(segments.slice(0, -1));
+    const node: FileSystemTreeNode = {
+      id: path,
+      name: segments[segments.length - 1] ?? path,
+      path,
+      isFolder: true,
+      children: [],
+    };
+    byPath.set(path, node);
+    parent.children.push(node);
+    return node;
+  }
+
+  for (const item of items) {
+    const segments = segmentsOf(item.path);
+    if (segments.length === 0) continue;
+    const name = segments[segments.length - 1];
+    const normalizedPath = segments.join("/");
+
+    if (item.type === FOLDER_TYPE) {
+      const node = ensureFolder(segments);
+      node.item = item;
+      node.name = name;
+      continue;
+    }
+
+    // Leaf. If a folder already claims this exact path, keep folder semantics
+    // and just attach the source row.
+    const existing = byPath.get(normalizedPath);
+    if (existing?.isFolder) {
+      existing.item = existing.item ?? item;
+      continue;
+    }
+
+    const parent = ensureFolder(segments.slice(0, -1));
+    const leaf: FileSystemTreeNode = {
+      id: normalizedPath,
+      name,
+      path: normalizedPath,
+      isFolder: false,
+      item,
+      children: [],
+    };
+    byPath.set(normalizedPath, leaf);
+    parent.children.push(leaf);
+  }
+
+  sortChildren(root);
+  return root.children;
+}
+
+function sortChildren(node: FileSystemTreeNode): void {
+  node.children.sort((a, b) => {
+    if (a.isFolder !== b.isFolder) return a.isFolder ? -1 : 1;
+    return a.name.localeCompare(b.name);
+  });
+  for (const child of node.children) sortChildren(child);
+}
diff --git a/apps/code/src/renderer/hooks/useTaskContextMenu.ts b/apps/code/src/renderer/hooks/useTaskContextMenu.ts
index 31c48107a5..28529bb493 100644
--- a/apps/code/src/renderer/hooks/useTaskContextMenu.ts
+++ b/apps/code/src/renderer/hooks/useTaskContextMenu.ts
@@ -29,9 +29,11 @@ export function useTaskContextMenu() {
         isSuspended?: boolean;
         isInCommandCenter?: boolean;
         hasEmptyCommandCenterCell?: boolean;
+        fileToFolders?: { id: string; path: string }[];
         onTogglePin?: () => void;
         onArchivePrior?: (taskId: string) => void;
         onAddToCommandCenter?: () => void;
+        onFileTo?: (folderPath: string) => void | Promise<void>;
       },
     ) => {
       event.preventDefault();
@@ -44,9 +46,11 @@ export function useTaskContextMenu() {
         isSuspended,
         isInCommandCenter,
         hasEmptyCommandCenterCell,
+        fileToFolders,
         onTogglePin,
         onArchivePrior,
         onAddToCommandCenter,
+        onFileTo,
       } = options ?? {};
 
       try {
@@ -58,6 +62,7 @@ export function useTaskContextMenu() {
           isSuspended,
           isInCommandCenter,
           hasEmptyCommandCenterCell,
+          fileToFolders,
         });
 
         if (!result.action) return;
@@ -92,6 +97,9 @@ export function useTaskContextMenu() {
           case "add-to-command-center":
             onAddToCommandCenter?.();
             break;
+          case "file-to":
+            await onFileTo?.(result.action.folderPath);
+            break;
           case "external-app": {
             const effectivePath = worktreePath ?? folderPath;
             if (effectivePath) {
diff --git a/apps/code/src/renderer/navigationBridge.ts b/apps/code/src/renderer/navigationBridge.ts
index 645fb9e4a9..892060f67c 100644
--- a/apps/code/src/renderer/navigationBridge.ts
+++ b/apps/code/src/renderer/navigationBridge.ts
@@ -39,6 +39,13 @@ export function navigateToFolderSettings(folderId: string): void {
   });
 }
 
+export function navigateToFolderContext(folderId: string): void {
+  void getRouterOrNull()?.navigate({
+    to: "/code/channels/$folderId/context",
+    params: { folderId },
+  });
+}
+
 export function navigateToInbox(): void {
   void getRouterOrNull()?.navigate({ to: "/code/inbox" });
 }
diff --git a/apps/code/src/renderer/routeTree.gen.ts b/apps/code/src/renderer/routeTree.gen.ts
index e6d4d9846e..de116ac256 100644
--- a/apps/code/src/renderer/routeTree.gen.ts
+++ b/apps/code/src/renderer/routeTree.gen.ts
@@ -21,6 +21,7 @@ import { Route as CodeInboxRouteImport } from './routes/code/inbox'
 import { Route as CodeArchivedRouteImport } from './routes/code/archived'
 import { Route as CodeTasksTaskIdRouteImport } from './routes/code/tasks/$taskId'
 import { Route as CodeTasksPendingKeyRouteImport } from './routes/code/tasks/pending.$key'
+import { Route as CodeChannelsFolderIdContextRouteImport } from './routes/code/channels/$folderId/context'
 
 const SkillsRoute = SkillsRouteImport.update({
   id: '/skills',
@@ -82,6 +83,12 @@ const CodeTasksPendingKeyRoute = CodeTasksPendingKeyRouteImport.update({
   path: '/code/tasks/pending/$key',
   getParentRoute: () => rootRouteImport,
 } as any)
+const CodeChannelsFolderIdContextRoute =
+  CodeChannelsFolderIdContextRouteImport.update({
+    id: '/code/channels/$folderId/context',
+    path: '/code/channels/$folderId/context',
+    getParentRoute: () => rootRouteImport,
+  } as any)
 
 export interface FileRoutesByFullPath {
   '/': typeof IndexRoute
@@ -95,6 +102,7 @@ export interface FileRoutesByFullPath {
   '/code/': typeof CodeIndexRoute
   '/settings/': typeof SettingsIndexRoute
   '/code/tasks/$taskId': typeof CodeTasksTaskIdRoute
+  '/code/channels/$folderId/context': typeof CodeChannelsFolderIdContextRoute
   '/code/tasks/pending/$key': typeof CodeTasksPendingKeyRoute
 }
 export interface FileRoutesByTo {
@@ -109,6 +117,7 @@ export interface FileRoutesByTo {
   '/code': typeof CodeIndexRoute
   '/settings': typeof SettingsIndexRoute
   '/code/tasks/$taskId': typeof CodeTasksTaskIdRoute
+  '/code/channels/$folderId/context': typeof CodeChannelsFolderIdContextRoute
   '/code/tasks/pending/$key': typeof CodeTasksPendingKeyRoute
 }
 export interface FileRoutesById {
@@ -124,6 +133,7 @@ export interface FileRoutesById {
   '/code/': typeof CodeIndexRoute
   '/settings/': typeof SettingsIndexRoute
   '/code/tasks/$taskId': typeof CodeTasksTaskIdRoute
+  '/code/channels/$folderId/context': typeof CodeChannelsFolderIdContextRoute
   '/code/tasks/pending/$key': typeof CodeTasksPendingKeyRoute
 }
 export interface FileRouteTypes {
@@ -140,6 +150,7 @@ export interface FileRouteTypes {
     | '/code/'
     | '/settings/'
     | '/code/tasks/$taskId'
+    | '/code/channels/$folderId/context'
     | '/code/tasks/pending/$key'
   fileRoutesByTo: FileRoutesByTo
   to:
@@ -154,6 +165,7 @@ export interface FileRouteTypes {
     | '/code'
     | '/settings'
     | '/code/tasks/$taskId'
+    | '/code/channels/$folderId/context'
     | '/code/tasks/pending/$key'
   id:
     | '__root__'
@@ -168,6 +180,7 @@ export interface FileRouteTypes {
     | '/code/'
     | '/settings/'
     | '/code/tasks/$taskId'
+    | '/code/channels/$folderId/context'
     | '/code/tasks/pending/$key'
   fileRoutesById: FileRoutesById
 }
@@ -183,6 +196,7 @@ export interface RootRouteChildren {
   CodeIndexRoute: typeof CodeIndexRoute
   SettingsIndexRoute: typeof SettingsIndexRoute
   CodeTasksTaskIdRoute: typeof CodeTasksTaskIdRoute
+  CodeChannelsFolderIdContextRoute: typeof CodeChannelsFolderIdContextRoute
   CodeTasksPendingKeyRoute: typeof CodeTasksPendingKeyRoute
 }
 
@@ -272,6 +286,13 @@ declare module '@tanstack/react-router' {
       preLoaderRoute: typeof CodeTasksPendingKeyRouteImport
       parentRoute: typeof rootRouteImport
     }
+    '/code/channels/$folderId/context': {
+      id: '/code/channels/$folderId/context'
+      path: '/code/channels/$folderId/context'
+      fullPath: '/code/channels/$folderId/context'
+      preLoaderRoute: typeof CodeChannelsFolderIdContextRouteImport
+      parentRoute: typeof rootRouteImport
+    }
   }
 }
 
@@ -287,6 +308,7 @@ const rootRouteChildren: RootRouteChildren = {
   CodeIndexRoute: CodeIndexRoute,
   SettingsIndexRoute: SettingsIndexRoute,
   CodeTasksTaskIdRoute: CodeTasksTaskIdRoute,
+  CodeChannelsFolderIdContextRoute: CodeChannelsFolderIdContextRoute,
   CodeTasksPendingKeyRoute: CodeTasksPendingKeyRoute,
 }
 export const routeTree = rootRouteImport
diff --git a/apps/code/src/renderer/routes/code/channels/$folderId/context.tsx b/apps/code/src/renderer/routes/code/channels/$folderId/context.tsx
new file mode 100644
index 0000000000..e725f60e51
--- /dev/null
+++ b/apps/code/src/renderer/routes/code/channels/$folderId/context.tsx
@@ -0,0 +1,11 @@
+import { FolderContextView } from "@features/folder-context/components/FolderContextView";
+import { createFileRoute } from "@tanstack/react-router";
+
+export const Route = createFileRoute("/code/channels/$folderId/context")({
+  component: FolderContextRoute,
+});
+
+function FolderContextRoute() {
+  const { folderId } = Route.useParams();
+  return <FolderContextView folderId={folderId} />;
+}
diff --git a/apps/code/src/shared/constants.ts b/apps/code/src/shared/constants.ts
index 1cdb2c9f38..afbfab30c5 100644
--- a/apps/code/src/shared/constants.ts
+++ b/apps/code/src/shared/constants.ts
@@ -3,6 +3,7 @@ export const INBOX_GATED_DUE_TO_SCALE_FLAG = "inbox-gated-due-to-scale";
 export const EXPERIMENT_SUGGESTIONS_FLAG =
   "posthog-code-experiment-suggestions";
 export const SYNC_CLOUD_TASKS_FLAG = "posthog-code-sync-cloud-tasks";
+export const FILE_SYSTEM_SIDEBAR_FLAG = "posthog-code-file-system-sidebar";
 export const DISCOVERY_RUN_FLAG = "posthog-code-discovery-run";
 export const BRANCH_PREFIX = "posthog-code/";
 export const DATA_DIR = ".posthog-code";