Fix: persist project folder hierarchy

Backend/cmd/posix/main.go

@@ -0,0 +1,52 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"os"
+
+	"moku-backend/internal/config"
+	"moku-backend/internal/database"
+	"moku-backend/internal/posixproj"
+)
+
+func main() {
+	command := "rebuild"
+	if len(os.Args) > 1 {
+		command = os.Args[1]
+	}
+
+	switch command {
+	case "rebuild":
+		if err := rebuildProjection(context.Background()); err != nil {
+			log.Fatalf("rebuild POSIX projection: %v", err)
+		}
+	default:
+		log.Fatalf("unsupported posix command %q (supported: rebuild)", command)
+	}
+}
+
+func rebuildProjection(ctx context.Context) error {
+	cfg := config.Load()
+
+	db, err := database.NewPostgres(cfg.PostgresURL)
+	if err != nil {
+		return fmt.Errorf("connect database: %w", err)
+	}
+	defer db.Close()
+
+	summary, err := posixproj.NewProjector(db, cfg.POSIXRoot).RebuildWithSummary(ctx)
+	if err != nil {
+		return err
+	}
+
+	fmt.Printf(
+		"POSIX projection rebuilt from %s\n  total nodes: %d\n  directories: %d\n  files: %d\n",
+		cfg.POSIXRoot,
+		summary.TotalNodes,
+		summary.DirectoryCount,
+		summary.FileCount,
+	)
+	return nil
+}

Backend/db/migrations/000004_posix_nodes.sql

@@ -0,0 +1,45 @@
+-- +goose Up
+
+CREATE TYPE posix_node_kind AS ENUM ('directory', 'file');
+
+CREATE TABLE IF NOT EXISTS posix_nodes (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  path TEXT NOT NULL UNIQUE,
+  parent_path TEXT,
+  name TEXT NOT NULL,
+  depth INTEGER NOT NULL,
+  node_kind posix_node_kind NOT NULL,
+  logical_type TEXT NOT NULL DEFAULT 'generic',
+  file_role TEXT,
+  resource_id TEXT,
+  resource_name TEXT,
+  resource_slug TEXT,
+  installation_id TEXT,
+  organization_id TEXT,
+  organization_slug TEXT,
+  department_slug TEXT,
+  team_slug TEXT,
+  project_slug TEXT,
+  personal_slug TEXT,
+  content_json JSONB,
+  size_bytes BIGINT NOT NULL DEFAULT 0,
+  checksum TEXT,
+  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE INDEX IF NOT EXISTS idx_posix_nodes_parent_path ON posix_nodes (parent_path);
+CREATE INDEX IF NOT EXISTS idx_posix_nodes_logical_type ON posix_nodes (logical_type);
+CREATE INDEX IF NOT EXISTS idx_posix_nodes_project_slug ON posix_nodes (project_slug);
+CREATE INDEX IF NOT EXISTS idx_posix_nodes_department_slug ON posix_nodes (department_slug);
+CREATE INDEX IF NOT EXISTS idx_posix_nodes_team_slug ON posix_nodes (team_slug);
+
+-- +goose Down
+
+DROP INDEX IF EXISTS idx_posix_nodes_team_slug;
+DROP INDEX IF EXISTS idx_posix_nodes_department_slug;
+DROP INDEX IF EXISTS idx_posix_nodes_project_slug;
+DROP INDEX IF EXISTS idx_posix_nodes_logical_type;
+DROP INDEX IF EXISTS idx_posix_nodes_parent_path;
+DROP TABLE IF EXISTS posix_nodes;
+DROP TYPE IF EXISTS posix_node_kind;

Backend/internal/bootstrap/service.go

@@ -10,10 +10,12 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+	"unicode"
 
 	"github.com/jackc/pgx/v5"
 
 	"moku-backend/internal/database"
+	"moku-backend/internal/posixproj"
 )
 
 const (
@@ -41,6 +43,8 @@ const (
 var (
 	ErrInstallationNotConfigured = errors.New("bootstrap installation step has not been completed")
 	ErrAdminNotConfigured        = errors.New("bootstrap admin step has not been completed")
+	ErrProjectNotFound           = errors.New("project not found")
+	ErrProjectFolderNotFound     = errors.New("project folder not found")
 )
 
 type Service struct {
@@ -176,6 +180,30 @@ type namedRecord struct {
 	Slug string `json:"slug"`
 }
 
+type ProjectHierarchyFolderRecord struct {
+	ID       string                         `json:"id"`
+	Label    string                         `json:"label"`
+	Children []ProjectHierarchyFolderRecord `json:"children"`
+}
+
+type CreateProjectFolderInput struct {
+	ProjectID      string
+	ParentFolderID string
+	Name           string
+}
+
+type CreateProjectFolderResult struct {
+	ProjectID     string                         `json:"projectId"`
+	CreatedFolder ProjectHierarchyFolderRecord   `json:"createdFolder"`
+	Folders       []ProjectHierarchyFolderRecord `json:"folders"`
+}
+
+type projectHierarchyFolderRow struct {
+	Path       string
+	ParentPath string
+	Label      string
+}
+
 func NewService(db *database.DB, posixRoot string) *Service {
 	return &Service{db: db, posixRoot: strings.TrimSpace(posixRoot)}
 }
@@ -413,6 +441,10 @@ func (service *Service) SaveStructure(ctx context.Context, input SaveStructureIn
 		return StructureRecord{}, err
 	}
 
+	if err := posixproj.NewProjector(service.db, service.posixRoot).Rebuild(ctx); err != nil {
+		return StructureRecord{}, fmt.Errorf("rebuild POSIX projection: %w", err)
+	}
+
 	return StructureRecord{
 		Installation: installation,
 		Organization: organization,
@@ -789,6 +821,92 @@ func (service *Service) listProjects(ctx context.Context) ([]ProjectRecord, erro
 	return records, rows.Err()
 }
 
+func (service *Service) loadProjectByID(ctx context.Context, projectID string) (*ProjectRecord, error) {
+	var record ProjectRecord
+	err := service.db.Pool.QueryRow(ctx, `
+		SELECT id::text, organization_id::text, department_id::text, team_id::text, name, slug
+		FROM projects
+		WHERE id = $1::uuid
+		LIMIT 1;
+	`, projectID).Scan(&record.ID, &record.OrganizationID, &record.DepartmentID, &record.TeamID, &record.Name, &record.Slug)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return nil, ErrProjectNotFound
+		}
+
+		return nil, err
+	}
+
+	return &record, nil
+}
+
+func (service *Service) GetProjectHierarchyFolders(ctx context.Context, projectID string) ([]ProjectHierarchyFolderRecord, error) {
+	project, err := service.loadProjectByID(ctx, projectID)
+	if err != nil {
+		return nil, err
+	}
+
+	rows, err := service.db.Pool.Query(ctx, `
+		SELECT path, COALESCE(parent_path, ''), COALESCE(resource_name, '')
+		FROM posix_nodes
+		WHERE node_kind = 'directory'::posix_node_kind
+		  AND logical_type = 'hierarchy_folder'
+		  AND project_slug = $1
+		ORDER BY depth ASC, path ASC;
+	`, project.Slug)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var folderRows []projectHierarchyFolderRow
+	for rows.Next() {
+		var row projectHierarchyFolderRow
+		if err := rows.Scan(&row.Path, &row.ParentPath, &row.Label); err != nil {
+			return nil, err
+		}
+		folderRows = append(folderRows, row)
+	}
+
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+
+	return buildProjectHierarchyFolderTree(folderRows, projectHierarchyRootPath(project.Slug)), nil
+}
+
+func (service *Service) CreateProjectFolder(ctx context.Context, input CreateProjectFolderInput) (CreateProjectFolderResult, error) {
+	project, err := service.loadProjectByID(ctx, strings.TrimSpace(input.ProjectID))
+	if err != nil {
+		return CreateProjectFolderResult{}, err
+	}
+
+	createdPath, _, err := service.createProjectHierarchyFolderOnDisk(project.Slug, strings.TrimSpace(input.ParentFolderID), input.Name)
+	if err != nil {
+		return CreateProjectFolderResult{}, err
+	}
+
+	if err := posixproj.NewProjector(service.db, service.posixRoot).Rebuild(ctx); err != nil {
+		return CreateProjectFolderResult{}, fmt.Errorf("rebuild POSIX projection: %w", err)
+	}
+
+	folders, err := service.GetProjectHierarchyFolders(ctx, project.ID)
+	if err != nil {
+		return CreateProjectFolderResult{}, err
+	}
+
+	createdFolder, ok := findProjectHierarchyFolder(folders, createdPath)
+	if !ok {
+		return CreateProjectFolderResult{}, fmt.Errorf("created project folder missing from projection")
+	}
+
+	return CreateProjectFolderResult{
+		ProjectID:     project.ID,
+		CreatedFolder: createdFolder,
+		Folders:       folders,
+	}, nil
+}
+
 func (service *Service) listWorkspaces(ctx context.Context) ([]WorkspaceRecord, error) {
 	rows, err := service.db.Pool.Query(ctx, `
 		SELECT id::text, organization_id::text, name, slug, kind::text, department_id::text, team_id::text, project_id::text
@@ -973,6 +1091,7 @@ func (service *Service) ensureBootstrapPOSIXSkeleton(
 		departmentPath,
 		teamPath,
 		projectPath,
+		filepath.Join(projectPath, "children"),
 		filepath.Join(projectPath, "tree"),
 		filepath.Join(usersPath, "personals"),
 	} {
@@ -1036,6 +1155,14 @@ func (service *Service) ensureBootstrapPOSIXSkeleton(
 		return fmt.Errorf("write project home.json: %w", err)
 	}
 
+	if err := writeJSONFile(filepath.Join(projectPath, "acl.json"), map[string]any{
+		"version":  1,
+		"inherits": true,
+		"rules":    []any{},
+	}); err != nil {
+		return fmt.Errorf("write project acl.json: %w", err)
+	}
+
 	if err := writeJSONFile(filepath.Join(usersPath, "settings.json"), map[string]any{
 		"primaryAdminId": admin.ID,
 	}); err != nil {
@@ -1055,6 +1182,194 @@ func (service *Service) ensureBootstrapPOSIXSkeleton(
 	return nil
 }
 
+func (service *Service) createProjectHierarchyFolderOnDisk(projectSlug, parentFolderID, name string) (string, string, error) {
+	rootPath := strings.TrimSpace(service.posixRoot)
+	if rootPath == "" {
+		return "", "", fmt.Errorf("POSIX root is not configured")
+	}
+
+	trimmedName := strings.TrimSpace(name)
+	if trimmedName == "" {
+		return "", "", fmt.Errorf("folder name is required")
+	}
+
+	projectRoot := filepath.Join(rootPath, "projects", slugDir("project", projectSlug))
+	childrenRoot := filepath.Join(projectRoot, "children")
+	parentDir := childrenRoot
+	containerProjectionPath := projectHierarchyRootPath(projectSlug)
+
+	if strings.TrimSpace(parentFolderID) != "" {
+		containerProjectionPath = filepath.ToSlash(filepath.Join(strings.TrimSpace(parentFolderID), "children"))
+		parentDir = filepath.Join(rootPath, filepath.FromSlash(containerProjectionPath))
+		info, err := os.Stat(parentDir)
+		if err != nil {
+			if os.IsNotExist(err) {
+				return "", "", ErrProjectFolderNotFound
+			}
+			return "", "", fmt.Errorf("stat parent project folder: %w", err)
+		}
+		if !info.IsDir() {
+			return "", "", ErrProjectFolderNotFound
+		}
+	}
+
+	if err := os.MkdirAll(parentDir, 0o755); err != nil {
+		return "", "", fmt.Errorf("create parent project folder path: %w", err)
+	}
+
+	baseSlug := normalizePOSIXSlug(trimmedName)
+	folderName := slugDir("folder", baseSlug)
+	folderDir := filepath.Join(parentDir, folderName)
+	folderSlug := baseSlug
+
+	for attempt := 2; ; attempt += 1 {
+		if _, err := os.Stat(folderDir); os.IsNotExist(err) {
+			break
+		} else if err != nil {
+			return "", "", fmt.Errorf("stat candidate project folder: %w", err)
+		}
+
+		folderSlug = fmt.Sprintf("%s-%d", baseSlug, attempt)
+		folderName = slugDir("folder", folderSlug)
+		folderDir = filepath.Join(parentDir, folderName)
+	}
+
+	if err := os.MkdirAll(filepath.Join(folderDir, "children"), 0o755); err != nil {
+		return "", "", fmt.Errorf("create project hierarchy folder: %w", err)
+	}
+
+	if err := writeJSONFile(filepath.Join(folderDir, "folder.json"), map[string]any{
+		"name": trimmedName,
+		"slug": folderSlug,
+		"type": "folder",
+	}); err != nil {
+		return "", "", fmt.Errorf("write project folder.json: %w", err)
+	}
+
+	if err := writeJSONFile(filepath.Join(folderDir, "acl.json"), map[string]any{
+		"version":  1,
+		"inherits": true,
+		"rules":    []any{},
+	}); err != nil {
+		return "", "", fmt.Errorf("write project acl.json: %w", err)
+	}
+
+	return filepath.ToSlash(filepath.Join(containerProjectionPath, folderName)), folderSlug, nil
+}
+
+func buildProjectHierarchyFolderTree(rows []projectHierarchyFolderRow, rootParentPath string) []ProjectHierarchyFolderRecord {
+	if len(rows) == 0 {
+		return nil
+	}
+
+	nodesByPath := make(map[string]*ProjectHierarchyFolderRecord, len(rows))
+	childrenByParent := make(map[string][]string)
+
+	for _, row := range rows {
+		label := strings.TrimSpace(row.Label)
+		if label == "" {
+			label = fallbackFolderLabel(row.Path)
+		}
+		nodesByPath[row.Path] = &ProjectHierarchyFolderRecord{
+			ID:       row.Path,
+			Label:    label,
+			Children: []ProjectHierarchyFolderRecord{},
+		}
+		childrenByParent[row.ParentPath] = append(childrenByParent[row.ParentPath], row.Path)
+	}
+
+	var build func(parentPath string) []ProjectHierarchyFolderRecord
+	build = func(parentPath string) []ProjectHierarchyFolderRecord {
+		childPaths := childrenByParent[parentPath]
+		if len(childPaths) == 0 {
+			return nil
+		}
+
+		folders := make([]ProjectHierarchyFolderRecord, 0, len(childPaths))
+		for _, childPath := range childPaths {
+			node := nodesByPath[childPath]
+			if node == nil {
+				continue
+			}
+
+			folder := ProjectHierarchyFolderRecord{
+				ID:       node.ID,
+				Label:    node.Label,
+				Children: build(filepath.ToSlash(filepath.Join(childPath, "children"))),
+			}
+			folders = append(folders, folder)
+		}
+
+		return folders
+	}
+
+	return build(rootParentPath)
+}
+
+func findProjectHierarchyFolder(folders []ProjectHierarchyFolderRecord, folderID string) (ProjectHierarchyFolderRecord, bool) {
+	for _, folder := range folders {
+		if folder.ID == folderID {
+			return folder, true
+		}
+
+		if child, ok := findProjectHierarchyFolder(folder.Children, folderID); ok {
+			return child, true
+		}
+	}
+
+	return ProjectHierarchyFolderRecord{}, false
+}
+
+func projectHierarchyRootPath(projectSlug string) string {
+	return filepath.ToSlash(filepath.Join("projects", slugDir("project", projectSlug), "children"))
+}
+
+func normalizePOSIXSlug(value string) string {
+	trimmed := strings.TrimSpace(strings.ToLower(value))
+	if trimmed == "" {
+		return "untitled"
+	}
+
+	var builder strings.Builder
+	lastDash := false
+	for _, r := range trimmed {
+		switch {
+		case unicode.IsLetter(r) || unicode.IsDigit(r):
+			builder.WriteRune(r)
+			lastDash = false
+		case r == '-' || r == '_' || unicode.IsSpace(r):
+			if !lastDash && builder.Len() > 0 {
+				builder.WriteByte('-')
+				lastDash = true
+			}
+		}
+	}
+
+	slug := strings.Trim(builder.String(), "-")
+	if slug == "" {
+		return "untitled"
+	}
+
+	return slug
+}
+
+func fallbackFolderLabel(path string) string {
+	base := filepath.Base(filepath.FromSlash(path))
+	trimmed := strings.TrimPrefix(base, "folder-")
+	parts := strings.FieldsFunc(trimmed, func(r rune) bool { return r == '-' || r == '_' })
+	for index, part := range parts {
+		if part == "" {
+			continue
+		}
+		parts[index] = strings.ToUpper(part[:1]) + part[1:]
+	}
+	label := strings.Join(parts, " ")
+	if label == "" {
+		return base
+	}
+	return label
+}
+
 func slugDir(prefix, slug string) string {
 	trimmedSlug := strings.TrimSpace(slug)
 	if trimmedSlug == "" {

Backend/internal/bootstrap/service_test.go

@@ -52,6 +52,8 @@ func TestEnsureBootstrapPOSIXSkeletonInitializesEmptyRoot(t *testing.T) {
 		filepath.Join(rootPath, "departments", "department-primary-department", "teams", "team-primary-team", "users.json"),
 		filepath.Join(rootPath, "projects", "project-primary-project", "settings.json"),
 		filepath.Join(rootPath, "projects", "project-primary-project", "home.json"),
+		filepath.Join(rootPath, "projects", "project-primary-project", "acl.json"),
+		filepath.Join(rootPath, "projects", "project-primary-project", "children"),
 		filepath.Join(rootPath, "projects", "project-primary-project", "tree"),
 		filepath.Join(rootPath, "users", "settings.json"),
 		filepath.Join(rootPath, "users", "data.json"),
@@ -90,12 +92,94 @@ func TestEnsureBootstrapPOSIXSkeletonInitializesEmptyRoot(t *testing.T) {
 		t.Fatalf("expected project settings type project, got %#v", projectSettings["type"])
 	}
 
+	projectACL := readJSONFileForTest[map[string]any](t, filepath.Join(rootPath, "projects", "project-primary-project", "acl.json"))
+	if projectACL["inherits"] != true {
+		t.Fatalf("expected project acl to inherit by default, got %#v", projectACL["inherits"])
+	}
+
 	usersSettings := readJSONFileForTest[map[string]any](t, filepath.Join(rootPath, "users", "settings.json"))
 	if usersSettings["primaryAdminId"] != "admin-1" {
 		t.Fatalf("expected primary admin id admin-1, got %#v", usersSettings["primaryAdminId"])
 	}
 }
 
+func TestCreateProjectHierarchyFolderOnDiskCreatesExpectedFolderShape(t *testing.T) {
+	rootPath := filepath.Join(t.TempDir(), "POSIX")
+	service := NewService(nil, rootPath)
+
+	err := service.ensureBootstrapPOSIXSkeleton(
+		InstallationRecord{ID: "installation-1", Name: "MangoPig", Mode: "personal", Access: "local", Protocol: "http", Host: "localhost", IsBootstrapped: true},
+		AdminSummary{ID: "admin-1", Email: "ronald@example.com", DisplayName: "Ronald"},
+		namedRecord{ID: "org-1", Name: "Primary Organization", Slug: "primary-organization"},
+		namedRecord{ID: "dept-1", Name: "Primary Department", Slug: "primary-department"},
+		namedRecord{ID: "team-1", Name: "Primary Team", Slug: "primary-team"},
+		namedRecord{ID: "project-1", Name: "Primary Project", Slug: "primary-project"},
+	)
+	if err != nil {
+		t.Fatalf("ensure bootstrap POSIX skeleton: %v", err)
+	}
+
+	createdPath, createdSlug, err := service.createProjectHierarchyFolderOnDisk("primary-project", "", "Design System")
+	if err != nil {
+		t.Fatalf("createProjectHierarchyFolderOnDisk root folder: %v", err)
+	}
+	if createdPath != "projects/project-primary-project/children/folder-design-system" {
+		t.Fatalf("unexpected created path: %s", createdPath)
+	}
+	if createdSlug != "design-system" {
+		t.Fatalf("unexpected created slug: %s", createdSlug)
+	}
+
+	createdFolderPath := filepath.Join(rootPath, "projects", "project-primary-project", "children", "folder-design-system")
+	for _, path := range []string{
+		filepath.Join(createdFolderPath, "folder.json"),
+		filepath.Join(createdFolderPath, "acl.json"),
+		filepath.Join(createdFolderPath, "children"),
+	} {
+		if _, err := os.Stat(path); err != nil {
+			t.Fatalf("expected path to exist %s: %v", path, err)
+		}
+	}
+
+	folderPayload := readJSONFileForTest[map[string]any](t, filepath.Join(createdFolderPath, "folder.json"))
+	if folderPayload["name"] != "Design System" {
+		t.Fatalf("expected folder name Design System, got %#v", folderPayload["name"])
+	}
+	if folderPayload["slug"] != "design-system" {
+		t.Fatalf("expected folder slug design-system, got %#v", folderPayload["slug"])
+	}
+
+	nestedPath, nestedSlug, err := service.createProjectHierarchyFolderOnDisk("primary-project", createdPath, "Research")
+	if err != nil {
+		t.Fatalf("createProjectHierarchyFolderOnDisk nested folder: %v", err)
+	}
+	if nestedPath != "projects/project-primary-project/children/folder-design-system/children/folder-research" {
+		t.Fatalf("unexpected nested path: %s", nestedPath)
+	}
+	if nestedSlug != "research" {
+		t.Fatalf("unexpected nested slug: %s", nestedSlug)
+	}
+}
+
+func TestBuildProjectHierarchyFolderTreeBuildsNestedStructure(t *testing.T) {
+	rows := []projectHierarchyFolderRow{
+		{Path: "projects/project-primary-project/children/folder-design", ParentPath: projectHierarchyRootPath("primary-project"), Label: "Design"},
+		{Path: "projects/project-primary-project/children/folder-design/children/folder-research", ParentPath: "projects/project-primary-project/children/folder-design/children", Label: "Research"},
+		{Path: "projects/project-primary-project/children/folder-ops", ParentPath: projectHierarchyRootPath("primary-project"), Label: "Ops"},
+	}
+
+	folders := buildProjectHierarchyFolderTree(rows, projectHierarchyRootPath("primary-project"))
+	if len(folders) != 2 {
+		t.Fatalf("expected 2 top-level folders, got %d", len(folders))
+	}
+	if folders[0].Label != "Design" || folders[1].Label != "Ops" {
+		t.Fatalf("unexpected top-level folder labels: %#v", folders)
+	}
+	if len(folders[0].Children) != 1 || folders[0].Children[0].Label != "Research" {
+		t.Fatalf("unexpected nested folder structure: %#v", folders[0].Children)
+	}
+}
+
 func readJSONFileForTest[T any](t *testing.T, path string) T {
 	t.Helper()
 

Backend/internal/httpx/api_project_routes.go

@@ -0,0 +1,118 @@
+package httpx
+
+import (
+	"encoding/json"
+	"errors"
+	"io"
+	"net/http"
+	"strings"
+
+	bootstrapservice "moku-backend/internal/bootstrap"
+
+	"github.com/go-chi/chi/v5"
+)
+
+type createProjectFolderRequest struct {
+	Name           string `json:"name"`
+	ParentFolderID string `json:"parentFolderId"`
+}
+
+func (routes apiRoutes) handleProjectFolders(w http.ResponseWriter, r *http.Request) {
+	projectID := strings.TrimSpace(chi.URLParam(r, "projectId"))
+	if projectID == "" {
+		WriteError(w, http.StatusBadRequest, RequestIDFromContext(r.Context()), "invalid_request", "Project ID is required.")
+		return
+	}
+
+	folders, err := routes.bootstrapService().GetProjectHierarchyFolders(r.Context(), projectID)
+	if err != nil {
+		routes.writeProjectFolderError(w, r, err)
+		return
+	}
+
+	WriteJSON(w, http.StatusOK, map[string]any{
+		"data": map[string]any{
+			"projectId": projectID,
+			"folders":   folders,
+		},
+		"meta": map[string]any{
+			"resource": "project-folders",
+		},
+	})
+}
+
+func (routes apiRoutes) handleCreateProjectFolder(w http.ResponseWriter, r *http.Request) {
+	projectID := strings.TrimSpace(chi.URLParam(r, "projectId"))
+	if projectID == "" {
+		WriteError(w, http.StatusBadRequest, RequestIDFromContext(r.Context()), "invalid_request", "Project ID is required.")
+		return
+	}
+
+	payload, ok := decodeProjectFolderRequest(w, r)
+	if !ok {
+		return
+	}
+
+	payload.Name = strings.TrimSpace(payload.Name)
+	payload.ParentFolderID = strings.TrimSpace(payload.ParentFolderID)
+	if payload.Name == "" {
+		WriteError(w, http.StatusBadRequest, RequestIDFromContext(r.Context()), "invalid_request", "Folder name is required.")
+		return
+	}
+
+	result, err := routes.bootstrapService().CreateProjectFolder(r.Context(), bootstrapservice.CreateProjectFolderInput{
+		ProjectID:      projectID,
+		ParentFolderID: payload.ParentFolderID,
+		Name:           payload.Name,
+	})
+	if err != nil {
+		routes.writeProjectFolderError(w, r, err)
+		return
+	}
+
+	WriteJSON(w, http.StatusCreated, map[string]any{
+		"data": result,
+		"meta": map[string]any{
+			"resource":  "project-folder-create",
+			"persisted": true,
+		},
+	})
+}
+
+func (routes apiRoutes) writeProjectFolderError(w http.ResponseWriter, r *http.Request, err error) {
+	switch {
+	case errors.Is(err, bootstrapservice.ErrProjectNotFound), errors.Is(err, bootstrapservice.ErrProjectFolderNotFound):
+		WriteError(w, http.StatusNotFound, RequestIDFromContext(r.Context()), "not_found", err.Error())
+	default:
+		routes.cfg.Logger.Error("persist project folder", "error", err, "path", r.URL.Path)
+		message := "Failed to persist project folder."
+		if routes.cfg.Config.IsDevelopment() {
+			message = message + " " + err.Error()
+		}
+		WriteError(w, http.StatusInternalServerError, RequestIDFromContext(r.Context()), "project_folder_persist_failed", message)
+	}
+}
+
+func decodeProjectFolderRequest(w http.ResponseWriter, r *http.Request) (createProjectFolderRequest, bool) {
+	var payload createProjectFolderRequest
+
+	decoder := json.NewDecoder(r.Body)
+	decoder.DisallowUnknownFields()
+
+	if err := decoder.Decode(&payload); err != nil {
+		if errors.Is(err, io.EOF) {
+			WriteError(w, http.StatusBadRequest, RequestIDFromContext(r.Context()), "invalid_json", "The request body is required and must be valid JSON.")
+			return payload, false
+		}
+
+		WriteError(w, http.StatusBadRequest, RequestIDFromContext(r.Context()), "invalid_json", "The request body must be valid JSON.")
+		return payload, false
+	}
+
+	if err := decoder.Decode(&struct{}{}); !errors.Is(err, io.EOF) {
+		WriteError(w, http.StatusBadRequest, RequestIDFromContext(r.Context()), "invalid_json", "The request body must contain a single JSON object.")
+		return payload, false
+	}
+
+	return payload, true
+}

Backend/internal/httpx/api_routes.go

@@ -33,6 +33,10 @@ func (routes apiRoutes) Register(router chi.Router) {
 		apiRouter.Get("/app-shell", routes.handleAppShellState)
 		apiRouter.Get("/organizations", routes.handleOrganizations)
 		apiRouter.Get("/workspaces", routes.handleWorkspaces)
+		apiRouter.Route("/projects/{projectId}", func(projectRouter chi.Router) {
+			projectRouter.Get("/folders", routes.handleProjectFolders)
+			projectRouter.Post("/folders", routes.handleCreateProjectFolder)
+		})
 
 		if routes.cfg.Config.IsDevelopment() {
 			apiRouter.Post("/dev/bootstrap/reset", routes.handleDevelopmentBootstrapReset)

Backend/internal/posixproj/projector.go

@@ -0,0 +1,553 @@
+package posixproj
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"moku-backend/internal/database"
+)
+
+const rootProjectionPath = "/"
+
+type Projector struct {
+	db   *database.DB
+	root string
+}
+
+type RebuildSummary struct {
+	TotalNodes      int
+	DirectoryCount  int
+	FileCount       int
+}
+
+type NodeKind string
+
+const (
+	NodeKindDirectory NodeKind = "directory"
+	NodeKindFile      NodeKind = "file"
+)
+
+type Scope struct {
+	InstallationID  string
+	OrganizationID  string
+	OrganizationSlug string
+	DepartmentSlug  string
+	TeamSlug        string
+	ProjectSlug     string
+	PersonalSlug    string
+}
+
+type Node struct {
+	Path            string
+	ParentPath      *string
+	Name            string
+	Depth           int
+	NodeKind        NodeKind
+	LogicalType     string
+	FileRole        string
+	ResourceID      string
+	ResourceName    string
+	ResourceSlug    string
+	InstallationID  string
+	OrganizationID  string
+	OrganizationSlug string
+	DepartmentSlug  string
+	TeamSlug        string
+	ProjectSlug     string
+	PersonalSlug    string
+	ContentJSON     []byte
+	SizeBytes       int64
+	Checksum        string
+}
+
+func NewProjector(db *database.DB, root string) *Projector {
+	return &Projector{db: db, root: strings.TrimSpace(root)}
+}
+
+func (projector *Projector) Rebuild(ctx context.Context) error {
+	_, err := projector.RebuildWithSummary(ctx)
+	return err
+}
+
+func (projector *Projector) RebuildWithSummary(ctx context.Context) (RebuildSummary, error) {
+	if projector == nil || projector.db == nil || projector.db.Pool == nil {
+		return RebuildSummary{}, nil
+	}
+
+	nodes, err := ScanRoot(projector.root)
+	if err != nil {
+		return RebuildSummary{}, err
+	}
+
+	summary := summarizeNodes(nodes)
+
+	tx, err := projector.db.Pool.Begin(ctx)
+	if err != nil {
+		return RebuildSummary{}, err
+	}
+	defer func() {
+		_ = tx.Rollback(ctx)
+	}()
+
+	if _, err := tx.Exec(ctx, `DELETE FROM posix_nodes;`); err != nil {
+		return RebuildSummary{}, fmt.Errorf("clear posix_nodes: %w", err)
+	}
+
+	for _, node := range nodes {
+		if _, err := tx.Exec(ctx, `
+			INSERT INTO posix_nodes (
+				path,
+				parent_path,
+				name,
+				depth,
+				node_kind,
+				logical_type,
+				file_role,
+				resource_id,
+				resource_name,
+				resource_slug,
+				installation_id,
+				organization_id,
+				organization_slug,
+				department_slug,
+				team_slug,
+				project_slug,
+				personal_slug,
+				content_json,
+				size_bytes,
+				checksum
+			) VALUES (
+				$1, $2, $3, $4, $5::posix_node_kind, $6, $7, $8, $9, $10,
+				$11, $12, $13, $14, $15, $16, $17, $18::jsonb, $19, $20
+			);
+		`,
+			node.Path,
+			node.ParentPath,
+			node.Name,
+			node.Depth,
+			string(node.NodeKind),
+			node.LogicalType,
+			node.FileRole,
+			node.ResourceID,
+			node.ResourceName,
+			node.ResourceSlug,
+			node.InstallationID,
+			node.OrganizationID,
+			node.OrganizationSlug,
+			node.DepartmentSlug,
+			node.TeamSlug,
+			node.ProjectSlug,
+			node.PersonalSlug,
+				node.ContentJSON,
+				node.SizeBytes,
+				node.Checksum,
+		); err != nil {
+			return RebuildSummary{}, fmt.Errorf("insert posix node %s: %w", node.Path, err)
+		}
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return RebuildSummary{}, err
+	}
+
+	return summary, nil
+}
+
+func ScanRoot(root string) ([]Node, error) {
+	rootPath := strings.TrimSpace(root)
+	if rootPath == "" {
+		return nil, nil
+	}
+
+	info, err := os.Stat(rootPath)
+	if err != nil {
+		return nil, fmt.Errorf("stat POSIX root: %w", err)
+	}
+	if !info.IsDir() {
+		return nil, fmt.Errorf("POSIX root is not a directory: %s", rootPath)
+	}
+
+	rootScope, err := loadRootScope(rootPath)
+	if err != nil {
+		return nil, err
+	}
+
+	nodes := []Node{{
+		Path:             rootProjectionPath,
+		ParentPath:       nil,
+		Name:             filepath.Base(rootPath),
+		Depth:            0,
+		NodeKind:         NodeKindDirectory,
+		LogicalType:      "tenant_root",
+		InstallationID:   rootScope.InstallationID,
+		OrganizationID:   rootScope.OrganizationID,
+		OrganizationSlug: rootScope.OrganizationSlug,
+	}}
+
+	err = filepath.WalkDir(rootPath, func(path string, entry fs.DirEntry, walkErr error) error {
+		if walkErr != nil {
+			return walkErr
+		}
+		if path == rootPath {
+			return nil
+		}
+
+		relPath, err := filepath.Rel(rootPath, path)
+		if err != nil {
+			return err
+		}
+		relPath = filepath.ToSlash(relPath)
+		if relPath == "." {
+			return nil
+		}
+
+		node, err := buildNode(rootPath, relPath, entry, rootScope)
+		if err != nil {
+			return err
+		}
+
+		nodes = append(nodes, node)
+		return nil
+	})
+	if err != nil {
+		return nil, fmt.Errorf("scan POSIX root: %w", err)
+	}
+
+	return nodes, nil
+}
+
+func loadRootScope(rootPath string) (Scope, error) {
+	settingsPath := filepath.Join(rootPath, "settings.json")
+	content, err := os.ReadFile(settingsPath)
+	if err != nil {
+		if errorsIsNotExist(err) {
+			return Scope{}, nil
+		}
+		return Scope{}, fmt.Errorf("read root settings.json: %w", err)
+	}
+
+	var payload map[string]any
+	if err := json.Unmarshal(content, &payload); err != nil {
+		return Scope{}, fmt.Errorf("decode root settings.json: %w", err)
+	}
+
+	installation, _ := payload["installation"].(map[string]any)
+	organization, _ := payload["organization"].(map[string]any)
+
+	return Scope{
+		InstallationID:  stringValue(installation["id"]),
+		OrganizationID:  stringValue(organization["id"]),
+		OrganizationSlug: stringValue(organization["slug"]),
+	}, nil
+}
+
+func buildNode(rootPath, relPath string, entry fs.DirEntry, rootScope Scope) (Node, error) {
+	scope := deriveScope(relPath, rootScope)
+	parentPath := projectionParentPath(relPath)
+	logicalType, fileRole := classifyPath(relPath, entry.IsDir())
+
+	node := Node{
+		Path:             relPath,
+		ParentPath:       parentPath,
+		Name:             entry.Name(),
+		Depth:            strings.Count(relPath, "/") + 1,
+		NodeKind:         NodeKindDirectory,
+		LogicalType:      logicalType,
+		FileRole:         fileRole,
+		InstallationID:   scope.InstallationID,
+		OrganizationID:   scope.OrganizationID,
+		OrganizationSlug: scope.OrganizationSlug,
+		DepartmentSlug:   scope.DepartmentSlug,
+		TeamSlug:         scope.TeamSlug,
+		ProjectSlug:      scope.ProjectSlug,
+		PersonalSlug:     scope.PersonalSlug,
+	}
+
+	if entry.IsDir() {
+		return node, nil
+	}
+
+	absPath := filepath.Join(rootPath, filepath.FromSlash(relPath))
+	content, err := os.ReadFile(absPath)
+	if err != nil {
+		return Node{}, fmt.Errorf("read POSIX file %s: %w", relPath, err)
+	}
+
+	hash := sha256.Sum256(content)
+	node.NodeKind = NodeKindFile
+	node.SizeBytes = int64(len(content))
+	node.Checksum = hex.EncodeToString(hash[:])
+
+	if strings.EqualFold(filepath.Ext(entry.Name()), ".json") {
+		var payload map[string]any
+		if err := json.Unmarshal(content, &payload); err == nil {
+			jsonContent, err := json.Marshal(payload)
+			if err != nil {
+				return Node{}, fmt.Errorf("remarshal POSIX file %s: %w", relPath, err)
+			}
+			node.ContentJSON = jsonContent
+			node.ResourceID = stringValue(payload["id"])
+			node.ResourceName = stringValue(payload["name"])
+			node.ResourceSlug = stringValue(payload["slug"])
+			if node.ResourceID == "" && fileRole == "settings" && logicalType == "tenant" {
+				installation, _ := payload["installation"].(map[string]any)
+				organization, _ := payload["organization"].(map[string]any)
+				node.ResourceID = stringValue(installation["id"])
+				node.ResourceName = stringValue(installation["name"])
+				node.InstallationID = stringValue(installation["id"])
+				node.OrganizationID = stringValue(organization["id"])
+				node.OrganizationSlug = firstNonEmpty(node.OrganizationSlug, stringValue(organization["slug"]))
+			}
+			if node.ResourceID == "" && fileRole == "users" {
+				node.ResourceName = firstNonEmpty(node.ResourceName, parentEntityName(logicalType, scope))
+			}
+		}
+	}
+
+	if node.ResourceSlug == "" {
+		node.ResourceSlug = inferredResourceSlug(logicalType, scope)
+	}
+
+	return node, nil
+}
+
+func deriveScope(relPath string, rootScope Scope) Scope {
+	scope := rootScope
+	parts := strings.Split(relPath, "/")
+	for _, part := range parts {
+		switch {
+		case strings.HasPrefix(part, "department-"):
+			scope.DepartmentSlug = strings.TrimPrefix(part, "department-")
+		case strings.HasPrefix(part, "team-"):
+			scope.TeamSlug = strings.TrimPrefix(part, "team-")
+		case strings.HasPrefix(part, "project-"):
+			scope.ProjectSlug = strings.TrimPrefix(part, "project-")
+		case strings.HasPrefix(part, "personal-"):
+			scope.PersonalSlug = strings.TrimPrefix(part, "personal-")
+		}
+	}
+	return scope
+}
+
+func classifyPath(relPath string, isDir bool) (logicalType, fileRole string) {
+	parts := strings.Split(relPath, "/")
+	name := parts[len(parts)-1]
+	if !isDir {
+		fileRole = strings.TrimSuffix(name, filepath.Ext(name))
+	}
+
+	hasChildrenAncestor := pathContainsSegment(parts, "children")
+	hasTreeAncestor := pathContainsSegment(parts, "tree")
+	parentName := ""
+	if len(parts) >= 2 {
+		parentName = parts[len(parts)-2]
+	}
+
+	switch {
+	case relPath == "settings.json":
+		return "tenant", "settings"
+	case relPath == "layout.json":
+		return "tenant", "layout"
+	case len(parts) >= 1 && parts[0] == "catalog":
+		if isDir {
+			if len(parts) == 1 {
+				return "catalog", ""
+			}
+			if len(parts) >= 2 && parts[1] == "packs" {
+				if len(parts) == 2 {
+					return "catalog_packs", ""
+				}
+				if len(parts) == 3 {
+					return "catalog_pack", ""
+				}
+				if len(parts) >= 4 && parts[3] == "entries" {
+					return "catalog_pack_entries", ""
+				}
+				return "catalog_entry", ""
+			}
+			if len(parts) >= 2 && parts[1] == "standalone" {
+				if len(parts) == 2 {
+					return "catalog_standalone", ""
+				}
+				return "catalog_entry", ""
+			}
+		}
+		return "catalog", fileRole
+	case len(parts) >= 2 && parts[0] == "departments" && strings.HasPrefix(parts[1], "department-"):
+		if isDir {
+			if len(parts) == 2 {
+				return "department", ""
+			}
+			if len(parts) == 3 && parts[2] == "teams" {
+				return "department_teams", ""
+			}
+			if len(parts) >= 4 && strings.HasPrefix(parts[3], "team-") {
+				return "team", ""
+			}
+		}
+		if len(parts) >= 4 && strings.HasPrefix(parts[3], "team-") {
+			return "team", fileRole
+		}
+		return "department", fileRole
+	case len(parts) >= 2 && parts[0] == "projects" && strings.HasPrefix(parts[1], "project-"):
+		if isDir {
+			if strings.HasPrefix(name, "project-") {
+				return "project", ""
+			}
+			if name == "children" {
+				return "project_children", ""
+			}
+			if name == "tree" {
+				return "project_tree", ""
+			}
+			if hasChildrenAncestor && strings.HasPrefix(name, "folder-") {
+				return "hierarchy_folder", ""
+			}
+			if hasTreeAncestor && strings.HasPrefix(name, "folder-") {
+				return "folder", ""
+			}
+			if hasTreeAncestor && strings.HasPrefix(name, "item-") {
+				return "item", ""
+			}
+		}
+		if hasChildrenAncestor && strings.HasPrefix(parentName, "folder-") {
+			return "hierarchy_folder", fileRole
+		}
+		if hasTreeAncestor {
+			if strings.HasPrefix(parentName, "item-") {
+				return "item", fileRole
+			}
+			if strings.HasPrefix(parentName, "folder-") {
+				return "folder", fileRole
+			}
+		}
+		return "project", fileRole
+	case len(parts) >= 1 && parts[0] == "users":
+		if isDir {
+			if len(parts) == 1 {
+				return "users", ""
+			}
+			if len(parts) == 2 && parts[1] == "personals" {
+				return "personals", ""
+			}
+			if len(parts) >= 3 && parts[1] == "personals" && strings.HasPrefix(parts[2], "personal-") {
+				return "personal", ""
+			}
+			if strings.Contains(relPath, "/tree/") || strings.HasSuffix(relPath, "/tree") {
+				if strings.HasPrefix(name, "folder-") {
+					return "folder", ""
+				}
+				if strings.HasPrefix(name, "item-") {
+					return "item", ""
+				}
+			}
+		}
+		if len(parts) >= 3 && parts[1] == "personals" && strings.HasPrefix(parts[2], "personal-") {
+			if strings.Contains(relPath, "/tree/") {
+				if strings.HasPrefix(parts[len(parts)-2], "item-") {
+					return "item", fileRole
+				}
+				if strings.HasPrefix(parts[len(parts)-2], "folder-") {
+					return "folder", fileRole
+				}
+			}
+			return "personal", fileRole
+		}
+		return "users", fileRole
+	default:
+		if isDir {
+			return "directory", ""
+		}
+		return "file", fileRole
+	}
+}
+
+func pathContainsSegment(parts []string, target string) bool {
+	for _, part := range parts {
+		if part == target {
+			return true
+		}
+	}
+	return false
+}
+
+func projectionParentPath(relPath string) *string {
+	if relPath == "" || relPath == rootProjectionPath {
+		return nil
+	}
+	parent := filepath.ToSlash(filepath.Dir(relPath))
+	if parent == "." || parent == "" {
+		root := rootProjectionPath
+		return &root
+	}
+	return &parent
+}
+
+func inferredResourceSlug(logicalType string, scope Scope) string {
+	switch logicalType {
+	case "department":
+		return scope.DepartmentSlug
+	case "team":
+		return scope.TeamSlug
+	case "project":
+		return scope.ProjectSlug
+	case "personal":
+		return scope.PersonalSlug
+	default:
+		return ""
+	}
+}
+
+func parentEntityName(logicalType string, scope Scope) string {
+	switch logicalType {
+	case "department":
+		return scope.DepartmentSlug
+	case "team":
+		return scope.TeamSlug
+	case "project":
+		return scope.ProjectSlug
+	case "personal":
+		return scope.PersonalSlug
+	default:
+		return ""
+	}
+}
+
+func stringValue(value any) string {
+	stringValue, _ := value.(string)
+	return strings.TrimSpace(stringValue)
+}
+
+func firstNonEmpty(values ...string) string {
+	for _, value := range values {
+		trimmed := strings.TrimSpace(value)
+		if trimmed != "" {
+			return trimmed
+		}
+	}
+	return ""
+}
+
+func summarizeNodes(nodes []Node) RebuildSummary {
+	summary := RebuildSummary{TotalNodes: len(nodes)}
+	for _, node := range nodes {
+		switch node.NodeKind {
+		case NodeKindDirectory:
+			summary.DirectoryCount++
+		case NodeKindFile:
+			summary.FileCount++
+		}
+	}
+	return summary
+}
+
+func errorsIsNotExist(err error) bool {
+	return err != nil && os.IsNotExist(err)
+}

Backend/internal/posixproj/projector_test.go

@@ -0,0 +1,226 @@
+package posixproj
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestScanRootBuildsProjectedNodesFromBootstrapShape(t *testing.T) {
+	root := filepath.Join(t.TempDir(), "POSIX")
+
+	mustMkdirAll(t, filepath.Join(root, "catalog", "packs"))
+	mustMkdirAll(t, filepath.Join(root, "catalog", "standalone"))
+	mustMkdirAll(t, filepath.Join(root, "departments", "department-primary-department", "teams", "team-primary-team"))
+	mustMkdirAll(t, filepath.Join(root, "projects", "project-primary-project", "children", "folder-design", "children", "project-web", "children"))
+	mustMkdirAll(t, filepath.Join(root, "projects", "project-primary-project", "children", "folder-design", "children", "project-web", "tree"))
+	mustMkdirAll(t, filepath.Join(root, "projects", "project-primary-project", "tree"))
+	mustMkdirAll(t, filepath.Join(root, "projects", "project-primary-project", "tree", "folder-docs", "item-roadmap"))
+	mustMkdirAll(t, filepath.Join(root, "users", "personals"))
+
+	mustWriteJSON(t, filepath.Join(root, "settings.json"), map[string]any{
+		"installation": map[string]any{
+			"id":             "installation-1",
+			"name":           "MangoPig",
+			"isBootstrapped": true,
+		},
+		"organization": map[string]any{
+			"id":   "org-1",
+			"name": "Primary Organization",
+			"slug": "primary-organization",
+		},
+	})
+	mustWriteJSON(t, filepath.Join(root, "layout.json"), map[string]any{
+		"type": "tenant-layout",
+		"home": map[string]any{"defaultProjectSlug": "primary-project"},
+	})
+	mustWriteJSON(t, filepath.Join(root, "departments", "department-primary-department", "settings.json"), map[string]any{
+		"id":   "dept-1",
+		"name": "Primary Department",
+		"slug": "primary-department",
+		"type": "department",
+	})
+	mustWriteJSON(t, filepath.Join(root, "departments", "department-primary-department", "users.json"), map[string]any{
+		"users": []map[string]any{{"id": "admin-1"}},
+	})
+	mustWriteJSON(t, filepath.Join(root, "departments", "department-primary-department", "teams", "team-primary-team", "settings.json"), map[string]any{
+		"id":   "team-1",
+		"name": "Primary Team",
+		"slug": "primary-team",
+		"type": "team",
+	})
+	mustWriteJSON(t, filepath.Join(root, "projects", "project-primary-project", "settings.json"), map[string]any{
+		"id":   "project-1",
+		"name": "Primary Project",
+		"slug": "primary-project",
+		"type": "project",
+	})
+	mustWriteJSON(t, filepath.Join(root, "projects", "project-primary-project", "home.json"), map[string]any{
+		"type":    "project-home",
+		"project": "primary-project",
+	})
+	mustWriteJSON(t, filepath.Join(root, "projects", "project-primary-project", "acl.json"), map[string]any{
+		"inherits": true,
+		"rules":    []any{},
+	})
+	mustWriteJSON(t, filepath.Join(root, "projects", "project-primary-project", "children", "folder-design", "folder.json"), map[string]any{
+		"name": "Design",
+		"slug": "design",
+	})
+	mustWriteJSON(t, filepath.Join(root, "projects", "project-primary-project", "children", "folder-design", "acl.json"), map[string]any{
+		"inherits": true,
+		"rules":    []any{},
+	})
+	mustWriteJSON(t, filepath.Join(root, "projects", "project-primary-project", "children", "folder-design", "children", "project-web", "settings.json"), map[string]any{
+		"id":   "project-2",
+		"name": "Web Project",
+		"slug": "web",
+		"type": "project",
+	})
+	mustWriteJSON(t, filepath.Join(root, "projects", "project-primary-project", "children", "folder-design", "children", "project-web", "home.json"), map[string]any{
+		"type":    "project-home",
+		"project": "web",
+	})
+	mustWriteJSON(t, filepath.Join(root, "projects", "project-primary-project", "children", "folder-design", "children", "project-web", "acl.json"), map[string]any{
+		"inherits": true,
+		"rules":    []any{},
+	})
+	mustWriteJSON(t, filepath.Join(root, "projects", "project-primary-project", "tree", "folder-docs", "folder.json"), map[string]any{
+		"name": "Docs",
+		"slug": "docs",
+	})
+	mustWriteJSON(t, filepath.Join(root, "projects", "project-primary-project", "tree", "folder-docs", "item-roadmap", "item.json"), map[string]any{
+		"id":   "item-1",
+		"name": "Roadmap",
+		"slug": "roadmap",
+		"type": "board",
+	})
+	mustWriteJSON(t, filepath.Join(root, "projects", "project-primary-project", "tree", "folder-docs", "item-roadmap", "schema.json"), map[string]any{
+		"type": "object",
+	})
+	mustWriteJSON(t, filepath.Join(root, "projects", "project-primary-project", "tree", "folder-docs", "item-roadmap", "data.json"), map[string]any{
+		"title": "Roadmap",
+	})
+	mustWriteJSON(t, filepath.Join(root, "users", "settings.json"), map[string]any{
+		"primaryAdminId": "admin-1",
+	})
+	mustWriteJSON(t, filepath.Join(root, "users", "data.json"), map[string]any{
+		"users": []map[string]any{{"id": "admin-1", "email": "ronald@example.com"}},
+	})
+
+	nodes, err := ScanRoot(root)
+	if err != nil {
+		t.Fatalf("ScanRoot() error = %v", err)
+	}
+
+	index := make(map[string]Node, len(nodes))
+	for _, node := range nodes {
+		index[node.Path] = node
+	}
+
+	rootNode, ok := index[rootProjectionPath]
+	if !ok {
+		t.Fatalf("expected synthetic root node")
+	}
+	if rootNode.LogicalType != "tenant_root" {
+		t.Fatalf("expected root logical type tenant_root, got %q", rootNode.LogicalType)
+	}
+	if rootNode.OrganizationSlug != "primary-organization" {
+		t.Fatalf("expected root organization slug primary-organization, got %q", rootNode.OrganizationSlug)
+	}
+
+	tenantSettings := index["settings.json"]
+	if tenantSettings.LogicalType != "tenant" || tenantSettings.FileRole != "settings" {
+		t.Fatalf("unexpected tenant settings classification: %#v", tenantSettings)
+	}
+	if tenantSettings.InstallationID != "installation-1" {
+		t.Fatalf("expected installation id installation-1, got %q", tenantSettings.InstallationID)
+	}
+
+	deptSettings := index["departments/department-primary-department/settings.json"]
+	if deptSettings.DepartmentSlug != "primary-department" {
+		t.Fatalf("expected department slug primary-department, got %q", deptSettings.DepartmentSlug)
+	}
+	if deptSettings.ResourceID != "dept-1" {
+		t.Fatalf("expected department resource id dept-1, got %q", deptSettings.ResourceID)
+	}
+
+	teamSettings := index["departments/department-primary-department/teams/team-primary-team/settings.json"]
+	if teamSettings.TeamSlug != "primary-team" {
+		t.Fatalf("expected team slug primary-team, got %q", teamSettings.TeamSlug)
+	}
+
+	projectSettings := index["projects/project-primary-project/settings.json"]
+	if projectSettings.ProjectSlug != "primary-project" {
+		t.Fatalf("expected project slug primary-project, got %q", projectSettings.ProjectSlug)
+	}
+	if projectSettings.ResourceName != "Primary Project" {
+		t.Fatalf("expected project resource name Primary Project, got %q", projectSettings.ResourceName)
+	}
+
+	projectTree := index["projects/project-primary-project/tree"]
+	if projectTree.LogicalType != "project_tree" || projectTree.NodeKind != NodeKindDirectory {
+		t.Fatalf("unexpected project tree node: %#v", projectTree)
+	}
+
+	projectChildren := index["projects/project-primary-project/children"]
+	if projectChildren.LogicalType != "project_children" || projectChildren.NodeKind != NodeKindDirectory {
+		t.Fatalf("unexpected project children node: %#v", projectChildren)
+	}
+
+	hierarchyFolder := index["projects/project-primary-project/children/folder-design"]
+	if hierarchyFolder.LogicalType != "hierarchy_folder" || hierarchyFolder.ProjectSlug != "primary-project" {
+		t.Fatalf("unexpected hierarchy folder node: %#v", hierarchyFolder)
+	}
+
+	hierarchyFolderACL := index["projects/project-primary-project/children/folder-design/acl.json"]
+	if hierarchyFolderACL.LogicalType != "hierarchy_folder" || hierarchyFolderACL.FileRole != "acl" {
+		t.Fatalf("unexpected hierarchy folder acl classification: %#v", hierarchyFolderACL)
+	}
+
+	childProjectSettings := index["projects/project-primary-project/children/folder-design/children/project-web/settings.json"]
+	if childProjectSettings.LogicalType != "project" || childProjectSettings.ProjectSlug != "web" {
+		t.Fatalf("unexpected child project classification: %#v", childProjectSettings)
+	}
+
+	treeFolder := index["projects/project-primary-project/tree/folder-docs"]
+	if treeFolder.LogicalType != "folder" || treeFolder.ProjectSlug != "primary-project" {
+		t.Fatalf("unexpected tree folder node: %#v", treeFolder)
+	}
+
+	treeItem := index["projects/project-primary-project/tree/folder-docs/item-roadmap/item.json"]
+	if treeItem.LogicalType != "item" || treeItem.FileRole != "item" {
+		t.Fatalf("unexpected tree item classification: %#v", treeItem)
+	}
+	if treeItem.ResourceSlug != "roadmap" {
+		t.Fatalf("expected tree item resource slug roadmap, got %#v", treeItem.ResourceSlug)
+	}
+
+	usersData := index["users/data.json"]
+	if usersData.LogicalType != "users" || usersData.FileRole != "data" {
+		t.Fatalf("unexpected users data classification: %#v", usersData)
+	}
+	if usersData.Checksum == "" || usersData.SizeBytes == 0 {
+		t.Fatalf("expected users/data.json checksum and size to be populated: %#v", usersData)
+	}
+}
+
+func mustMkdirAll(t *testing.T, path string) {
+	t.Helper()
+	if err := os.MkdirAll(path, 0o755); err != nil {
+		t.Fatalf("MkdirAll(%q) error = %v", path, err)
+	}
+}
+
+func mustWriteJSON(t *testing.T, path string, payload any) {
+	t.Helper()
+	bytes, err := json.MarshalIndent(payload, "", "  ")
+	if err != nil {
+		t.Fatalf("MarshalIndent(%q) error = %v", path, err)
+	}
+	bytes = append(bytes, '\n')
+	if err := os.WriteFile(path, bytes, 0o644); err != nil {
+		t.Fatalf("WriteFile(%q) error = %v", path, err)
+	}
+}

Commands/Local/Dev/backend.just

@@ -21,6 +21,10 @@ migrate-rebuild:
 migrate-status:
 	cd '{{backend_dir}}' && go run ./cmd/migrate status
 
+# Rebuild the POSIX-to-DB projection from the current POSIX root.
+posix-rebuild:
+	cd '{{backend_dir}}' && go run ./cmd/posix rebuild
+
 # Format backend Go source files.
 fmt:
 	cd '{{backend_dir}}' && gofmt -w ./cmd ./db ./internal

Documentation/POSIX-Structure.md

@@ -1,5 +1,7 @@
 # POSIX Structure
 
+[Filetree Link](https://tree.nathanfriend.com/?s=(%27optiUs!(%27fancy!Yue~fullPath!fbq~YailingSlash!Yue~rootDot!fbq)~R(%27R%27PJ%20or%20OrganizatiU%20%7Bqrver%7DM*46layout6cNlog7packs7*pack37A2*enYies75W5A_standbUe7WA6HwH30LZ2teamw5teamGL5Z6FwF30LKTC058T5C7XFG5LXKXTXC7XI7I05QG5BN2*8QG5BN6Z04_dN_pJw*pJGlayout2L*KI70%27)~vEiU!%271%27)*%20%200M52_*3-%3Cslug%3E4qttings5**69M*7%2F08VG*V259.jsUA5manifestBQ25*schema25*dCchildrenEersFprojectG305HdepartmentI*YeeJEUbKhome2L*42M%5CnNataQitemRsource!Tacl2UonVfolderW*app37X55YtrZusE_90balqsews0%01wqb_ZYXWVUTRQNMLKJIHGFECBA987654320*)
+
 ``` markdown
 Personal or Organization (server)/
 ├── settings.json
@@ -26,6 +28,18 @@ Personal or Organization (server)/
 │   └── project-<slug>/
 │       ├── settings.json
 │       ├── home.json
+│       ├── acl.json
+│       ├── children/
+│       │   └── folder-<slug>/
+│       │       ├── folder.json
+│       │       ├── acl.json
+│       │       └── children/
+│       │           └── project-<slug>/
+│       │               ├── settings.json
+│       │               ├── home.json
+│       │               ├── acl.json
+│       │               ├── children/
+│       │               └── tree/
 │       └── tree/
 │           ├── item-<slug>/
 │           │   ├── item.json

Frontend/src/components/shell/ProjectSelector/ProjectSelector.module.scss

@@ -192,13 +192,61 @@
 
 .treeSectionLabel {
   @include text-caption;
-  margin: 0 0 var(--space-2);
+  margin: 0;
   padding: 0 var(--space-3);
   color: var(--color-text-subtle);
   text-transform: uppercase;
   letter-spacing: 0.04em;
 }
 
+.treeSectionHeader {
+	display: flex;
+	align-items: center;
+	justify-content: space-between;
+	gap: var(--space-2);
+	margin-bottom: var(--space-2);
+	padding-right: var(--space-1);
+}
+
+.treeControls {
+	display: inline-flex;
+	align-items: center;
+	gap: var(--space-1);
+	flex-wrap: wrap;
+	justify-content: flex-end;
+}
+
+.treeControlButton {
+	display: inline-flex;
+	align-items: center;
+	justify-content: center;
+	width: calc(var(--control-size-md) - var(--space-1));
+	height: calc(var(--control-size-md) - var(--space-1));
+	@include text-caption;
+	padding: 0;
+	border: 1px solid color-mix(in srgb, var(--color-border) 46%, transparent);
+	border-radius: var(--radius-pill);
+	background: color-mix(in srgb, var(--color-surface) 95%, transparent);
+	color: var(--color-text-muted);
+	transition:
+		border-color 160ms var(--easing-standard),
+		background 160ms var(--easing-standard),
+		color 160ms var(--easing-standard);
+}
+
+.treeControlButton:hover,
+.treeControlButton:focus-visible {
+	border-color: color-mix(in srgb, var(--color-border-strong) 56%, transparent);
+	background: var(--color-surface-hover);
+	color: var(--color-text);
+	outline: none;
+}
+
+.treeControlButton:disabled {
+	opacity: 0.45;
+	cursor: default;
+}
+
 .treeList {
   list-style: none;
   display: grid;

Frontend/src/components/shell/ProjectSelector/ProjectSelector.tsx

@@ -1,9 +1,10 @@
 // Path: Frontend/src/components/shell/ProjectSelector/ProjectSelector.tsx
 
 import { For, Show, createEffect, createSignal, onCleanup, onMount, type JSX } from "solid-js";
-import { ChevronDown, ChevronRight, Folder, LayoutGrid } from "../../../lib/icons";
+import { ChevronDown, ChevronRight, Folder, LayoutGrid, ListCollapse, UnfoldVertical } from "../../../lib/icons";
 import { ProjectContextMenu } from "../ProjectContextMenu/ProjectContextMenu";
 import { useAppShellData } from "../data/app-shell.context";
+import { resolveAPIBase } from "../../../lib/api";
 import {
 	createProjectFolderTarget,
 	createProjectSurfaceTarget,
@@ -36,6 +37,20 @@ type ProjectLeafNode = {
 
 type ProjectTreeNode = ProjectFolderNode | ProjectLeafNode;
 
+type PersistedProjectFolderRecord = {
+	id: string;
+	label: string;
+	children: PersistedProjectFolderRecord[];
+};
+
+type ProjectFoldersResponse = {
+	data?: {
+		folders?: PersistedProjectFolderRecord[];
+	};
+	error?: string;
+	message?: string;
+};
+
 type PendingProjectFolderDraft = {
 	parentId: string | null;
 	depth: number;
@@ -61,17 +76,46 @@ type ProjectNodeLocation = {
 
 const LONG_PRESS_MS = 320;
 
-const createProjectFolderId = (): string => `project-folder-${Math.random().toString(36).slice(2, 10)}`;
-
 const getProjectTreeNodeId = (node: ProjectTreeNode): string =>
 	node.kind === "folder" ? node.id : node.item.id;
 
-const buildProjectTree = (items: readonly ProjectItem[]): ProjectTreeNode[] =>
+const buildPersistedFolderNodes = (folders: readonly PersistedProjectFolderRecord[] = []): ProjectTreeNode[] =>
-	items.map((item) => ({
+	folders.map((folder) => ({
-		kind: "project",
+		kind: "folder",
-		item,
+		id: folder.id,
+		label: folder.label,
+		children: buildPersistedFolderNodes(folder.children ?? []),
 	}));
 
+const buildProjectTree = (
+	items: readonly ProjectItem[],
+	folders: readonly PersistedProjectFolderRecord[] = [],
+): ProjectTreeNode[] => [
+	...items.map((item) => ({
+		kind: "project" as const,
+		item,
+	})),
+	...buildPersistedFolderNodes(folders),
+];
+
+const collectProjectFolderIds = (nodes: readonly ProjectTreeNode[]): string[] => {
+	const ids: string[] = [];
+
+	for (const node of nodes) {
+		if (node.kind !== "folder") {
+			continue;
+		}
+
+		ids.push(node.id);
+		ids.push(...collectProjectFolderIds(node.children));
+	}
+
+	return ids;
+};
+
+const readPersistedFolders = (body: ProjectFoldersResponse): PersistedProjectFolderRecord[] =>
+	Array.isArray(body.data?.folders) ? body.data.folders : [];
+
 const cloneProjectTreeNode = (node: ProjectTreeNode): ProjectTreeNode => {
 	if (node.kind === "project") {
 		return {
@@ -89,34 +133,6 @@ const cloneProjectTreeNode = (node: ProjectTreeNode): ProjectTreeNode => {
 	};
 };
 
-const insertProjectFolderNode = (
-	nodes: readonly ProjectTreeNode[],
-	parentId: string | null,
-	folder: ProjectFolderNode,
-): ProjectTreeNode[] => {
-	if (parentId === null) {
-		return [...nodes, folder];
-	}
-
-	return nodes.map((node) => {
-		if (node.kind !== "folder") {
-			return node;
-		}
-
-		if (node.id === parentId) {
-			return {
-				...node,
-				children: [...node.children, folder],
-			};
-		}
-
-		return {
-			...node,
-			children: insertProjectFolderNode(node.children, parentId, folder),
-		};
-	});
-};
-
 const findProjectNodeLocation = (
 	nodes: readonly ProjectTreeNode[],
 	nodeId: string,
@@ -336,6 +352,7 @@ const ProjectFolderBranch = (props: {
 	onSubmitPendingFolder: () => void;
 	onCancelPendingFolder: () => void;
 	dragState: ProjectDragState | null;
+	isTreeClickSuppressed: () => boolean;
 }): JSX.Element => (
 	<ul class={styles.treeList} role="list">
 		<Show when={props.nodes.length === 0 && props.pendingFolderDraft?.parentId !== props.parentId}>
@@ -368,18 +385,18 @@ const ProjectFolderBranch = (props: {
 									[styles.treeItemFolder]: true,
 									[styles.treeItemDragging]: isDraggedNode(),
 									[styles.treeItemDropBefore]: dropIntent() === "before",
-									[styles.treeItemDropAfter]: dropIntent() === "after",
+								[styles.treeItemDropAfter]: dropIntent() === "after",
-									[styles.treeItemDropInside]: dropIntent() === "inside",
+								[styles.treeItemDropInside]: dropIntent() === "inside",
-								}}
+							}}
-								style={{ "--tree-depth": String(props.depth) }}
+							style={{ "--tree-depth": String(props.depth) }}
-								aria-expanded={!isCollapsed()}
+							aria-expanded={!isCollapsed()}
-								onClick={() => {
+							onClick={() => {
-									if (props.dragState || suppressNextTreeClick()) {
+								if (props.dragState || props.isTreeClickSuppressed()) {
-										return;
+									return;
-									}
+								}
 
-									props.onToggleFolder(node.id);
+								props.onToggleFolder(node.id);
-								}}
+							}}
 								onContextMenu={(event): void => props.onOpenFolderMenu(event, node)}
 								onPointerDown={(event): void => props.onNodePointerDown(event, node.id)}
 								onPointerMove={(event): void =>
@@ -404,7 +421,7 @@ const ProjectFolderBranch = (props: {
 								</Show>
 							</button>
 
-							<Show when={!isCollapsed() && (node.children.length > 0 || props.pendingFolderDraft?.parentId === node.id)}>
+							<Show when={!isCollapsed() && ((node.children?.length ?? 0) > 0 || props.pendingFolderDraft?.parentId === node.id)}>
 								<ProjectFolderBranch
 									nodes={node.children}
 									depth={props.depth + 1}
@@ -423,6 +440,7 @@ const ProjectFolderBranch = (props: {
 									onSubmitPendingFolder={props.onSubmitPendingFolder}
 									onCancelPendingFolder={props.onCancelPendingFolder}
 									dragState={props.dragState}
+									isTreeClickSuppressed={props.isTreeClickSuppressed}
 								/>
 							</Show>
 						</li>
@@ -442,7 +460,7 @@ const ProjectFolderBranch = (props: {
 							}}
 							style={{ "--tree-depth": String(props.depth) }}
 							onClick={(): void => {
-								if (props.dragState || suppressNextTreeClick()) {
+								if (props.dragState || props.isTreeClickSuppressed()) {
 									return;
 								}
 
@@ -485,8 +503,9 @@ export const ProjectSelector = (props: ProjectSelectorProps): JSX.Element => {
 	const [selectedProject, setSelectedProject] = createSignal(appShellData.activeProject());
 	const [drawerTop, setDrawerTop] = createSignal<number>(0);
 	const [collapsedFolderIds, setCollapsedFolderIds] = createSignal<readonly string[]>([]);
+	const [persistedFolders, setPersistedFolders] = createSignal<readonly PersistedProjectFolderRecord[]>([]);
 	const [projectTreeNodes, setProjectTreeNodes] = createSignal<ProjectTreeNode[]>(
-		buildProjectTree(appShellData.projectItems()),
+		buildProjectTree(appShellData.projectItems(), persistedFolders()),
 	);
 	const [pendingFolderDraft, setPendingFolderDraft] = createSignal<PendingProjectFolderDraft | null>(null);
 	const [pendingFolderName, setPendingFolderName] = createSignal("");
@@ -497,6 +516,8 @@ export const ProjectSelector = (props: ProjectSelectorProps): JSX.Element => {
 	let contextMenuRef: HTMLDivElement | undefined;
 	let longPressTimer: number | undefined;
 	let suppressClickTimer: number | undefined;
+	let lastSelectedProjectId: string | null = null;
+	let latestPersistedFoldersRequest = 0;
 	const contextMenu = createProjectContextMenuController();
 
 	const clearLongPressTimer = (): void => {
@@ -527,16 +548,111 @@ export const ProjectSelector = (props: ProjectSelectorProps): JSX.Element => {
 		);
 	};
 
+	const syncProjectTree = (): void => {
+		const nextTree = buildProjectTree(appShellData.projectItems(), persistedFolders());
+		const availableFolderIds = new Set(collectProjectFolderIds(nextTree));
+
+		setProjectTreeNodes(nextTree);
+		setCollapsedFolderIds((current) => current.filter((folderId) => availableFolderIds.has(folderId)));
+	};
+
+	const resetProjectTreeInteractionState = (): void => {
+		setCollapsedFolderIds([]);
+		setPendingFolderDraft(null);
+		setPendingFolderName("");
+		setDragState(null);
+	};
+
+	const folderIds = (): string[] => collectProjectFolderIds(projectTreeNodes());
+
+	const expandAllFolders = (): void => {
+		setCollapsedFolderIds([]);
+	};
+
+	const collapseAllFolders = (): void => {
+		setCollapsedFolderIds(folderIds());
+	};
+
+	const totalFolderCount = (): number => folderIds().length;
+
+	const areAllFoldersCollapsed = (): boolean => {
+		const folderCount = totalFolderCount();
+
+		return folderCount > 0 && collapsedFolderIds().length >= folderCount;
+	};
+
+	const toggleAllFolders = (): void => {
+		if (areAllFoldersCollapsed()) {
+			expandAllFolders();
+			return;
+		}
+
+		collapseAllFolders();
+	};
+
+	const loadPersistedFolders = async (projectId: string): Promise<void> => {
+		const requestId = latestPersistedFoldersRequest + 1;
+		latestPersistedFoldersRequest = requestId;
+
+		if (!projectId) {
+			setPersistedFolders([]);
+			return;
+		}
+
+		try {
+			const response = await fetch(`${resolveAPIBase()}/projects/${projectId}/folders`, {
+				headers: {
+					Accept: "application/json",
+				},
+			});
+			const body = (await response.json()) as ProjectFoldersResponse;
+
+			if (requestId !== latestPersistedFoldersRequest) {
+				return;
+			}
+
+			if (!response.ok) {
+				throw new Error(body.message || "Failed to load project folders.");
+			}
+
+			setPersistedFolders(readPersistedFolders(body));
+		} catch (error) {
+			if (requestId !== latestPersistedFoldersRequest) {
+				return;
+			}
+
+			console.error(error);
+			setPersistedFolders([]);
+		}
+	};
+
 	createEffect(() => {
 		setSelectedProject(appShellData.activeProject());
 	});
 
 	createEffect(() => {
-		setProjectTreeNodes(buildProjectTree(appShellData.projectItems()));
+		syncProjectTree();
-		setCollapsedFolderIds([]);
+	});
-		setPendingFolderDraft(null);
+
-		setPendingFolderName("");
+	createEffect(() => {
-		setDragState(null);
+		const projectId = selectedProject().id;
+
+		if (lastSelectedProjectId === null) {
+			lastSelectedProjectId = projectId;
+			return;
+		}
+
+		if (projectId === lastSelectedProjectId) {
+			return;
+		}
+
+		lastSelectedProjectId = projectId;
+		resetProjectTreeInteractionState();
+	});
+
+	createEffect(() => {
+		const projectId = selectedProject().id;
+		void loadPersistedFolders(projectId);
 	});
 
 	onMount(() => {
@@ -668,7 +784,7 @@ export const ProjectSelector = (props: ProjectSelectorProps): JSX.Element => {
 		setPendingFolderDraft({ parentId, depth });
 	};
 
-	const submitPendingFolder = (): void => {
+	const submitPendingFolder = async (): Promise<void> => {
 		const name = pendingFolderName().trim();
 		const draft = pendingFolderDraft();
 
@@ -682,16 +798,31 @@ export const ProjectSelector = (props: ProjectSelectorProps): JSX.Element => {
 			return;
 		}
 
-		setProjectTreeNodes((current) =>
+		try {
-			insertProjectFolderNode(current, draft.parentId, {
+			const response = await fetch(`${resolveAPIBase()}/projects/${selectedProject().id}/folders`, {
-				kind: "folder",
+				method: "POST",
-				id: createProjectFolderId(),
+				headers: {
-				label: name,
+					Accept: "application/json",
-				children: [],
+					"Content-Type": "application/json",
-			}),
+				},
-		);
+				body: JSON.stringify({
-		setPendingFolderDraft(null);
+					name,
-		setPendingFolderName("");
+					parentFolderId: draft.parentId,
+				}),
+			});
+
+			const body = (await response.json()) as ProjectFoldersResponse;
+
+			if (!response.ok) {
+				throw new Error(body.message || "Failed to create project folder.");
+			}
+
+			setPersistedFolders(readPersistedFolders(body));
+			setPendingFolderDraft(null);
+			setPendingFolderName("");
+		} catch (error) {
+			console.error(error);
+		}
 	};
 
 	const cancelPendingFolder = (): void => {
@@ -724,6 +855,9 @@ export const ProjectSelector = (props: ProjectSelectorProps): JSX.Element => {
 		contextMenu.openMenu(event, createProjectSurfaceTarget("Projects"));
 	};
 
+	const treeControlLabel = (): string =>
+		areAllFoldersCollapsed() ? "Expand all folders" : "Collapse all folders";
+
 	const handleNodePointerDown = (event: PointerEvent, nodeId: string): void => {
 		if (event.button !== 0 || pendingFolderDraft()) {
 			return;
@@ -752,7 +886,12 @@ export const ProjectSelector = (props: ProjectSelectorProps): JSX.Element => {
 			return;
 		}
 
-		const bounds = event.currentTarget.getBoundingClientRect();
+		const currentTarget = event.currentTarget;
+		if (!(currentTarget instanceof HTMLElement)) {
+			return;
+		}
+
+		const bounds = currentTarget.getBoundingClientRect();
 		const relativeY = bounds.height <= 0 ? 0.5 : (event.clientY - bounds.top) / bounds.height;
 		let nextTarget: ProjectDragTarget;
 
@@ -861,9 +1000,29 @@ export const ProjectSelector = (props: ProjectSelectorProps): JSX.Element => {
 						onContextMenu={handleSurfaceContextMenu}
 					>
 						<div class={styles.drawerBody}>
-							<Show when={!props.compact}>
+							<div class={styles.treeSectionHeader}>
-								<div class={styles.treeSectionLabel}>Projects</div>
+								<Show when={!props.compact}>
-							</Show>
+									<div class={styles.treeSectionLabel}>Projects</div>
+								</Show>
+
+								<div class={styles.treeControls}>
+									<button
+										type="button"
+										class={styles.treeControlButton}
+										onClick={toggleAllFolders}
+										aria-label={treeControlLabel()}
+										title={treeControlLabel()}
+										disabled={totalFolderCount() === 0}
+									>
+										<Show
+											when={areAllFoldersCollapsed()}
+											fallback={<ListCollapse size={16} strokeWidth={2} />}
+										>
+											<UnfoldVertical size={16} strokeWidth={2} />
+										</Show>
+									</button>
+								</div>
+							</div>
 
 							<ProjectFolderBranch
 								nodes={projectTreeNodes()}
@@ -889,6 +1048,7 @@ export const ProjectSelector = (props: ProjectSelectorProps): JSX.Element => {
 								onSubmitPendingFolder={submitPendingFolder}
 								onCancelPendingFolder={cancelPendingFolder}
 								dragState={dragState()}
+								isTreeClickSuppressed={suppressNextTreeClick}
 							/>
 						</div>
 					</div>

Frontend/src/lib/icons/index.ts

@@ -10,6 +10,7 @@ export { default as Folder } from "lucide-solid/icons/folder";
 export { default as Home } from "lucide-solid/icons/house";
 export { default as Keyboard } from "lucide-solid/icons/keyboard";
 export { default as LayoutGrid } from "lucide-solid/icons/layout-grid";
+export { default as ListCollapse } from "lucide-solid/icons/list-collapse";
 export { default as LogOut } from "lucide-solid/icons/log-out";
 export { default as Moon } from "lucide-solid/icons/moon";
 export { default as Plus } from "lucide-solid/icons/plus";
@@ -18,5 +19,6 @@ export { default as Search } from "lucide-solid/icons/search";
 export { default as Settings } from "lucide-solid/icons/settings";
 export { default as Shield } from "lucide-solid/icons/shield";
 export { default as Sun } from "lucide-solid/icons/sun";
+export { default as UnfoldVertical } from "lucide-solid/icons/unfold-vertical";
 export { default as User } from "lucide-solid/icons/user";
 export { default as X } from "lucide-solid/icons/x";