Fix: Make bootstrap state backend authoritative

.gitignore

@@ -27,5 +27,3 @@ tmp/
 bin/
 
 .cgcignore
-
-POSIX/

Backend/cmd/posix/main.go

@@ -1,52 +0,0 @@
-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/000003_installation_name.sql

@@ -1,9 +0,0 @@
--- +goose Up
-
-ALTER TABLE installations
-  ADD COLUMN IF NOT EXISTS name TEXT NOT NULL DEFAULT '';
-
--- +goose Down
-
-ALTER TABLE installations
-  DROP COLUMN IF EXISTS name;

Backend/db/migrations/000004_posix_nodes.sql

@@ -1,45 +0,0 @@
--- +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

@@ -4,18 +4,13 @@ package bootstrap
 
 import (
 	"context"
-	"encoding/json"
 	"errors"
 	"fmt"
-	"os"
-	"path/filepath"
 	"strings"
-	"unicode"
 
 	"github.com/jackc/pgx/v5"
 
 	"moku-backend/internal/database"
-	"moku-backend/internal/posixproj"
 )
 
 const (
@@ -43,13 +38,10 @@ 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 {
-	db        *database.DB
+	db *database.DB
-	posixRoot string
 }
 
 type SaveInstanceInput struct {
@@ -60,7 +52,6 @@ type SaveInstanceInput struct {
 
 type SaveModeInput struct {
 	Mode string
-	Name string
 }
 
 type SaveAdminInput struct {
@@ -78,7 +69,6 @@ type SaveStructureInput struct {
 
 type InstallationRecord struct {
 	ID             string `json:"id"`
-	Name           string `json:"name"`
 	Mode           string `json:"mode"`
 	Access         string `json:"access"`
 	Protocol       string `json:"protocol"`
@@ -180,64 +170,15 @@ type namedRecord struct {
 	Slug string `json:"slug"`
 }
 
-type ProjectHierarchyFolderRecord struct {
+func NewService(db *database.DB) *Service {
-	ID       string                         `json:"id"`
+	return &Service{db: db}
-	Label    string                         `json:"label"`
-	Children []ProjectHierarchyFolderRecord `json:"children"`
-}
-
-type CreateProjectFolderInput struct {
-	ProjectID      string
-	ParentFolderID string
-	Name           string
-}
-
-type DeleteProjectFolderInput struct {
-	ProjectID string
-	FolderID  string
-}
-
-type RenameProjectFolderInput struct {
-	ProjectID string
-	FolderID  string
-	Name      string
-}
-
-type CreateProjectFolderResult struct {
-	ProjectID     string                         `json:"projectId"`
-	CreatedFolder ProjectHierarchyFolderRecord   `json:"createdFolder"`
-	Folders       []ProjectHierarchyFolderRecord `json:"folders"`
-}
-
-type DeleteProjectFolderResult struct {
-	ProjectID       string                         `json:"projectId"`
-	DeletedFolderID string                         `json:"deletedFolderId"`
-	Folders         []ProjectHierarchyFolderRecord `json:"folders"`
-}
-
-type RenameProjectFolderResult struct {
-	ProjectID        string                         `json:"projectId"`
-	PreviousFolderID string                         `json:"previousFolderId"`
-	RenamedFolder    ProjectHierarchyFolderRecord   `json:"renamedFolder"`
-	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)}
 }
 
 func (service *Service) SaveInstance(ctx context.Context, input SaveInstanceInput) (InstallationRecord, error) {
 	row := service.db.Pool.QueryRow(ctx, `
-		INSERT INTO installations (singleton, name, mode, access, protocol, host)
+		INSERT INTO installations (singleton, mode, access, protocol, host)
 		VALUES (
 			TRUE,
-			COALESCE((SELECT name FROM installations WHERE singleton = TRUE LIMIT 1), ''),
 			COALESCE((SELECT mode FROM installations WHERE singleton = TRUE LIMIT 1), 'personal'::instance_mode),
 			$1::instance_access,
 			$2::instance_protocol,
@@ -249,7 +190,7 @@ func (service *Service) SaveInstance(ctx context.Context, input SaveInstanceInpu
 			protocol = EXCLUDED.protocol,
 			host = EXCLUDED.host,
 			updated_at = NOW()
-		RETURNING id::text, name, mode::text, access::text, protocol::text, host, is_bootstrapped;
+		RETURNING id::text, mode::text, access::text, protocol::text, host, is_bootstrapped;
 	`, input.Access, input.Protocol, input.Host)
 
 	return scanInstallationRecord(row)
@@ -257,22 +198,20 @@ func (service *Service) SaveInstance(ctx context.Context, input SaveInstanceInpu
 
 func (service *Service) SaveMode(ctx context.Context, input SaveModeInput) (InstallationRecord, error) {
 	row := service.db.Pool.QueryRow(ctx, `
-		INSERT INTO installations (singleton, name, mode, access, protocol, host)
+		INSERT INTO installations (singleton, mode, access, protocol, host)
 		VALUES (
 			TRUE,
-			$2,
 			$1::instance_mode,
 			COALESCE((SELECT access FROM installations WHERE singleton = TRUE LIMIT 1), 'local'::instance_access),
 			COALESCE((SELECT protocol FROM installations WHERE singleton = TRUE LIMIT 1), 'http'::instance_protocol),
-			COALESCE((SELECT host FROM installations WHERE singleton = TRUE LIMIT 1), $3)
+			COALESCE((SELECT host FROM installations WHERE singleton = TRUE LIMIT 1), $2)
 		)
 		ON CONFLICT (singleton) DO UPDATE
 		SET
-			name = EXCLUDED.name,
 			mode = EXCLUDED.mode,
 			updated_at = NOW()
-		RETURNING id::text, name, mode::text, access::text, protocol::text, host, is_bootstrapped;
+		RETURNING id::text, mode::text, access::text, protocol::text, host, is_bootstrapped;
-	`, input.Mode, input.Name, defaultInstallationHost)
+	`, input.Mode, defaultInstallationHost)
 
 	return scanInstallationRecord(row)
 }
@@ -362,7 +301,7 @@ func (service *Service) SaveStructure(ctx context.Context, input SaveStructureIn
 
 	organizationName := strings.TrimSpace(input.OrganizationName)
 	if organizationName == "" {
-		organizationName = defaultRootOrganizationName(installation.Name, installation.Mode, installation.Host, admin.DisplayName)
+		organizationName = defaultRootOrganizationName(installation.Mode, installation.Host, admin.DisplayName)
 	}
 
 	organization, err := upsertNamedRecord(ctx, tx, `
@@ -461,14 +400,6 @@ func (service *Service) SaveStructure(ctx context.Context, input SaveStructureIn
 		return StructureRecord{}, err
 	}
 
-	if err := service.ensureBootstrapPOSIXSkeleton(installation, admin, organization, department, team, project); err != nil {
-		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,
@@ -511,7 +442,7 @@ func (service *Service) ResetDevelopmentState(ctx context.Context) error {
 
 func (service *Service) GetInstallation(ctx context.Context) (*InstallationRecord, error) {
 	record, err := scanInstallationRecord(service.db.Pool.QueryRow(ctx, `
-		SELECT id::text, name, mode::text, access::text, protocol::text, host, is_bootstrapped
+		SELECT id::text, mode::text, access::text, protocol::text, host, is_bootstrapped
 		FROM installations
 		WHERE singleton = TRUE
 		LIMIT 1;
@@ -666,7 +597,7 @@ func (service *Service) GetAppShellState(ctx context.Context) (AppShellState, er
 
 func scanInstallationRecord(row pgx.Row) (InstallationRecord, error) {
 	var record InstallationRecord
-	if err := row.Scan(&record.ID, &record.Name, &record.Mode, &record.Access, &record.Protocol, &record.Host, &record.IsBootstrapped); err != nil {
+	if err := row.Scan(&record.ID, &record.Mode, &record.Access, &record.Protocol, &record.Host, &record.IsBootstrapped); err != nil {
 		return InstallationRecord{}, err
 	}
 
@@ -845,220 +776,6 @@ 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) {
-	return service.getProjectHierarchyFoldersByRootPath(ctx, projectID, projectHierarchyRootPath)
-}
-
-func (service *Service) GetProjectTreeFolders(ctx context.Context, projectID string) ([]ProjectHierarchyFolderRecord, error) {
-	return service.getProjectHierarchyFoldersByRootPath(ctx, projectID, projectTreeRootPath)
-}
-
-func (service *Service) getProjectHierarchyFoldersByRootPath(
-	ctx context.Context,
-	projectID string,
-	rootPath func(projectSlug string) string,
-) ([]ProjectHierarchyFolderRecord, error) {
-	project, err := service.loadProjectByID(ctx, projectID)
-	if err != nil {
-		return nil, err
-	}
-
-	rootParentPath := rootPath(project.Slug)
-
-	rows, err := service.db.Pool.Query(ctx, `
-		SELECT
-			directories.path,
-			COALESCE(directories.parent_path, ''),
-			COALESCE(folder_meta.resource_name, directories.resource_name, '')
-		FROM posix_nodes AS directories
-		LEFT JOIN posix_nodes AS folder_meta
-		  ON folder_meta.path = directories.path || '/folder.json'
-		 AND folder_meta.node_kind = 'file'::posix_node_kind
-		WHERE directories.node_kind = 'directory'::posix_node_kind
-		  AND directories.logical_type = 'hierarchy_folder'
-		  AND directories.project_slug = $1
-		  AND directories.path LIKE $2
-		ORDER BY directories.depth ASC, directories.path ASC;
-	`, project.Slug, rootParentPath+"/%")
-	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, rootParentPath), nil
-}
-
-func (service *Service) CreateProjectFolder(ctx context.Context, input CreateProjectFolderInput) (CreateProjectFolderResult, error) {
-	return service.createProjectHierarchyFolder(ctx, input, projectHierarchyRootPath, service.createProjectHierarchyFolderOnDisk)
-}
-
-func (service *Service) CreateProjectTreeFolder(ctx context.Context, input CreateProjectFolderInput) (CreateProjectFolderResult, error) {
-	return service.createProjectHierarchyFolder(ctx, input, projectTreeRootPath, service.createProjectTreeFolderOnDisk)
-}
-
-func (service *Service) DeleteProjectFolder(ctx context.Context, input DeleteProjectFolderInput) (DeleteProjectFolderResult, error) {
-	return service.deleteProjectHierarchyFolder(ctx, input, projectHierarchyRootPath, service.deleteProjectHierarchyFolderOnDisk)
-}
-
-func (service *Service) DeleteProjectTreeFolder(ctx context.Context, input DeleteProjectFolderInput) (DeleteProjectFolderResult, error) {
-	return service.deleteProjectHierarchyFolder(ctx, input, projectTreeRootPath, service.deleteProjectTreeFolderOnDisk)
-}
-
-func (service *Service) RenameProjectFolder(ctx context.Context, input RenameProjectFolderInput) (RenameProjectFolderResult, error) {
-	return service.renameProjectHierarchyFolder(ctx, input, projectHierarchyRootPath, service.renameProjectHierarchyFolderOnDisk)
-}
-
-func (service *Service) RenameProjectTreeFolder(ctx context.Context, input RenameProjectFolderInput) (RenameProjectFolderResult, error) {
-	return service.renameProjectHierarchyFolder(ctx, input, projectTreeRootPath, service.renameProjectTreeFolderOnDisk)
-}
-
-func (service *Service) createProjectHierarchyFolder(
-	ctx context.Context,
-	input CreateProjectFolderInput,
-	rootPath func(projectSlug string) string,
-	createOnDisk func(projectSlug, parentFolderID, name string) (string, string, error),
-) (CreateProjectFolderResult, error) {
-	project, err := service.loadProjectByID(ctx, strings.TrimSpace(input.ProjectID))
-	if err != nil {
-		return CreateProjectFolderResult{}, err
-	}
-
-	createdPath, _, err := createOnDisk(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.getProjectHierarchyFoldersByRootPath(ctx, project.ID, rootPath)
-	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) deleteProjectHierarchyFolder(
-	ctx context.Context,
-	input DeleteProjectFolderInput,
-	rootPath func(projectSlug string) string,
-	deleteOnDisk func(projectSlug, folderID string) (string, error),
-) (DeleteProjectFolderResult, error) {
-	project, err := service.loadProjectByID(ctx, strings.TrimSpace(input.ProjectID))
-	if err != nil {
-		return DeleteProjectFolderResult{}, err
-	}
-
-	deletedFolderID, err := deleteOnDisk(project.Slug, input.FolderID)
-	if err != nil {
-		return DeleteProjectFolderResult{}, err
-	}
-
-	if err := posixproj.NewProjector(service.db, service.posixRoot).Rebuild(ctx); err != nil {
-		return DeleteProjectFolderResult{}, fmt.Errorf("rebuild POSIX projection: %w", err)
-	}
-
-	folders, err := service.getProjectHierarchyFoldersByRootPath(ctx, project.ID, rootPath)
-	if err != nil {
-		return DeleteProjectFolderResult{}, err
-	}
-
-	if _, found := findProjectHierarchyFolder(folders, deletedFolderID); found {
-		return DeleteProjectFolderResult{}, fmt.Errorf("deleted project folder still present in projection")
-	}
-
-	return DeleteProjectFolderResult{
-		ProjectID:       project.ID,
-		DeletedFolderID: deletedFolderID,
-		Folders:         folders,
-	}, nil
-}
-
-func (service *Service) renameProjectHierarchyFolder(
-	ctx context.Context,
-	input RenameProjectFolderInput,
-	rootPath func(projectSlug string) string,
-	renameOnDisk func(projectSlug, folderID, name string) (string, string, error),
-) (RenameProjectFolderResult, error) {
-	project, err := service.loadProjectByID(ctx, strings.TrimSpace(input.ProjectID))
-	if err != nil {
-		return RenameProjectFolderResult{}, err
-	}
-
-	previousFolderID, renamedFolderID, err := renameOnDisk(project.Slug, input.FolderID, input.Name)
-	if err != nil {
-		return RenameProjectFolderResult{}, err
-	}
-
-	if err := posixproj.NewProjector(service.db, service.posixRoot).Rebuild(ctx); err != nil {
-		return RenameProjectFolderResult{}, fmt.Errorf("rebuild POSIX projection: %w", err)
-	}
-
-	folders, err := service.getProjectHierarchyFoldersByRootPath(ctx, project.ID, rootPath)
-	if err != nil {
-		return RenameProjectFolderResult{}, err
-	}
-
-	renamedFolder, found := findProjectHierarchyFolder(folders, renamedFolderID)
-	if !found {
-		return RenameProjectFolderResult{}, fmt.Errorf("renamed project folder missing from projection")
-	}
-
-	if _, found := findProjectHierarchyFolder(folders, previousFolderID); found {
-		return RenameProjectFolderResult{}, fmt.Errorf("previous project folder path still present in projection")
-	}
-
-	return RenameProjectFolderResult{
-		ProjectID:        project.ID,
-		PreviousFolderID: previousFolderID,
-		RenamedFolder:    renamedFolder,
-		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
@@ -1085,7 +802,7 @@ func (service *Service) listWorkspaces(ctx context.Context) ([]WorkspaceRecord,
 
 func loadInstallation(ctx context.Context, tx pgx.Tx) (InstallationRecord, error) {
 	return scanInstallationRecord(tx.QueryRow(ctx, `
-		SELECT id::text, name, mode::text, access::text, protocol::text, host, is_bootstrapped
+		SELECT id::text, mode::text, access::text, protocol::text, host, is_bootstrapped
 		FROM installations
 		WHERE singleton = TRUE
 		LIMIT 1;
@@ -1112,7 +829,7 @@ func updateBootstrappedInstallation(ctx context.Context, tx pgx.Tx) (Installatio
 		UPDATE installations
 		SET is_bootstrapped = TRUE, bootstrapped_at = COALESCE(bootstrapped_at, NOW()), updated_at = NOW()
 		WHERE singleton = TRUE
-		RETURNING id::text, name, mode::text, access::text, protocol::text, host, is_bootstrapped;
+		RETURNING id::text, mode::text, access::text, protocol::text, host, is_bootstrapped;
 	`))
 }
 
@@ -1143,15 +860,10 @@ func upsertWorkspace(ctx context.Context, tx pgx.Tx, organizationID, name, slug,
 	return err
 }
 
-func defaultRootOrganizationName(installationName, mode, host, adminDisplayName string) string {
+func defaultRootOrganizationName(mode, host, adminDisplayName string) string {
-	trimmedInstallationName := strings.TrimSpace(installationName)
 	trimmedHost := strings.TrimSpace(host)
 	trimmedAdminDisplayName := strings.TrimSpace(adminDisplayName)
 
-	if trimmedInstallationName != "" {
-		return trimmedInstallationName
-	}
-
 	if strings.EqualFold(mode, defaultInstallationMode) {
 		if trimmedAdminDisplayName != "" {
 			return fmt.Sprintf("%s %s", trimmedAdminDisplayName, defaultPersonalServerSuffix)
@@ -1179,515 +891,3 @@ func personalHomeTitle(displayName string) string {
 
 	return fmt.Sprintf("%s's Home", trimmedDisplayName)
 }
-
-func (service *Service) ensureBootstrapPOSIXSkeleton(
-	installation InstallationRecord,
-	admin AdminSummary,
-	organization namedRecord,
-	department namedRecord,
-	team namedRecord,
-	project namedRecord,
-) error {
-	rootPath := strings.TrimSpace(service.posixRoot)
-	if rootPath == "" {
-		return nil
-	}
-
-	if err := os.MkdirAll(rootPath, 0o755); err != nil {
-		return fmt.Errorf("create POSIX root: %w", err)
-	}
-
-	if err := writeJSONFile(filepath.Join(rootPath, "settings.json"), map[string]any{
-		"installation": map[string]any{
-			"id":             installation.ID,
-			"name":           installation.Name,
-			"mode":           installation.Mode,
-			"access":         installation.Access,
-			"protocol":       installation.Protocol,
-			"host":           installation.Host,
-			"isBootstrapped": installation.IsBootstrapped,
-		},
-		"organization": map[string]any{
-			"id":   organization.ID,
-			"name": organization.Name,
-			"slug": organization.Slug,
-		},
-	}); err != nil {
-		return fmt.Errorf("write tenant settings.json: %w", err)
-	}
-
-	if err := writeJSONFile(filepath.Join(rootPath, "layout.json"), map[string]any{
-		"version": 1,
-		"type":    "tenant-layout",
-		"home": map[string]any{
-			"defaultProjectSlug": project.Slug,
-		},
-	}); err != nil {
-		return fmt.Errorf("write tenant layout.json: %w", err)
-	}
-
-	if err := os.MkdirAll(filepath.Join(rootPath, "catalog", "packs"), 0o755); err != nil {
-		return fmt.Errorf("create catalog packs root: %w", err)
-	}
-
-	if err := os.MkdirAll(filepath.Join(rootPath, "catalog", "standalone"), 0o755); err != nil {
-		return fmt.Errorf("create catalog standalone root: %w", err)
-	}
-
-	departmentPath := filepath.Join(rootPath, "departments", slugDir("department", department.Slug))
-	teamPath := filepath.Join(departmentPath, "teams", slugDir("team", team.Slug))
-	projectPath := filepath.Join(rootPath, "projects", slugDir("project", project.Slug))
-	usersPath := filepath.Join(rootPath, "users")
-
-	for _, dirPath := range []string{
-		departmentPath,
-		teamPath,
-		projectPath,
-		filepath.Join(projectPath, "children"),
-		filepath.Join(projectPath, "tree"),
-		filepath.Join(usersPath, "personals"),
-	} {
-		if err := os.MkdirAll(dirPath, 0o755); err != nil {
-			return fmt.Errorf("create POSIX directory %s: %w", dirPath, err)
-		}
-	}
-
-	if err := writeJSONFile(filepath.Join(departmentPath, "settings.json"), map[string]any{
-		"id":   department.ID,
-		"name": department.Name,
-		"slug": department.Slug,
-		"type": "department",
-	}); err != nil {
-		return fmt.Errorf("write department settings.json: %w", err)
-	}
-
-	if err := writeJSONFile(filepath.Join(departmentPath, "users.json"), map[string]any{
-		"owners": []map[string]string{{
-			"id":          admin.ID,
-			"email":       admin.Email,
-			"displayName": admin.DisplayName,
-		}},
-	}); err != nil {
-		return fmt.Errorf("write department users.json: %w", err)
-	}
-
-	if err := writeJSONFile(filepath.Join(teamPath, "settings.json"), map[string]any{
-		"id":   team.ID,
-		"name": team.Name,
-		"slug": team.Slug,
-		"type": "team",
-	}); err != nil {
-		return fmt.Errorf("write team settings.json: %w", err)
-	}
-
-	if err := writeJSONFile(filepath.Join(teamPath, "users.json"), map[string]any{
-		"owners": []map[string]string{{
-			"id":          admin.ID,
-			"email":       admin.Email,
-			"displayName": admin.DisplayName,
-		}},
-	}); err != nil {
-		return fmt.Errorf("write team users.json: %w", err)
-	}
-
-	if err := writeJSONFile(filepath.Join(projectPath, "settings.json"), map[string]any{
-		"id":   project.ID,
-		"name": project.Name,
-		"slug": project.Slug,
-		"type": "project",
-	}); err != nil {
-		return fmt.Errorf("write project settings.json: %w", err)
-	}
-
-	if err := writeJSONFile(filepath.Join(projectPath, "home.json"), map[string]any{
-		"type":    "project-home",
-		"project": project.Slug,
-		"widgets": []any{},
-	}); err != nil {
-		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 {
-		return fmt.Errorf("write users settings.json: %w", err)
-	}
-
-	if err := writeJSONFile(filepath.Join(usersPath, "data.json"), map[string]any{
-		"users": []map[string]string{{
-			"id":          admin.ID,
-			"email":       admin.Email,
-			"displayName": admin.DisplayName,
-		}},
-	}); err != nil {
-		return fmt.Errorf("write users data.json: %w", err)
-	}
-
-	return nil
-}
-
-func (service *Service) createProjectHierarchyFolderOnDisk(projectSlug, parentFolderID, name string) (string, string, error) {
-	return service.createProjectFolderOnDisk(projectSlug, parentFolderID, name, projectHierarchyRootPath)
-}
-
-func (service *Service) createProjectTreeFolderOnDisk(projectSlug, parentFolderID, name string) (string, string, error) {
-	return service.createProjectFolderOnDisk(projectSlug, parentFolderID, name, projectTreeRootPath)
-}
-
-func (service *Service) deleteProjectHierarchyFolderOnDisk(projectSlug, folderID string) (string, error) {
-	return service.deleteProjectFolderOnDisk(projectSlug, folderID, projectHierarchyRootPath)
-}
-
-func (service *Service) deleteProjectTreeFolderOnDisk(projectSlug, folderID string) (string, error) {
-	return service.deleteProjectFolderOnDisk(projectSlug, folderID, projectTreeRootPath)
-}
-
-func (service *Service) renameProjectHierarchyFolderOnDisk(projectSlug, folderID, name string) (string, string, error) {
-	return service.renameProjectFolderOnDisk(projectSlug, folderID, name, projectHierarchyRootPath)
-}
-
-func (service *Service) renameProjectTreeFolderOnDisk(projectSlug, folderID, name string) (string, string, error) {
-	return service.renameProjectFolderOnDisk(projectSlug, folderID, name, projectTreeRootPath)
-}
-
-func (service *Service) createProjectFolderOnDisk(
-	projectSlug, parentFolderID, name string,
-	rootPathBuilder func(projectSlug string) string,
-) (string, string, error) {
-	posixRoot := strings.TrimSpace(service.posixRoot)
-	if posixRoot == "" {
-		return "", "", fmt.Errorf("POSIX root is not configured")
-	}
-
-	trimmedName := strings.TrimSpace(name)
-	if trimmedName == "" {
-		return "", "", fmt.Errorf("folder name is required")
-	}
-
-	containerProjectionPath := rootPathBuilder(projectSlug)
-	parentDir := filepath.Join(posixRoot, filepath.FromSlash(containerProjectionPath))
-
-	if strings.TrimSpace(parentFolderID) != "" {
-		containerProjectionPath = filepath.ToSlash(filepath.Join(strings.TrimSpace(parentFolderID), "children"))
-		parentDir = filepath.Join(posixRoot, 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 (service *Service) deleteProjectFolderOnDisk(
-	projectSlug, folderID string,
-	rootPathBuilder func(projectSlug string) string,
-) (string, error) {
-	posixRoot := strings.TrimSpace(service.posixRoot)
-	if posixRoot == "" {
-		return "", fmt.Errorf("POSIX root is not configured")
-	}
-
-	trimmedFolderID := strings.TrimSpace(folderID)
-	if trimmedFolderID == "" {
-		return "", ErrProjectFolderNotFound
-	}
-
-	rootProjectionPath := rootPathBuilder(projectSlug)
-	folderProjectionPath := strings.TrimPrefix(filepath.ToSlash(filepath.Clean("/"+trimmedFolderID)), "/")
-	if folderProjectionPath == "." || folderProjectionPath == rootProjectionPath || !strings.HasPrefix(folderProjectionPath, rootProjectionPath+"/") {
-		return "", ErrProjectFolderNotFound
-	}
-
-	folderDir := filepath.Join(posixRoot, filepath.FromSlash(folderProjectionPath))
-	info, err := os.Stat(folderDir)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return "", ErrProjectFolderNotFound
-		}
-		return "", fmt.Errorf("stat project folder: %w", err)
-	}
-	if !info.IsDir() {
-		return "", ErrProjectFolderNotFound
-	}
-
-	if err := os.RemoveAll(folderDir); err != nil {
-		return "", fmt.Errorf("delete project folder: %w", err)
-	}
-
-	return folderProjectionPath, nil
-}
-
-func (service *Service) renameProjectFolderOnDisk(
-	projectSlug, folderID, name string,
-	rootPathBuilder func(projectSlug string) string,
-) (string, string, error) {
-	posixRoot := strings.TrimSpace(service.posixRoot)
-	if posixRoot == "" {
-		return "", "", fmt.Errorf("POSIX root is not configured")
-	}
-
-	trimmedFolderID := strings.TrimSpace(folderID)
-	if trimmedFolderID == "" {
-		return "", "", ErrProjectFolderNotFound
-	}
-
-	trimmedName := strings.TrimSpace(name)
-	if trimmedName == "" {
-		return "", "", fmt.Errorf("folder name is required")
-	}
-
-	rootProjectionPath := rootPathBuilder(projectSlug)
-	folderProjectionPath := strings.TrimPrefix(filepath.ToSlash(filepath.Clean("/"+trimmedFolderID)), "/")
-	if folderProjectionPath == "." || folderProjectionPath == rootProjectionPath || !strings.HasPrefix(folderProjectionPath, rootProjectionPath+"/") {
-		return "", "", ErrProjectFolderNotFound
-	}
-
-	folderDir := filepath.Join(posixRoot, filepath.FromSlash(folderProjectionPath))
-	info, err := os.Stat(folderDir)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return "", "", ErrProjectFolderNotFound
-		}
-		return "", "", fmt.Errorf("stat project folder: %w", err)
-	}
-	if !info.IsDir() {
-		return "", "", ErrProjectFolderNotFound
-	}
-
-	parentDir := filepath.Dir(folderDir)
-	baseSlug := normalizePOSIXSlug(trimmedName)
-	folderName := slugDir("folder", baseSlug)
-	folderSlug := baseSlug
-	destinationDir := filepath.Join(parentDir, folderName)
-
-	for attempt := 2; ; attempt += 1 {
-		if destinationDir == folderDir {
-			break
-		}
-
-		if _, err := os.Stat(destinationDir); os.IsNotExist(err) {
-			break
-		} else if err != nil {
-			return "", "", fmt.Errorf("stat candidate renamed project folder: %w", err)
-		}
-
-		folderSlug = fmt.Sprintf("%s-%d", baseSlug, attempt)
-		folderName = slugDir("folder", folderSlug)
-		destinationDir = filepath.Join(parentDir, folderName)
-	}
-
-	renamedProjectionPath := filepath.ToSlash(filepath.Join(filepath.Dir(folderProjectionPath), folderName))
-	if destinationDir != folderDir {
-		if err := os.Rename(folderDir, destinationDir); err != nil {
-			return "", "", fmt.Errorf("rename project folder: %w", err)
-		}
-	}
-
-	if err := writeJSONFile(filepath.Join(destinationDir, "folder.json"), map[string]any{
-		"name": trimmedName,
-		"slug": folderSlug,
-		"type": "folder",
-	}); err != nil {
-		return "", "", fmt.Errorf("write renamed project folder.json: %w", err)
-	}
-
-	return folderProjectionPath, renamedProjectionPath, 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 projectTreeRootPath(projectSlug string) string {
-	return filepath.ToSlash(filepath.Join("projects", slugDir("project", projectSlug), "tree"))
-}
-
-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 == "" {
-		return prefix
-	}
-
-	return fmt.Sprintf("%s-%s", prefix, trimmedSlug)
-}
-
-func writeJSONFile(path string, payload any) error {
-	parentDir := filepath.Dir(path)
-	if err := os.MkdirAll(parentDir, 0o755); err != nil {
-		return err
-	}
-
-	data, err := json.MarshalIndent(payload, "", "  ")
-	if err != nil {
-		return err
-	}
-
-	data = append(data, '\n')
-
-	return os.WriteFile(path, data, 0o644)
-}

Backend/internal/bootstrap/service_test.go

@@ -1,346 +0,0 @@
-package bootstrap
-
-import (
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestEnsureBootstrapPOSIXSkeletonInitializesEmptyRoot(t *testing.T) {
-	rootPath := filepath.Join(t.TempDir(), "POSIX")
-	t.Setenv("POSIX_ROOT", rootPath)
-
-	if _, err := os.Stat(rootPath); !os.IsNotExist(err) {
-		t.Fatalf("expected isolated POSIX root to start absent, got err=%v", err)
-	}
-
-	service := NewService(nil, os.Getenv("POSIX_ROOT"))
-
-	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)
-	}
-
-	requiredPaths := []string{
-		filepath.Join(rootPath, "settings.json"),
-		filepath.Join(rootPath, "layout.json"),
-		filepath.Join(rootPath, "catalog", "packs"),
-		filepath.Join(rootPath, "catalog", "standalone"),
-		filepath.Join(rootPath, "departments", "department-primary-department", "settings.json"),
-		filepath.Join(rootPath, "departments", "department-primary-department", "users.json"),
-		filepath.Join(rootPath, "departments", "department-primary-department", "teams", "team-primary-team", "settings.json"),
-		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"),
-		filepath.Join(rootPath, "users", "personals"),
-	}
-
-	for _, path := range requiredPaths {
-		if _, err := os.Stat(path); err != nil {
-			t.Fatalf("expected path to exist %s: %v", path, err)
-		}
-	}
-
-	settingsPayload := readJSONFileForTest[map[string]any](t, filepath.Join(rootPath, "settings.json"))
-	installationPayload, ok := settingsPayload["installation"].(map[string]any)
-	if !ok {
-		t.Fatalf("settings.json missing installation object: %#v", settingsPayload)
-	}
-	if installationPayload["name"] != "MangoPig" {
-		t.Fatalf("expected installation name MangoPig, got %#v", installationPayload["name"])
-	}
-	if installationPayload["isBootstrapped"] != true {
-		t.Fatalf("expected installation to be bootstrapped, got %#v", installationPayload["isBootstrapped"])
-	}
-
-	layoutPayload := readJSONFileForTest[map[string]any](t, filepath.Join(rootPath, "layout.json"))
-	homePayload, ok := layoutPayload["home"].(map[string]any)
-	if !ok {
-		t.Fatalf("layout.json missing home object: %#v", layoutPayload)
-	}
-	if homePayload["defaultProjectSlug"] != "primary-project" {
-		t.Fatalf("expected default project slug primary-project, got %#v", homePayload["defaultProjectSlug"])
-	}
-
-	projectSettings := readJSONFileForTest[map[string]any](t, filepath.Join(rootPath, "projects", "project-primary-project", "settings.json"))
-	if projectSettings["type"] != "project" {
-		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 TestCreateProjectTreeFolderOnDiskCreatesExpectedFolderShape(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.createProjectTreeFolderOnDisk("primary-project", "", "Docs")
-	if err != nil {
-		t.Fatalf("createProjectTreeFolderOnDisk root folder: %v", err)
-	}
-	if createdPath != "projects/project-primary-project/tree/folder-docs" {
-		t.Fatalf("unexpected created path: %s", createdPath)
-	}
-	if createdSlug != "docs" {
-		t.Fatalf("unexpected created slug: %s", createdSlug)
-	}
-
-	createdFolderPath := filepath.Join(rootPath, "projects", "project-primary-project", "tree", "folder-docs")
-	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)
-		}
-	}
-
-	nestedPath, nestedSlug, err := service.createProjectTreeFolderOnDisk("primary-project", createdPath, "Research")
-	if err != nil {
-		t.Fatalf("createProjectTreeFolderOnDisk nested folder: %v", err)
-	}
-	if nestedPath != "projects/project-primary-project/tree/folder-docs/children/folder-research" {
-		t.Fatalf("unexpected nested path: %s", nestedPath)
-	}
-	if nestedSlug != "research" {
-		t.Fatalf("unexpected nested slug: %s", nestedSlug)
-	}
-}
-
-func TestRenameProjectHierarchyFolderOnDiskRenamesFolderShape(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, _, err := service.createProjectHierarchyFolderOnDisk("primary-project", "", "Design System")
-	if err != nil {
-		t.Fatalf("createProjectHierarchyFolderOnDisk root folder: %v", err)
-	}
-
-	nestedPath, _, err := service.createProjectHierarchyFolderOnDisk("primary-project", createdPath, "Research")
-	if err != nil {
-		t.Fatalf("createProjectHierarchyFolderOnDisk nested folder: %v", err)
-	}
-
-	previousPath, renamedPath, err := service.renameProjectHierarchyFolderOnDisk("primary-project", createdPath, "Platform Design")
-	if err != nil {
-		t.Fatalf("renameProjectHierarchyFolderOnDisk: %v", err)
-	}
-	if previousPath != createdPath {
-		t.Fatalf("expected previous path %s, got %s", createdPath, previousPath)
-	}
-	if renamedPath != "projects/project-primary-project/children/folder-platform-design" {
-		t.Fatalf("unexpected renamed path: %s", renamedPath)
-	}
-
-	if _, err := os.Stat(filepath.Join(rootPath, filepath.FromSlash(createdPath))); !os.IsNotExist(err) {
-		t.Fatalf("expected previous folder path to be gone, got err=%v", err)
-	}
-
-	renamedFolderPath := filepath.Join(rootPath, filepath.FromSlash(renamedPath))
-	if _, err := os.Stat(filepath.Join(renamedFolderPath, "children", filepath.Base(nestedPath))); err != nil {
-		t.Fatalf("expected nested child folder to move with renamed parent: %v", err)
-	}
-
-	folderPayload := readJSONFileForTest[map[string]any](t, filepath.Join(renamedFolderPath, "folder.json"))
-	if folderPayload["name"] != "Platform Design" {
-		t.Fatalf("expected renamed folder name Platform Design, got %#v", folderPayload["name"])
-	}
-	if folderPayload["slug"] != "platform-design" {
-		t.Fatalf("expected renamed folder slug platform-design, got %#v", folderPayload["slug"])
-	}
-	if folderPayload["type"] != "folder" {
-		t.Fatalf("expected renamed folder type folder, got %#v", folderPayload["type"])
-	}
-}
-
-func TestRenameProjectTreeFolderOnDiskRenamesFolderShape(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, _, err := service.createProjectTreeFolderOnDisk("primary-project", "", "Docs")
-	if err != nil {
-		t.Fatalf("createProjectTreeFolderOnDisk root folder: %v", err)
-	}
-
-	previousPath, renamedPath, err := service.renameProjectTreeFolderOnDisk("primary-project", createdPath, "Specifications")
-	if err != nil {
-		t.Fatalf("renameProjectTreeFolderOnDisk: %v", err)
-	}
-	if previousPath != createdPath {
-		t.Fatalf("expected previous path %s, got %s", createdPath, previousPath)
-	}
-	if renamedPath != "projects/project-primary-project/tree/folder-specifications" {
-		t.Fatalf("unexpected renamed path: %s", renamedPath)
-	}
-
-	folderPayload := readJSONFileForTest[map[string]any](t, filepath.Join(rootPath, filepath.FromSlash(renamedPath), "folder.json"))
-	if folderPayload["name"] != "Specifications" {
-		t.Fatalf("expected renamed folder name Specifications, got %#v", folderPayload["name"])
-	}
-	if folderPayload["slug"] != "specifications" {
-		t.Fatalf("expected renamed folder slug specifications, got %#v", folderPayload["slug"])
-	}
-}
-
-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()
-
-	data, err := os.ReadFile(path)
-	if err != nil {
-		t.Fatalf("read %s: %v", path, err)
-	}
-
-	var payload T
-	if err := json.Unmarshal(data, &payload); err != nil {
-		t.Fatalf("unmarshal %s: %v", path, err)
-	}
-
-	return payload
-}

Backend/internal/config/config.go

@@ -17,7 +17,6 @@ type Config struct {
 	APIPort         string
 	PostgresURL     string
 	ValkeyURL       string
-	POSIXRoot       string
 	ShutdownTimeout time.Duration
 }
 
@@ -30,7 +29,6 @@ func Load() *Config {
 		APIPort:         getEnv("BACKEND_API_PORT", "8081"),
 		PostgresURL:     getEnv("DATABASE_URL", "postgres://moku:moku_dev_password@localhost:5432/moku?sslmode=disable"),
 		ValkeyURL:       getEnv("VALKEY_URL", "redis://localhost:6379/0"),
-		POSIXRoot:       getEnv("POSIX_ROOT", "../POSIX"),
 		ShutdownTimeout: getDurationEnv("BACKEND_SHUTDOWN_TIMEOUT", 10*time.Second),
 	}
 }

Backend/internal/httpx/api_bootstrap_routes.go

@@ -20,7 +20,6 @@ type bootstrapInstanceStepRequest struct {
 
 type bootstrapModeStepRequest struct {
 	Mode string `json:"mode"`
-	Name string `json:"name"`
 }
 
 type bootstrapAdminStepRequest struct {
@@ -235,19 +234,13 @@ func (routes apiRoutes) handleBootstrapModeStep(w http.ResponseWriter, r *http.R
 		return
 	}
 	payload.Mode = strings.ToLower(strings.TrimSpace(payload.Mode))
-	payload.Name = strings.TrimSpace(payload.Name)
 
 	if payload.Mode != "personal" && payload.Mode != "organizational" {
 		WriteError(w, http.StatusBadRequest, RequestIDFromContext(r.Context()), "invalid_request", "Mode must be either 'personal' or 'organizational'.")
 		return
 	}
 
-	if payload.Name == "" {
+	record, err := routes.bootstrapService().SaveMode(r.Context(), bootstrapservice.SaveModeInput{Mode: payload.Mode})
-		WriteError(w, http.StatusBadRequest, RequestIDFromContext(r.Context()), "invalid_request", "Name is required.")
-		return
-	}
-
-	record, err := routes.bootstrapService().SaveMode(r.Context(), bootstrapservice.SaveModeInput{Mode: payload.Mode, Name: payload.Name})
 	if err != nil {
 		routes.writeBootstrapPersistenceError(w, r, err)
 		return
@@ -341,7 +334,7 @@ func (routes apiRoutes) handleBootstrapStructureStep(w http.ResponseWriter, r *h
 }
 
 func (routes apiRoutes) bootstrapService() *bootstrapservice.Service {
-	return bootstrapservice.NewService(routes.cfg.Database, routes.cfg.Config.POSIXRoot)
+	return bootstrapservice.NewService(routes.cfg.Database)
 }
 
 func (routes apiRoutes) writeBootstrapStepResponse(w http.ResponseWriter, status int, step string, payload any) {
@@ -363,11 +356,7 @@ func (routes apiRoutes) writeBootstrapPersistenceError(w http.ResponseWriter, r
 		WriteError(w, http.StatusConflict, RequestIDFromContext(r.Context()), "bootstrap_prerequisite_missing", err.Error())
 	default:
 		routes.cfg.Logger.Error("persist bootstrap step", "error", err, "path", r.URL.Path)
-		message := "Failed to persist bootstrap data."
+		WriteError(w, http.StatusInternalServerError, RequestIDFromContext(r.Context()), "bootstrap_persist_failed", "Failed to persist bootstrap data.")
-		if routes.cfg.Config.IsDevelopment() {
-			message = message + " " + err.Error()
-		}
-		WriteError(w, http.StatusInternalServerError, RequestIDFromContext(r.Context()), "bootstrap_persist_failed", message)
 	}
 }
 

Backend/internal/httpx/api_project_routes.go

@@ -1,365 +0,0 @@
-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"`
-}
-
-type renameProjectFolderRequest struct {
-	FolderID string `json:"folderId"`
-	Name     string `json:"name"`
-}
-
-type deleteProjectFolderRequest struct {
-	FolderID string `json:"folderId"`
-}
-
-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, "load")
-		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, "persist")
-		return
-	}
-
-	WriteJSON(w, http.StatusCreated, map[string]any{
-		"data": result,
-		"meta": map[string]any{
-			"resource":  "project-folder-create",
-			"persisted": true,
-		},
-	})
-}
-
-func (routes apiRoutes) handleDeleteProjectFolder(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 := decodeDeleteProjectFolderRequest(r)
-	if strings.TrimSpace(payload.FolderID) == "" {
-		WriteError(w, http.StatusBadRequest, RequestIDFromContext(r.Context()), "invalid_request", "Folder ID is required.")
-		return
-	}
-
-	result, err := routes.bootstrapService().DeleteProjectFolder(r.Context(), bootstrapservice.DeleteProjectFolderInput{
-		ProjectID: projectID,
-		FolderID:  payload.FolderID,
-	})
-	if err != nil {
-		routes.writeProjectFolderError(w, r, err, "delete")
-		return
-	}
-
-	WriteJSON(w, http.StatusOK, map[string]any{
-		"data": result,
-		"meta": map[string]any{
-			"resource":  "project-folder-delete",
-			"persisted": true,
-		},
-	})
-}
-
-func (routes apiRoutes) handleRenameProjectFolder(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 := decodeRenameProjectFolderRequest(w, r)
-	if !ok {
-		return
-	}
-
-	payload.FolderID = strings.TrimSpace(payload.FolderID)
-	payload.Name = strings.TrimSpace(payload.Name)
-	if payload.FolderID == "" {
-		WriteError(w, http.StatusBadRequest, RequestIDFromContext(r.Context()), "invalid_request", "Folder ID is required.")
-		return
-	}
-	if payload.Name == "" {
-		WriteError(w, http.StatusBadRequest, RequestIDFromContext(r.Context()), "invalid_request", "Folder name is required.")
-		return
-	}
-
-	result, err := routes.bootstrapService().RenameProjectFolder(r.Context(), bootstrapservice.RenameProjectFolderInput{
-		ProjectID: projectID,
-		FolderID:  payload.FolderID,
-		Name:      payload.Name,
-	})
-	if err != nil {
-		routes.writeProjectFolderError(w, r, err, "rename")
-		return
-	}
-
-	WriteJSON(w, http.StatusOK, map[string]any{
-		"data": result,
-		"meta": map[string]any{
-			"resource":  "project-folder-rename",
-			"persisted": true,
-		},
-	})
-}
-
-func (routes apiRoutes) handleProjectTreeFolders(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().GetProjectTreeFolders(r.Context(), projectID)
-	if err != nil {
-		routes.writeProjectFolderError(w, r, err, "load")
-		return
-	}
-
-	WriteJSON(w, http.StatusOK, map[string]any{
-		"data": map[string]any{
-			"projectId": projectID,
-			"folders":   folders,
-		},
-		"meta": map[string]any{
-			"resource": "project-tree-folders",
-		},
-	})
-}
-
-func (routes apiRoutes) handleCreateProjectTreeFolder(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().CreateProjectTreeFolder(r.Context(), bootstrapservice.CreateProjectFolderInput{
-		ProjectID:      projectID,
-		ParentFolderID: payload.ParentFolderID,
-		Name:           payload.Name,
-	})
-	if err != nil {
-		routes.writeProjectFolderError(w, r, err, "persist")
-		return
-	}
-
-	WriteJSON(w, http.StatusCreated, map[string]any{
-		"data": result,
-		"meta": map[string]any{
-			"resource":  "project-tree-folder-create",
-			"persisted": true,
-		},
-	})
-}
-
-func (routes apiRoutes) handleDeleteProjectTreeFolder(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 := decodeDeleteProjectFolderRequest(r)
-	if strings.TrimSpace(payload.FolderID) == "" {
-		WriteError(w, http.StatusBadRequest, RequestIDFromContext(r.Context()), "invalid_request", "Folder ID is required.")
-		return
-	}
-
-	result, err := routes.bootstrapService().DeleteProjectTreeFolder(r.Context(), bootstrapservice.DeleteProjectFolderInput{
-		ProjectID: projectID,
-		FolderID:  payload.FolderID,
-	})
-	if err != nil {
-		routes.writeProjectFolderError(w, r, err, "delete")
-		return
-	}
-
-	WriteJSON(w, http.StatusOK, map[string]any{
-		"data": result,
-		"meta": map[string]any{
-			"resource":  "project-tree-folder-delete",
-			"persisted": true,
-		},
-	})
-}
-
-func (routes apiRoutes) handleRenameProjectTreeFolder(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 := decodeRenameProjectFolderRequest(w, r)
-	if !ok {
-		return
-	}
-
-	payload.FolderID = strings.TrimSpace(payload.FolderID)
-	payload.Name = strings.TrimSpace(payload.Name)
-	if payload.FolderID == "" {
-		WriteError(w, http.StatusBadRequest, RequestIDFromContext(r.Context()), "invalid_request", "Folder ID is required.")
-		return
-	}
-	if payload.Name == "" {
-		WriteError(w, http.StatusBadRequest, RequestIDFromContext(r.Context()), "invalid_request", "Folder name is required.")
-		return
-	}
-
-	result, err := routes.bootstrapService().RenameProjectTreeFolder(r.Context(), bootstrapservice.RenameProjectFolderInput{
-		ProjectID: projectID,
-		FolderID:  payload.FolderID,
-		Name:      payload.Name,
-	})
-	if err != nil {
-		routes.writeProjectFolderError(w, r, err, "rename")
-		return
-	}
-
-	WriteJSON(w, http.StatusOK, map[string]any{
-		"data": result,
-		"meta": map[string]any{
-			"resource":  "project-tree-folder-rename",
-			"persisted": true,
-		},
-	})
-}
-
-func (routes apiRoutes) writeProjectFolderError(w http.ResponseWriter, r *http.Request, err error, operation string) {
-	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(operation+" project folder", "error", err, "path", r.URL.Path)
-		message := "Failed to " + operation + " project folder."
-		if routes.cfg.Config.IsDevelopment() {
-			message = message + " " + err.Error()
-		}
-		WriteError(w, http.StatusInternalServerError, RequestIDFromContext(r.Context()), "project_folder_"+operation+"_failed", message)
-	}
-}
-
-func decodeDeleteProjectFolderRequest(r *http.Request) deleteProjectFolderRequest {
-	return deleteProjectFolderRequest{
-		FolderID: strings.TrimSpace(r.URL.Query().Get("folderId")),
-	}
-}
-
-func decodeRenameProjectFolderRequest(w http.ResponseWriter, r *http.Request) (renameProjectFolderRequest, bool) {
-	var payload renameProjectFolderRequest
-
-	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
-}
-
-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,16 +33,6 @@ 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)
-			projectRouter.Patch("/folders", routes.handleRenameProjectFolder)
-			projectRouter.Delete("/folders", routes.handleDeleteProjectFolder)
-			projectRouter.Get("/tree/folders", routes.handleProjectTreeFolders)
-			projectRouter.Post("/tree/folders", routes.handleCreateProjectTreeFolder)
-			projectRouter.Patch("/tree/folders", routes.handleRenameProjectTreeFolder)
-			projectRouter.Delete("/tree/folders", routes.handleDeleteProjectTreeFolder)
-		})
 
 		if routes.cfg.Config.IsDevelopment() {
 			apiRouter.Post("/dev/bootstrap/reset", routes.handleDevelopmentBootstrapReset)

Backend/internal/posixproj/projector.go

@@ -1,553 +0,0 @@
-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 "hierarchy_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 "hierarchy_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

@@ -1,232 +0,0 @@
-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", "children"))
-	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 != "hierarchy_folder" || treeFolder.ProjectSlug != "primary-project" {
-		t.Fatalf("unexpected tree folder node: %#v", treeFolder)
-	}
-
-	treeFolderACL := index["projects/project-primary-project/tree/folder-docs/folder.json"]
-	if treeFolderACL.LogicalType != "hierarchy_folder" || treeFolderACL.FileRole != "folder" {
-		t.Fatalf("unexpected tree folder file classification: %#v", treeFolderACL)
-	}
-
-	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

@@ -9,22 +9,18 @@ migrate-up:
 migrate-down:
 	cd '{{backend_dir}}' && go run ./cmd/migrate down
 
-# Reset all embedded database migrations.
+# Reset all embedded database migrations and reapply from scratch.
 migrate-reset:
 	cd '{{backend_dir}}' && go run ./cmd/migrate reset
 
-# Reset embedded database migrations and apply them again from scratch.
-migrate-rebuild:
-	cd '{{backend_dir}}' && go run ./cmd/migrate reset && go run ./cmd/migrate up
-
 # Show the embedded database migration status.
 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
+
+# Run backend test suite.
+test:
+	cd '{{backend_dir}}' && go test ./...

Commands/Test/backend.just

@@ -1,11 +0,0 @@
-project_root := justfile_directory()
-backend_dir := project_root + "/Backend"
-
-# Run the full backend test suite.
-[default]
-all:
-	cd '{{backend_dir}}' && go test ./...
-
-# Run the isolated POSIX bootstrap smoke test.
-posix-bootstrap:
-	cd '{{backend_dir}}' && go test ./internal/bootstrap -run TestEnsureBootstrapPOSIXSkeletonInitializesEmptyRoot -count=1 -v

Commands/Test/mod.just

@@ -1 +0,0 @@
-mod backend

Docker/docker-compose.local.dev.yaml

@@ -6,7 +6,6 @@ x-backend-service: &backend-service
   environment:
     DATABASE_URL: postgres://moku:moku_dev_password@postgres:5432/moku?sslmode=disable
     VALKEY_URL: redis://valkey:6379/0
-    POSIX_ROOT: /posix
   depends_on:
     postgres:
       condition: service_healthy
@@ -14,7 +13,6 @@ x-backend-service: &backend-service
       condition: service_healthy
   volumes:
     - ../Backend:/app
-    - ../POSIX:/posix
     - moku_work_backend_go_pkg:/go/pkg/mod
     - moku_work_backend_go_build:/root/.cache/go-build
 

Docker/docker-compose.local.prod.yaml

@@ -5,14 +5,11 @@ x-backend-service: &backend-service
   environment:
     DATABASE_URL: postgres://moku:moku_dev_password@postgres:5432/moku?sslmode=disable
     VALKEY_URL: redis://valkey:6379/0
-    POSIX_ROOT: /posix
   depends_on:
     postgres:
       condition: service_healthy
     valkey:
       condition: service_healthy
-  volumes:
-    - ../POSIX:/posix
 
 services:
   postgres:

Documentation/POSIX-Structure.md

@@ -1,75 +0,0 @@
-# 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
-├── layout.json
-├── catalog/
-│   ├── packs/
-│   │   └── pack-<slug>/
-│   │       ├── manifest.json
-│   │       └── entries/
-│   │           └── app-<slug>/
-│   │               └── manifest.json
-│   └── standalone/
-│       └── app-<slug>/
-│           └── manifest.json
-├── departments/
-│   └── department-<slug>/
-│       ├── settings.json
-│       ├── users.json
-│       └── teams/
-│           └── team-<slug>/
-│               ├── settings.json
-│               └── users.json
-├── projects/
-│   └── 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
-│           │   ├── schema.json
-│           │   └── data.json
-│           └── folder-<slug>/
-│               ├── folder.json
-│               └── item-<slug>/
-│                   ├── item.json
-│                   ├── schema.json
-│                   └── data.json
-└── users/
-    ├── settings.json
-    ├── data.json
-    └── personals/
-        └── personal-<slug>/
-            ├── layout.json
-            ├── settings.json
-            ├── home.json
-            └── tree/
-```
-
-## File Responsibilities
-
-- `settings.json` — Metadata and presentation config for the thing, such as display name, icon, description, and simple settings.
-- `layout.json` — Layout configuration for the current server or personal space.
-- `home.json` — Home surface configuration, such as widgets, sections, and how they are arranged.
-- `folder.json` — Metadata for a folder node in a tree.
-- `item.json` — Instance metadata for a created item, including what it is and how it should behave.
-- `schema.json` — The structure expected by that item's data.
-- `data.json` — The actual content or state data for that item.
-- `manifest.json` — Catalog definition metadata, including versioning, description, and capabilities for reusable apps or entries.
-- `users.json` — User membership or assignment data for departments and teams.

Documentation/TODO.md

@@ -4,149 +4,87 @@
 
 ### Version 0.1.0
 
-**Goal:** Finish the base application shell, auth, and platform foundations.
+**Goal:** Barebone frontend with a real backend core.
 
-#### Architecture and Delivery
+#### Architecture
 
-- [x] Project-Structure
+- [ ] Project-Structure
-- [x] Stack-Decisions
+- [ ] Stack-Decisions
-- [x] Proxy
+- [ ] Proxy
-  - [x] Local-Dev-Vite-Proxy
+  - [ ] Local-Prod-NGINX-Proxy
-  - [x] Local-Prod-NGINX-Proxy
+  - [ ] Static-Frontend-Serving
-- [x] First-Request-Web-Loader
+- [ ] First-Request-Web-Loader
-  - [x] Bootstrap-Document
+  - [ ] Bootstrap-Document
-  - [x] Route-Intent-Handoff
+  - [ ] Route-Intent-Handoff
-  - [x] Tiny-First-Paint-Budget
+  - [ ] Tiny-First-Paint-Budget
-- [x] Dev-and-Prod-Builds
+- [ ] Dev-and-Prod-Builds
   - [x] Local-Dev-Just-Commands
   - [x] Local-Dev-Docker-Compose
-  - [x] Local-Prod-Just-Commands
+  - [ ] Local-Prod-Just-Commands
-  - [x] Local-Prod-Docker-Compose
+  - [ ] Local-Prod-Docker-Compose
-  - [x] Frontend-Production-Dockerfile
+  - [ ] Frontend-Production-Dockerfile
-  - [x] Frontend-docker-bake
+  - [ ] Frontend-docker-bake
 
-#### Backend — Done Foundations
+#### Backend
-
-- [x] Bootstrap-Persistence
-  - [x] Installation-Step
-  - [x] Mode-Step
-  - [x] Admin-Step
-  - [x] Structure-Step
-  - [x] Bootstrap-State-Authority
-  - [x] Development-Bootstrap-Reset
-- [x] Base-Schema
-  - [x] Installations
-  - [x] Users
-  - [x] User-Homes
-  - [x] Organizations
-  - [x] Departments
-  - [x] Teams
-  - [x] Projects
-  - [x] Workspaces
-  - [x] Membership-Tables
-- [x] App-Shell-Read-API
-  - [x] App-Shell-State-Endpoint
-  - [x] Bootstrap-Read-Endpoints
-  - [x] Shell-Tree-Hydration
-- [x] Web-Route-Scaffolds
-  - [x] Session-Endpoint-Scaffold
-  - [x] Bootstrap-Endpoint-Scaffold
-  - [x] Current-User-Endpoint-Scaffold
-
-#### Backend — Remaining for 0.1.0
 
 - [ ] Auth
   - [ ] Session-Flow
   - [ ] Login-Logout-Foundation
   - [ ] Authentication
-- [ ] Current-User-Implementation
+- [ ] User
-- [ ] POSIX-Lite-File-Persistence-Foundation
+  - [ ] Base-Model
-  - [ ] Mounted-Storage-Root-Config
-  - [ ] Project-Folder-Creation-On-Backend
-  - [ ] moku.project.json
-  - [ ] Item-Folder-Creation
-  - [ ] item.json
-  - [ ] schema.json
-  - [ ] data.json
-  - [ ] DB-To-Files-Write-Flow
-- [ ] User-and-Workspace-Domain-Readiness
   - [ ] Base-Workspace
-  - [ ] Boards
+    - [ ] Folders-and-Subfolders
-  - [ ] Dashboard
+    - [ ] Boards
+    - [ ] Dashboard
+- [ ] Organization
+  - [ ] Base-Model
+  - [ ] Access-Rules-and-Membership
+- [ ] Workspace
+  - [ ] Folders-and-Subfolders
 - [ ] API
-  - [ ] Real-Organizations-Read-Endpoint
-  - [ ] Real-Workspaces-Read-Endpoint
-  - [ ] Tree-Mutation-Endpoints
-  - [ ] Project-Creation-Endpoint
 
-#### Frontend — Done Foundations
+#### Frontend
 
 - [x] Foundation
 - [x] Typography
 - [x] Icons
-- [x] App-Shell
+- [ ] App Shell
-  - [x] Left-Rail
-  - [x] Top-Bar
-  - [x] Server-Dock
-  - [x] Department-Selector
-  - [x] Theme-Toggle
-  - [x] Notifications-Menu
-  - [x] Profile-Menu
-- [x] Responsive-Shell
-  - [x] Collapsible-Shell
-  - [x] Mobile-Bottom-Nav
-  - [x] Mobile-Workspace-Browser
-  - [x] Mobile-Workspace-Views
-- [x] Context-Menus
-  - [x] Workspace-Context-Menu
-  - [x] Project-Context-Menu
-- [x] Bootstrap-Workspace-Home
-  - [x] Bootstrap-Wizard
-  - [x] Bootstrap-Step-Submission
-  - [x] App-Shell-Reload-After-Bootstrap
-- [x] Project-Menu
-  - [x] Folders-and-Subfolders
-  - [x] Rooted-From-Department
-  - [x] Long-Press-Drag-and-Drop
-- [x] Workspace-Tree
-  - [x] Folders-and-Subfolders
-  - [x] Long-Press-Drag-and-Drop
-- [x] App-Shell-Hydration
-
-#### Frontend — Remaining for 0.1.0
-
 - [ ] Primitives
   - [ ] Button
   - [ ] IconButton
   - [ ] Input
   - [ ] Surface
+- [ ] Nav-Bar
 - [ ] Workspace-Switching
-- [ ] Real-Workspace-Home
+- [ ] Workspace-Home
-- [ ] Real-Workspace-Tree-Hydration
-- [ ] Create-Project-Flow
-- [ ] Persist-Tree-Mutations
-- [ ] Connect-Tree-Interactions-To-Backend-Data
 
 ### Version 0.2.0
 
-**Goal:** Build the plugin app system on top of the base platform. And core app plugins like calendar, board, docs and text channels
+**Goal:** First real work surface.
+
+- [ ] Table
+- [ ] CVA
+- [ ] Storyboard
+- [ ] Theme-System
+  - [ ] Theme-Registry
+  - [ ] Built-In-Theme-Presets
+  - [ ] Active-Theme-Persistence
+  - [ ] Theme-Switcher
+  - [ ] Theme-JSON-Upload
+  - [ ] Theme-JSON-Import-Validation
+  - [ ] Community-Theme-Readiness
 
 ### Version 0.3.0
 
-**Goal:** Communications and Collaboration (Email System, Reminder System, and Live Collaboration on Documents)
+**Goal:** Documents and system hardening.
+
+- [ ] Document
+- [ ] Accessibility-Rules
+- [ ] Motion-Foundation
 
 ### Version 0.4.0
 
-**Goal:** Introduce the POSIX-based file system drive direction with OnlyOffice + S3 blob storage + Per File Versioning
+- [ ] Gantt-Board
-
+- [ ] Calendar
-### Version 0.5.0
+- [ ] Timeline
-
-**Goal:** File Sharing and Per File Permissions
-
-### Version 0.6.0
-
-**Goal:** Git as a core plugin
-
-### Version 0.7.0
-
-**Goal:** Full Automation System (Extensive)

Env/.env.example

@@ -10,7 +10,6 @@ BACKEND_SHUTDOWN_TIMEOUT=10s
 
 DATABASE_URL=postgres://moku:moku_dev_password@localhost:5432/moku?sslmode=disable
 VALKEY_URL=redis://localhost:6379/0
-POSIX_ROOT=../POSIX
 
 VITE_API_BASE_URL=/v1
 

Frontend/src/components/shell/ProjectContextMenu/ProjectContextMenu.tsx

@@ -1,204 +0,0 @@
-import { For, Show, createEffect, createMemo, createSignal, onMount, type JSX } from "solid-js";
-import { Portal } from "solid-js/web";
-import { ChevronRight, Plus } from "../../../lib/icons";
-import {
-	getProjectContextMenuEyebrow,
-	getProjectContextMenuSections,
-	type ProjectContextMenuAction,
-	type ProjectMenuTarget,
-	type WorkspaceContextMenuShortcut,
-} from "../data/shell.data";
-import styles from "../WorkspaceContextMenu/WorkspaceContextMenu.module.scss";
-
-type ShortcutPlatform = "mac" | "windows";
-
-type NavigatorWithUserAgentData = Navigator & {
-	userAgentData?: {
-		platform?: string;
-	};
-};
-
-type ProjectContextMenuPosition = {
-	x: number;
-	y: number;
-};
-
-type ProjectContextMenuProps = {
-	target: ProjectMenuTarget | null;
-	position: ProjectContextMenuPosition | null;
-	onClose: VoidFunction;
-	onSelect: (action: ProjectContextMenuAction, target: ProjectMenuTarget) => void;
-	menuRef: (element: HTMLDivElement) => void;
-};
-
-const getShortcutPlatform = (): ShortcutPlatform => {
-	if (typeof navigator === "undefined") {
-		return "mac";
-	}
-
-	const navigatorWithUserAgentData = navigator as NavigatorWithUserAgentData;
-	const platform =
-		typeof navigatorWithUserAgentData.userAgentData?.platform === "string"
-			? navigatorWithUserAgentData.userAgentData.platform
-			: navigator.platform;
-
-	return /mac|iphone|ipad|ipod/i.test(platform) ? "mac" : "windows";
-};
-
-const formatShortcut = (shortcut: WorkspaceContextMenuShortcut, platform: ShortcutPlatform): string => {
-	const keyLabel = (() => {
-		switch (shortcut.key) {
-			case "enter":
-				return platform === "mac" ? "↩" : "Enter";
-			case "delete":
-				return platform === "mac" ? "⌫" : "Del";
-			default:
-				return shortcut.key.toUpperCase();
-		}
-	})();
-
-	const modifierLabels =
-		shortcut.modifiers?.map((modifier) => {
-			switch (modifier) {
-				case "meta":
-					return platform === "mac" ? "⌘" : "Ctrl";
-				case "alt":
-					return platform === "mac" ? "⌥" : "Alt";
-				case "shift":
-					return platform === "mac" ? "⇧" : "Shift";
-			}
-		}) ?? [];
-
-	return platform === "mac" ? `${modifierLabels.join("")}${keyLabel}` : [...modifierLabels, keyLabel].join("+");
-};
-
-export const ProjectContextMenu = (props: ProjectContextMenuProps): JSX.Element => {
-	const [activeSubmenuActionId, setActiveSubmenuActionId] = createSignal<string | null>(null);
-	const [shortcutPlatform, setShortcutPlatform] = createSignal<ShortcutPlatform>("mac");
-	const sections = createMemo(() => (props.target ? getProjectContextMenuSections(props.target) : []));
-	const isCreateAction = (action: ProjectContextMenuAction): boolean => action.id.startsWith("new-");
-	const menuState = createMemo<{
-		target: ProjectMenuTarget;
-		position: ProjectContextMenuPosition;
-	} | null>(() => (props.target && props.position ? { target: props.target, position: props.position } : null));
-
-	onMount(() => {
-		setShortcutPlatform(getShortcutPlatform());
-	});
-
-	createEffect(() => {
-		void props.target;
-		setActiveSubmenuActionId(null);
-	});
-
-	return (
-		<Show when={menuState()}>
-			{(resolvedMenuState): JSX.Element => {
-				const target = resolvedMenuState().target;
-				const position = resolvedMenuState().position;
-
-				return (
-					<Portal>
-						<div
-							ref={props.menuRef}
-							class={styles.menu}
-							role="menu"
-							aria-label={`${target.label} project context menu`}
-							style={{ left: `${position.x}px`, top: `${position.y}px` }}
-						>
-							<Show when={target.kind !== "surface"}>
-								<header class={styles.header}>
-									<span class={styles.eyebrow}>{getProjectContextMenuEyebrow(target)}</span>
-									<strong class={styles.title}>{target.label}</strong>
-								</header>
-							</Show>
-
-							<div class={styles.sectionList}>
-								<For each={sections()}>
-									{(section): JSX.Element => (
-										<section class={styles.section}>
-											<Show when={section.label}>
-												<span class={styles.sectionLabel}>{section.label}</span>
-											</Show>
-											<div class={styles.actionList}>
-												<For each={section.items}>
-													{(action): JSX.Element => {
-														const isSubmenuOpen = () => activeSubmenuActionId() === action.id;
-
-														return (
-															<div class={styles.actionItem} onMouseEnter={() => setActiveSubmenuActionId(action.children ? action.id : null)}>
-												<button
-													type="button"
-													role="menuitem"
-													classList={{
-														[styles.action]: true,
-														[styles.actionCreate]: isCreateAction(action),
-														[styles.actionDanger]: action.tone === "danger",
-														[styles.actionSubmenuOpen]: isSubmenuOpen(),
-													}}
-																	onClick={() => {
-																		if (action.children) {
-																			setActiveSubmenuActionId(isSubmenuOpen() ? null : action.id);
-																			return;
-																		}
-
-														props.onSelect(action, target);
-														props.onClose();
-													}}
-												>
-													<Show when={isCreateAction(action)}>
-														<span class={styles.actionCreateIcon} aria-hidden="true">
-															<Plus size={14} strokeWidth={2.25} />
-														</span>
-													</Show>
-																	<span class={styles.actionLabel}>{action.label}</span>
-																	<div class={styles.actionMeta}>
-																		<Show when={action.shortcut}>
-																			<span class={styles.actionShortcut}>{formatShortcut(action.shortcut!, shortcutPlatform())}</span>
-																		</Show>
-																		<Show when={action.children}>
-																			<ChevronRight class={styles.actionChevron} size={16} strokeWidth={2} />
-																		</Show>
-																	</div>
-																</button>
-
-																<Show when={action.children && isSubmenuOpen()}>
-																	<div class={styles.submenu} role="menu" aria-label={`${action.label} submenu`}>
-																		<div class={styles.submenuList}>
-																			<For each={action.children ?? []}>
-																				{(childAction): JSX.Element => (
-																					<button
-																						type="button"
-																						role="menuitem"
-																						classList={{
-																							[styles.action]: true,
-																							[styles.actionDanger]: childAction.tone === "danger",
-																						}}
-																						onClick={() => {
-																							props.onSelect(childAction, target);
-																							props.onClose();
-																						}}
-																					>
-																						<span class={styles.actionLabel}>{childAction.label}</span>
-																					</button>
-																				)}
-																			</For>
-																		</div>
-																	</div>
-																</Show>
-															</div>
-														);
-													}}
-												</For>
-											</div>
-										</section>
-									)}
-								</For>
-							</div>
-						</div>
-					</Portal>
-				);
-			}}
-		</Show>
-	);
-};

Frontend/src/components/shell/ProjectContextMenu/createProjectContextMenuController.ts

@@ -1,120 +0,0 @@
-import { createEffect, createSignal, onCleanup } from "solid-js";
-import type { ProjectMenuTarget } from "../data/shell.data";
-
-type ProjectContextMenuState = {
-	target: ProjectMenuTarget;
-	x: number;
-	y: number;
-};
-
-const readRootPixelToken = (name: string, fallback: number): number => {
-	if (typeof window === "undefined") {
-		return fallback;
-	}
-
-	const value = window.getComputedStyle(document.documentElement).getPropertyValue(name).trim();
-	const parsed = Number.parseFloat(value);
-
-	if (!Number.isFinite(parsed)) {
-		return fallback;
-	}
-
-	if (value.endsWith("px")) {
-		return parsed;
-	}
-
-	return parsed * 16;
-};
-
-const clampMenuPosition = (value: number, min: number, max: number): number => {
-	if (max <= min) {
-		return min;
-	}
-
-	return Math.min(Math.max(value, min), max);
-};
-
-export const createProjectContextMenuController = () => {
-	const [menuState, setMenuState] = createSignal<ProjectContextMenuState | null>(null);
-	let menuRef: HTMLDivElement | undefined;
-
-	const closeMenu = (): void => {
-		setMenuState(null);
-	};
-
-	const repositionMenu = (): void => {
-		if (typeof window === "undefined" || !menuRef) {
-			return;
-		}
-
-		const current = menuState();
-
-		if (!current) {
-			return;
-		}
-
-		const viewportPadding = readRootPixelToken("--space-4", 16);
-		const rect = menuRef.getBoundingClientRect();
-		const nextX = clampMenuPosition(current.x, viewportPadding, window.innerWidth - rect.width - viewportPadding);
-		const nextY = clampMenuPosition(current.y, viewportPadding, window.innerHeight - rect.height - viewportPadding);
-
-		if (nextX === current.x && nextY === current.y) {
-			return;
-		}
-
-		setMenuState({ ...current, x: nextX, y: nextY });
-	};
-
-	const openMenu = (event: MouseEvent, target: ProjectMenuTarget): void => {
-		event.preventDefault();
-		setMenuState({ target, x: event.clientX, y: event.clientY });
-	};
-
-	createEffect(() => {
-		if (!menuState() || typeof window === "undefined") {
-			return;
-		}
-
-		const frame = window.requestAnimationFrame(() => {
-			repositionMenu();
-		});
-
-		const handlePointerDown = (event: PointerEvent): void => {
-			if (!menuRef?.contains(event.target as Node)) {
-				closeMenu();
-			}
-		};
-
-		const handleKeyDown = (event: KeyboardEvent): void => {
-			if (event.key === "Escape") {
-				closeMenu();
-			}
-		};
-
-		const handleViewportChange = (): void => {
-			closeMenu();
-		};
-
-		document.addEventListener("pointerdown", handlePointerDown);
-		window.addEventListener("resize", handleViewportChange);
-		window.addEventListener("scroll", handleViewportChange, true);
-		window.addEventListener("keydown", handleKeyDown);
-
-		onCleanup(() => {
-			window.cancelAnimationFrame(frame);
-			document.removeEventListener("pointerdown", handlePointerDown);
-			window.removeEventListener("resize", handleViewportChange);
-			window.removeEventListener("scroll", handleViewportChange, true);
-			window.removeEventListener("keydown", handleKeyDown);
-		});
-	});
-
-	return {
-		menuState,
-		openMenu,
-		closeMenu,
-		setMenuRef: (element: HTMLDivElement): void => {
-			menuRef = element;
-		},
-	};
-};

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

@@ -1,5 +1,3 @@
-@use "../shared/tree-nav" as treeNav;
-
 .root {
   display: grid;
   --project-drawer-gap: var(--space-3);
@@ -11,15 +9,6 @@
   justify-items: center;
 }
 
-.rootDragMode {
-	user-select: none;
-	cursor: grabbing;
-}
-
-.rootDragMode .treeItem {
-	cursor: grabbing;
-}
-
 .trigger {
   width: 100%;
   min-width: 0;
@@ -49,9 +38,9 @@
 }
 
 .triggerOpen {
-  border-color: color-mix(in srgb, var(--color-accent-strong) 22%, var(--color-border-strong));
+  border-color: color-mix(in srgb, var(--color-border-strong) 22%, transparent);
-  background: color-mix(in srgb, var(--color-accent-soft) 26%, var(--color-surface));
+  background: color-mix(in srgb, var(--color-surface) 92%, transparent);
-  box-shadow: 0 10px 28px color-mix(in srgb, black 8%, transparent);
+  box-shadow: var(--shadow-soft);
 }
 
 .triggerCompact {
@@ -94,14 +83,19 @@
   gap: 0.12rem;
 }
 
-.eyebrow {
+.eyebrow,
+.projectItemDescription {
   @include text-caption;
   color: var(--color-text-muted);
+}
+
+.eyebrow {
   text-transform: uppercase;
   letter-spacing: 0.08em;
 }
 
-.value {
+.value,
+.projectItemName {
   @include text-label;
 }
 
@@ -181,7 +175,7 @@
   min-height: 0;
   display: grid;
   align-content: start;
-  gap: var(--space-2);
+  gap: var(--space-3);
   padding: var(--space-4);
   overflow-y: auto;
   overscroll-behavior: contain;
@@ -192,132 +186,49 @@
 	width: 0;
 }
 
-.treeSectionLabel {
+.projectList {
-	@include treeNav.section-label;
+  list-style: none;
-  margin: 0;
+  display: grid;
-  padding: 0 var(--space-3);
+  gap: 0.2rem;
+  padding: 0;
 }
 
-.treeSectionHeader {
+.projectItem {
-	display: flex;
+  width: 100%;
-	align-items: center;
+  min-width: 0;
-	justify-content: space-between;
+  min-height: calc(var(--control-size-md) + var(--space-2));
-	gap: var(--space-2);
+  padding: var(--space-2) var(--space-3);
-	margin-bottom: var(--space-2);
+  border: 1px solid transparent;
-	padding-right: var(--space-1);
+  border-radius: var(--radius-sm);
+  background: transparent;
+  color: var(--color-text-muted);
+  transition:
+    background 160ms var(--easing-standard),
+    color 160ms var(--easing-standard),
+    border-color 160ms var(--easing-standard),
+    transform 180ms var(--easing-standard);
+  text-align: left;
 }
 
-.treeControls {
+.projectItem:hover {
-	display: inline-flex;
+  background: color-mix(in srgb, var(--color-surface-hover) 82%, transparent);
-	align-items: center;
+  color: var(--color-text);
-	gap: var(--space-1);
+  border-color: color-mix(in srgb, var(--color-border) 22%, transparent);
-	flex-wrap: wrap;
-	justify-content: flex-end;
 }
 
-.treeControlButton {
+.projectItemActive {
-	display: inline-flex;
+  border-color: color-mix(in srgb, var(--color-border) 28%, transparent);
-	align-items: center;
+  background: color-mix(in srgb, var(--color-surface) 82%, transparent);
-	justify-content: center;
+  color: var(--color-text);
-	width: calc(var(--control-size-md) - var(--space-1));
+  box-shadow: none;
-	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,
+.projectItemCopy {
-.treeControlButton:focus-visible {
+  min-width: 0;
-	border-color: color-mix(in srgb, var(--color-border-strong) 56%, transparent);
+  display: grid;
-	background: var(--color-surface-hover);
+  gap: 0.05rem;
-	color: var(--color-text);
-	outline: none;
 }
 
-.treeControlButton:disabled {
+.projectItemDescription {
-	opacity: 0.45;
+  color: color-mix(in srgb, var(--color-text-muted) 84%, transparent);
-	cursor: default;
-}
-
-.treeList {
-	@include treeNav.tree-list;
-}
-
-.treeEmptySlot {
-	@include treeNav.empty-slot;
-}
-
-.treeInputRow {
-	@include treeNav.input-row;
-}
-
-.treeInput {
-	@include treeNav.input;
-}
-
-.treeItem {
-	@include treeNav.item;
-}
-
-.treeItem:hover,
-.treeItem:focus-visible {
-	@include treeNav.item-hover;
-}
-
-.treeItemFolder {
-	@include treeNav.item-folder;
-}
-
-.treeItemDragging {
-	@include treeNav.item-dragging;
-}
-
-.treeItemDropBefore {
-	@include treeNav.item-drop-before;
-}
-
-.treeItemDropAfter {
-	@include treeNav.item-drop-after;
-}
-
-.treeItemDropInside {
-	@include treeNav.item-drop-inside;
-}
-
-.folderChevron {
-	@include treeNav.folder-chevron;
-}
-
-.folderChevronOpen {
-	@include treeNav.folder-chevron-open;
-}
-
-.treeItemActive {
-	@include treeNav.item-active;
-}
-
-.icon {
-	@include treeNav.icon;
-}
-
-.label {
-	@include treeNav.label;
-}
-
-.itemMeta {
-	@include treeNav.item-meta;
-}
-
-@media (max-width: 720px) {
-  .rootCompact .scrim,
-  .rootCompact .drawer {
-    width: min(18rem, calc(100vw - 5rem));
-  }
 }

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

@@ -1,5 +1,3 @@
-@use "../shared/tree-nav" as treeNav;
-
 .sidebar {
   --sidebar-nav-item-min-height: var(--control-size-lg);
   position: relative;
@@ -14,15 +12,6 @@
   isolation: isolate;
 }
 
-.sidebarDragMode {
-	user-select: none;
-	cursor: grabbing;
-}
-
-.sidebarDragMode .treeItem {
-	cursor: grabbing;
-}
-
 .header {
   display: grid;
   gap: var(--space-3);
@@ -119,25 +108,19 @@
 }
 
 .treeSectionLabel {
-	@include treeNav.section-label;
+  @include text-caption;
   margin: var(--space-3) 0 var(--space-2);
   padding: 0 var(--space-3);
+  color: var(--color-text-subtle);
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
 }
 
 .treeList {
-	@include treeNav.tree-list;
+  list-style: none;
-}
+  display: grid;
-
+  gap: var(--space-1);
-.treeEmptySlot {
+  padding: 0;
-	@include treeNav.empty-slot;
-}
-
-.treeInputRow {
-	@include treeNav.input-row;
-}
-
-.treeInput {
-	@include treeNav.input;
 }
 
 .navItem {
@@ -155,44 +138,42 @@
 }
 
 .treeItem {
-	@include treeNav.item;
+  width: 100%;
+  min-width: 0;
+  display: grid;
+  grid-template-columns: auto minmax(0, 1fr) auto;
+  align-items: center;
+  gap: var(--space-2);
+  min-height: calc(var(--control-size-lg) - var(--space-2));
+  padding: var(--space-2) var(--space-3);
+  padding-left: calc(var(--space-3) + (var(--tree-depth, 0) * var(--space-4)));
+  border: 1px solid transparent;
+  border-radius: var(--radius-lg);
+  background: transparent;
+  color: var(--color-text-muted);
+  text-align: left;
+  transition:
+    background 160ms var(--easing-standard),
+    color 160ms var(--easing-standard),
+    border-color 160ms var(--easing-standard),
+    transform 180ms var(--easing-standard);
 }
 
 .treeItem:hover,
 .treeItem:focus-visible {
-	@include treeNav.item-hover;
+  background: var(--color-surface-hover);
+  color: var(--color-text);
 }
 
 .treeItemFolder {
-	@include treeNav.item-folder;
+  color: var(--color-text);
-}
-
-.treeItemDragging {
-	@include treeNav.item-dragging;
-}
-
-.treeItemDropBefore {
-	@include treeNav.item-drop-before;
-}
-
-.treeItemDropAfter {
-	@include treeNav.item-drop-after;
-}
-
-.treeItemDropInside {
-	@include treeNav.item-drop-inside;
-}
-
-.folderChevron {
-	@include treeNav.folder-chevron;
-}
-
-.folderChevronOpen {
-	@include treeNav.folder-chevron-open;
 }
 
 .treeItemActive {
-	@include treeNav.item-active;
+  border-color: var(--color-border);
+  background: var(--color-surface);
+  color: var(--color-text);
+  box-shadow: inset 0 1px 0 color-mix(in srgb, white 4%, transparent);
 }
 
 .navItemActive {
@@ -203,15 +184,18 @@
 }
 
 .icon {
-	@include treeNav.icon;
+  color: inherit;
+  opacity: 0.85;
 }
 
 .label {
-	@include treeNav.label;
+  @include text-label;
+  min-width: 0;
 }
 
 .itemMeta {
-	@include treeNav.item-meta;
+  @include text-caption;
+  color: var(--color-text-muted);
 }
 
 .sidebarCollapsed {

Frontend/src/components/shell/WorkspaceSidebar/WorkspaceSidebar.tsx

@@ -1,20 +1,9 @@
 // Path: Frontend/src/components/shell/WorkspaceSidebar/WorkspaceSidebar.tsx
 
-import { For, Show, createEffect, createSignal, onCleanup, onMount, type JSX } from "solid-js";
+import { For, Show, createMemo, createSignal, type JSX } from "solid-js";
-import { resolveAPIBase } from "../../../lib/api";
+import { ChevronLeft, ChevronRight } from "../../../lib/icons";
-import { ChevronLeft, ChevronRight, Folder, ListCollapse, UnfoldVertical } from "../../../lib/icons";
 import { useAppShellData } from "../data/app-shell.context";
 import { ProjectSelector } from "../ProjectSelector/ProjectSelector";
-import {
-	collectBranchNodeIds,
-	findTreeNodeDepth,
-	getPointerRelativeY,
-	isUuidString,
-	moveTreeNode,
-	resolveTreeDropTarget,
-	type NavTreeAdapter,
-	type NavTreeDropTarget,
-} from "../shared/navTreeDnd";
 import {
 	createWorkspaceStaticTarget,
 	createWorkspaceSurfaceTarget,
@@ -37,112 +26,6 @@ type WorkspaceSidebarProps = {
 	onToggleRailCollapse: () => void;
 };
 
-type PendingWorkspaceFolderDraft = {
-	parentId: string | null;
-	depth: number;
-};
-
-type WorkspaceDragTarget = NavTreeDropTarget;
-
-type WorkspaceDragState = {
-	draggedNodeId: string;
-	dropTarget: WorkspaceDragTarget | null;
-};
-
-type PersistedWorkspaceFolderRecord = {
-	id: string;
-	label: string;
-	children?: PersistedWorkspaceFolderRecord[];
-};
-
-type WorkspaceFoldersResponse = {
-	data?: {
-		folders?: PersistedWorkspaceFolderRecord[];
-		renamedFolder?: PersistedWorkspaceFolderRecord;
-		previousFolderId?: string;
-	};
-	error?: string;
-	message?: string;
-};
-
-type PendingWorkspaceFolderRename = {
-	folderId: string;
-	depth: number;
-};
-
-const LONG_PRESS_MS = 320;
-
-const getWorkspaceTreeNodeId = (node: WorkspaceTreeNode): string => node.id;
-
-const buildPersistedWorkspaceFolderNodes = (
-	folders: readonly PersistedWorkspaceFolderRecord[],
-): WorkspaceTreeNode[] =>
-	folders.map((folder) => ({
-		id: folder.id,
-		label: folder.label,
-		kind: "folder",
-		icon: Folder,
-		children: buildPersistedWorkspaceFolderNodes(folder.children ?? []),
-	}));
-
-const readPersistedWorkspaceFolders = (body: WorkspaceFoldersResponse): PersistedWorkspaceFolderRecord[] =>
-	Array.isArray(body.data?.folders) ? body.data.folders : [];
-
-const workspaceTreeAdapter: NavTreeAdapter<WorkspaceTreeNode> = {
-	getNodeId: getWorkspaceTreeNodeId,
-	isBranchNode: (node) => node.kind === "folder",
-	getChildren: (node) => (node.kind === "folder" ? (node.children ?? []) : []),
-	withChildren: (node, children) =>
-		node.kind === "folder"
-			? {
-				...node,
-				children: [...children],
-			}
-			: node,
-};
-
-const FolderDraftRow = (props: {
-	depth: number;
-	value: string;
-	onInput: (value: string) => void;
-	onSubmit: () => void;
-	onCancel: () => void;
-}): JSX.Element => {
-	let inputRef: HTMLInputElement | undefined;
-
-	queueMicrotask(() => inputRef?.focus());
-
-	return (
-		<li>
-			<div class={styles.treeInputRow} style={{ "--tree-depth": String(props.depth) }}>
-				<Folder class={styles.icon} size={18} strokeWidth={2} />
-				<input
-					ref={inputRef}
-					type="text"
-					class={styles.treeInput}
-					value={props.value}
-					placeholder="Folder name"
-					onInput={(event): void => props.onInput(event.currentTarget.value)}
-					onBlur={props.onSubmit}
-					onKeyDown={(event): void => {
-						if (event.key === "Enter") {
-							event.preventDefault();
-							event.currentTarget.blur();
-							return;
-						}
-
-						if (event.key === "Escape") {
-							event.preventDefault();
-							props.onCancel();
-							event.currentTarget.blur();
-						}
-					}}
-				/>
-			</div>
-		</li>
-	);
-};
-
 const isContextMenuKeyboardTrigger = (event: KeyboardEvent): boolean => event.key === "ContextMenu" || (event.shiftKey && event.key === "F10");
 
 const WorkspaceHomeEntry = (props: {
@@ -192,615 +75,92 @@ const WorkspaceHomeEntry = (props: {
 
 const WorkspaceTreeBranch = (props: {
 	nodes: readonly WorkspaceTreeNode[];
-	parentId?: string | null;
 	depth?: number;
-	isFolderCollapsed: (folderId: string) => boolean;
-	onToggleFolder: (folderId: string) => void;
-	pendingFolderDraft: PendingWorkspaceFolderDraft | null;
-	pendingFolderName: string;
-	onPendingFolderNameChange: (value: string) => void;
-	onSubmitPendingFolder: () => void;
-	onCancelPendingFolder: () => void;
-	pendingFolderRename: PendingWorkspaceFolderRename | null;
-	pendingFolderRenameName: string;
-	onPendingFolderRenameChange: (value: string) => void;
-	onSubmitPendingFolderRename: () => void;
-	onCancelPendingFolderRename: () => void;
 	onOpenContextMenu: (event: MouseEvent, target: WorkspaceContextMenuTarget) => void;
 	onOpenContextMenuFromKeyboard: (element: HTMLElement, target: WorkspaceContextMenuTarget) => void;
-	onNodePointerDown: (event: PointerEvent, nodeId: string) => void;
-	onNodePointerMove: (event: PointerEvent, parentId: string | null, index: number, node: WorkspaceTreeNode) => void;
-	dragState: WorkspaceDragState | null;
-	isTreeClickSuppressed: () => boolean;
 }): JSX.Element => {
 	const depth = () => props.depth ?? 0;
-	const parentId = () => props.parentId ?? null;
 
 	return (
 		<ul class={styles.treeList} role="list">
-			<Show when={props.nodes.length === 0 && props.pendingFolderDraft?.parentId !== parentId()}>
-				<li>
-					<div class={styles.treeEmptySlot} style={{ "--tree-depth": String(depth()) }} />
-				</li>
-			</Show>
 			<For each={props.nodes}>
-				{(node, indexAccessor): JSX.Element => {
+				{(node): JSX.Element => {
 					const Icon = getWorkspaceNodeIcon(node);
 					const target = createWorkspaceTreeTarget(node);
-					const isCollapsed = (): boolean => (node.kind === "folder" ? props.isFolderCollapsed(node.id) : false);
-					const isRenaming = (): boolean => props.pendingFolderRename?.folderId === node.id;
-					const isDraggedNode = (): boolean => props.dragState?.draggedNodeId === node.id;
-					const dropIntent = (): WorkspaceDragTarget["intent"] | null => {
-						if (props.dragState?.dropTarget?.targetNodeId !== node.id) {
-							return null;
-						}
-
-						return props.dragState.dropTarget.intent;
-					};
 
 					return (
 						<li>
-							<Show
+							<button
-								when={node.kind === "folder" && isRenaming()}
+								type="button"
-								fallback={
+								classList={{
-									<button
+									[styles.treeItem]: true,
-										type="button"
+									[styles.treeItemActive]: !!node.active,
-										classList={{
+									[styles.treeItemFolder]: node.kind === "folder",
-											[styles.treeItem]: true,
+								}}
-											[styles.treeItemActive]: !!node.active,
+								style={{ "--tree-depth": String(depth()) }}
-											[styles.treeItemFolder]: node.kind === "folder",
+								aria-current={node.active ? "page" : undefined}
-											[styles.treeItemDragging]: isDraggedNode(),
+								aria-label={node.label}
-											[styles.treeItemDropBefore]: dropIntent() === "before",
+								title={node.label}
-											[styles.treeItemDropAfter]: dropIntent() === "after",
+								data-slot="workspace-tree-item"
-											[styles.treeItemDropInside]: dropIntent() === "inside",
+								data-kind={node.kind}
-										}}
+								data-item-type={node.kind === "item" ? node.itemType : undefined}
-										style={{ "--tree-depth": String(depth()) }}
+								data-active={node.active ? "true" : "false"}
-										aria-expanded={node.kind === "folder" ? !isCollapsed() : undefined}
+								onContextMenu={(event): void => {
-										aria-current={node.active ? "page" : undefined}
+									event.stopPropagation();
-										aria-label={node.label}
+									props.onOpenContextMenu(event, target);
-										title={node.label}
+								}}
-										data-slot="workspace-tree-item"
+								onKeyDown={(event): void => {
-										data-kind={node.kind}
+									if (!isContextMenuKeyboardTrigger(event)) {
-										data-item-type={node.kind === "item" ? node.itemType : undefined}
+										return;
-										data-active={node.active ? "true" : "false"}
+									}
-										onClick={(): void => {
-											if (props.dragState || props.isTreeClickSuppressed()) {
-												return;
-											}
 
-											if (node.kind !== "folder") {
+									event.preventDefault();
-												return;
+									props.onOpenContextMenuFromKeyboard(event.currentTarget, target);
-											}
+								}}
-
-											props.onToggleFolder(node.id);
-										}}
-										onContextMenu={(event): void => {
-											event.stopPropagation();
-											props.onOpenContextMenu(event, target);
-										}}
-										onPointerDown={(event): void => props.onNodePointerDown(event, node.id)}
-										onPointerMove={(event): void =>
-											props.onNodePointerMove(event, parentId(), indexAccessor(), node)
-										}
-										onPointerEnter={(event): void =>
-											props.onNodePointerMove(event, parentId(), indexAccessor(), node)
-										}
-										onKeyDown={(event): void => {
-											if (!isContextMenuKeyboardTrigger(event)) {
-												return;
-											}
-
-											event.preventDefault();
-											props.onOpenContextMenuFromKeyboard(event.currentTarget, target);
-										}}
-									>
-										<Show when={node.kind === "folder"}>
-											<ChevronRight
-												classList={{
-													[styles.folderChevron]: true,
-													[styles.folderChevronOpen]: !isCollapsed(),
-												}}
-												size={16}
-												strokeWidth={2}
-											/>
-										</Show>
-										<Icon class={styles.icon} size={18} strokeWidth={2} />
-										<span class={styles.label}>{node.label}</span>
-										<Show when={node.meta}>
-											<span class={styles.itemMeta}>{node.meta}</span>
-										</Show>
-									</button>
-								}
 							>
-								<FolderDraftRow
+								<Icon class={styles.icon} size={18} strokeWidth={2} />
-									depth={props.pendingFolderRename?.depth ?? depth()}
+								<span class={styles.label}>{node.label}</span>
-									value={props.pendingFolderRenameName}
+								<Show when={node.meta}>
-									onInput={props.onPendingFolderRenameChange}
+									<span class={styles.itemMeta}>{node.meta}</span>
-									onSubmit={props.onSubmitPendingFolderRename}
+								</Show>
-									onCancel={props.onCancelPendingFolderRename}
+							</button>
-								/>
-							</Show>
 
-							<Show when={node.kind === "folder" && !isCollapsed() && (((node.children?.length ?? 0) > 0) || props.pendingFolderDraft?.parentId === node.id)}>
+							<Show when={node.children?.length}>
 								<WorkspaceTreeBranch
 									nodes={node.children ?? []}
-									parentId={node.id}
 									depth={depth() + 1}
-									isFolderCollapsed={props.isFolderCollapsed}
-									onToggleFolder={props.onToggleFolder}
-									pendingFolderDraft={props.pendingFolderDraft}
-									pendingFolderName={props.pendingFolderName}
-									onPendingFolderNameChange={props.onPendingFolderNameChange}
-									onSubmitPendingFolder={props.onSubmitPendingFolder}
-									onCancelPendingFolder={props.onCancelPendingFolder}
-									pendingFolderRename={props.pendingFolderRename}
-									pendingFolderRenameName={props.pendingFolderRenameName}
-									onPendingFolderRenameChange={props.onPendingFolderRenameChange}
-									onSubmitPendingFolderRename={props.onSubmitPendingFolderRename}
-									onCancelPendingFolderRename={props.onCancelPendingFolderRename}
 									onOpenContextMenu={props.onOpenContextMenu}
 									onOpenContextMenuFromKeyboard={props.onOpenContextMenuFromKeyboard}
-									onNodePointerDown={props.onNodePointerDown}
-									onNodePointerMove={props.onNodePointerMove}
-									dragState={props.dragState}
-									isTreeClickSuppressed={props.isTreeClickSuppressed}
 								/>
 							</Show>
 						</li>
 					);
 				}}
 			</For>
-
-			<Show when={props.pendingFolderDraft && props.pendingFolderDraft.parentId === parentId()}>
-				<FolderDraftRow
-					depth={props.pendingFolderDraft?.depth ?? depth()}
-					value={props.pendingFolderName}
-					onInput={props.onPendingFolderNameChange}
-					onSubmit={props.onSubmitPendingFolder}
-					onCancel={props.onCancelPendingFolder}
-				/>
-			</Show>
 		</ul>
 	);
 };
 
 export const WorkspaceSidebar = (props: WorkspaceSidebarProps): JSX.Element => {
 	const appShellData = useAppShellData();
-	const activeProject = () => appShellData.activeProject();
 	const [isProjectDrawerOpen, setIsProjectDrawerOpen] = createSignal(false);
-	const [workspaceTreeNodes, setWorkspaceTreeNodes] = createSignal<readonly WorkspaceTreeNode[]>(appShellData.workspaceTree());
-	const [persistedFolders, setPersistedFolders] = createSignal<readonly PersistedWorkspaceFolderRecord[]>([]);
-	const [collapsedFolderIds, setCollapsedFolderIds] = createSignal<readonly string[]>([]);
-	const [pendingFolderDraft, setPendingFolderDraft] = createSignal<PendingWorkspaceFolderDraft | null>(null);
-	const [pendingFolderName, setPendingFolderName] = createSignal("");
-	const [pendingFolderRename, setPendingFolderRename] = createSignal<PendingWorkspaceFolderRename | null>(null);
-	const [pendingFolderRenameName, setPendingFolderRenameName] = createSignal("");
-	const [dragState, setDragState] = createSignal<WorkspaceDragState | null>(null);
-	const [suppressNextTreeClick, setSuppressNextTreeClick] = createSignal(false);
-	let lastSelectedProjectId: string | null = null;
-	let latestPersistedFoldersRequest = 0;
 	const contextMenu = createWorkspaceContextMenuController();
-	let longPressTimer: number | undefined;
-	let suppressClickTimer: number | undefined;
 	const railToggleLabel = (): string => (props.railCollapsed ? "Expand server rail" : "Collapse server rail");
-	const sidebarContextMenuTarget = createWorkspaceSurfaceTarget(appShellData.activeProject());
+	const sidebarContextMenuTarget = createMemo(() => createWorkspaceSurfaceTarget(appShellData.activeProject()));
-	const isFolderCollapsed = (folderId: string): boolean => collapsedFolderIds().includes(folderId);
+	const contextMenuTarget = createMemo(() => contextMenu.menuState()?.target ?? null);
-	const folderIds = (): string[] => collectBranchNodeIds(workspaceTreeNodes(), workspaceTreeAdapter);
+	const contextMenuPosition = createMemo(() => {
-	const totalFolderCount = (): number => folderIds().length;
+		const state = contextMenu.menuState();
-	const areAllFoldersCollapsed = (): boolean => {
-		const count = totalFolderCount();
-		return count > 0 && collapsedFolderIds().length >= count;
-	};
-	const workspaceFolderToggleLabel = (): string =>
-		areAllFoldersCollapsed() ? "Expand all folders" : "Collapse all folders";
-	const toggleFolder = (folderId: string): void => {
-		setCollapsedFolderIds((current) =>
-			current.includes(folderId) ? current.filter((id) => id !== folderId) : [...current, folderId],
-		);
-	};
-	const expandAllFolders = (): void => {
-		setCollapsedFolderIds([]);
-	};
-	const collapseAllFolders = (): void => {
-		setCollapsedFolderIds(folderIds());
-	};
-	const toggleAllFolders = (): void => {
-		if (areAllFoldersCollapsed()) {
-			expandAllFolders();
-			return;
-		}
 
-		collapseAllFolders();
+		return state
-	};
+			? {
-	const resetWorkspaceTreeInteractionState = (): void => {
+				x: state.x,
-		setCollapsedFolderIds([]);
+				y: state.y,
-		setPendingFolderDraft(null);
-		setPendingFolderName("");
-		setPendingFolderRename(null);
-		setPendingFolderRenameName("");
-		setDragState(null);
-	};
-	const syncWorkspaceTree = (): void => {
-		const nextTree = activeProject()?.id
-			? buildPersistedWorkspaceFolderNodes(persistedFolders())
-			: appShellData.workspaceTree();
-		const availableFolderIds = new Set(collectBranchNodeIds(nextTree, workspaceTreeAdapter));
-
-		setWorkspaceTreeNodes(nextTree);
-		setCollapsedFolderIds((current) => current.filter((id) => availableFolderIds.has(id)));
-	};
-	const loadPersistedFolders = async (projectId: string): Promise<void> => {
-		const requestId = latestPersistedFoldersRequest + 1;
-		latestPersistedFoldersRequest = requestId;
-
-		if (!projectId) {
-			setPersistedFolders([]);
-			return;
-		}
-
-		if (!isUuidString(projectId)) {
-			setPersistedFolders([]);
-			return;
-		}
-
-		try {
-			const response = await fetch(`${resolveAPIBase()}/projects/${projectId}/tree/folders`, {
-				headers: {
-					Accept: "application/json",
-				},
-			});
-			const body = (await response.json()) as WorkspaceFoldersResponse;
-
-			if (requestId !== latestPersistedFoldersRequest) {
-				return;
 			}
-
+			: null;
-			if (!response.ok) {
-				throw new Error(body.message || "Failed to load project tree folders.");
-			}
-
-			setPersistedFolders(readPersistedWorkspaceFolders(body));
-		} catch (error) {
-			if (requestId !== latestPersistedFoldersRequest) {
-				return;
-			}
-
-			console.error(error);
-			setPersistedFolders([]);
-		}
-	};
-	const clearLongPressTimer = (): void => {
-		if (longPressTimer !== undefined) {
-			window.clearTimeout(longPressTimer);
-			longPressTimer = undefined;
-		}
-	};
-	const suppressTreeClickTemporarily = (): void => {
-		setSuppressNextTreeClick(true);
-
-		if (suppressClickTimer !== undefined) {
-			window.clearTimeout(suppressClickTimer);
-		}
-
-		suppressClickTimer = window.setTimeout(() => {
-			setSuppressNextTreeClick(false);
-			suppressClickTimer = undefined;
-		}, 80);
-	};
-
-	createEffect(() => {
-		syncWorkspaceTree();
 	});
 
-	createEffect(() => {
+	const handleContextActionSelect = (_action: WorkspaceContextMenuAction, _target: WorkspaceContextMenuTarget): void => {
-		const projectId = activeProject()?.id ?? null;
+		// Initial implementation only establishes the menu IA and placement.
-
-		if (lastSelectedProjectId === null) {
-			lastSelectedProjectId = projectId;
-			return;
-		}
-
-		if (projectId === lastSelectedProjectId) {
-			return;
-		}
-
-		lastSelectedProjectId = projectId;
-		resetWorkspaceTreeInteractionState();
-	});
-
-	createEffect(() => {
-		void loadPersistedFolders(activeProject()?.id ?? "");
-	});
-
-	onMount(() => {
-		const handlePointerUp = (): void => {
-			clearLongPressTimer();
-
-			const nextDragState = dragState();
-
-			if (!nextDragState?.dropTarget) {
-				if (nextDragState) {
-					suppressTreeClickTemporarily();
-				}
-				setDragState(null);
-				return;
-			}
-
-			suppressTreeClickTemporarily();
-			setWorkspaceTreeNodes((current) =>
-				moveTreeNode(current, nextDragState.draggedNodeId, nextDragState.dropTarget as WorkspaceDragTarget, workspaceTreeAdapter),
-			);
-			setDragState(null);
-		};
-
-		const handleEscape = (event: KeyboardEvent): void => {
-			if (event.key !== "Escape") {
-				return;
-			}
-
-			clearLongPressTimer();
-
-			if (dragState()) {
-				setDragState(null);
-			}
-		};
-
-		window.addEventListener("pointerup", handlePointerUp);
-		window.addEventListener("pointercancel", handlePointerUp);
-		window.addEventListener("keydown", handleEscape);
-
-		onCleanup(() => {
-			clearLongPressTimer();
-			if (suppressClickTimer !== undefined) {
-				window.clearTimeout(suppressClickTimer);
-			}
-			window.removeEventListener("pointerup", handlePointerUp);
-			window.removeEventListener("pointercancel", handlePointerUp);
-			window.removeEventListener("keydown", handleEscape);
-		});
-	});
-
-	const beginFolderDraft = (parentId: string | null, depth: number): void => {
-		if (parentId) {
-			setCollapsedFolderIds((current) => current.filter((id) => id !== parentId));
-		}
-
-		setPendingFolderRename(null);
-		setPendingFolderRenameName("");
-		setPendingFolderName("");
-		setPendingFolderDraft({ parentId, depth });
-	};
-
-	const beginFolderRename = (folderId: string, label: string, depth: number): void => {
-		setPendingFolderDraft(null);
-		setPendingFolderName("");
-		setPendingFolderRename({ folderId, depth });
-		setPendingFolderRenameName(label);
-	};
-
-	const submitPendingFolder = async (): Promise<void> => {
-		const name = pendingFolderName().trim();
-		const draft = pendingFolderDraft();
-		const projectId = activeProject()?.id ?? "";
-
-		if (!draft) {
-			return;
-		}
-
-		if (!name) {
-			setPendingFolderDraft(null);
-			setPendingFolderName("");
-			return;
-		}
-
-		if (!projectId || !isUuidString(projectId)) {
-			cancelPendingFolder();
-			return;
-		}
-
-		try {
-			const response = await fetch(`${resolveAPIBase()}/projects/${projectId}/tree/folders`, {
-				method: "POST",
-				headers: {
-					Accept: "application/json",
-					"Content-Type": "application/json",
-				},
-				body: JSON.stringify({
-					name,
-					parentFolderId: draft.parentId,
-				}),
-			});
-
-			const body = (await response.json()) as WorkspaceFoldersResponse;
-
-			if (!response.ok) {
-				throw new Error(body.message || "Failed to create project tree folder.");
-			}
-
-			setPersistedFolders(readPersistedWorkspaceFolders(body));
-			setPendingFolderDraft(null);
-			setPendingFolderName("");
-		} catch (error) {
-			console.error(error);
-		}
-	};
-
-	const deletePersistedFolder = async (folderId: string): Promise<void> => {
-		const projectId = activeProject()?.id ?? "";
-		if (!folderId || !projectId || !isUuidString(projectId)) {
-			return;
-		}
-
-		try {
-			const response = await fetch(
-				`${resolveAPIBase()}/projects/${projectId}/tree/folders?folderId=${encodeURIComponent(folderId)}`,
-				{
-					method: "DELETE",
-					headers: {
-						Accept: "application/json",
-					},
-				},
-			);
-
-			const body = (await response.json()) as WorkspaceFoldersResponse;
-
-			if (!response.ok) {
-				throw new Error(body.message || "Failed to delete project tree folder.");
-			}
-
-			setPersistedFolders(readPersistedWorkspaceFolders(body));
-			setCollapsedFolderIds((current) => current.filter((id) => id !== folderId));
-		} catch (error) {
-			console.error(error);
-		}
-	};
-
-	const submitPendingFolderRename = async (): Promise<void> => {
-		const draft = pendingFolderRename();
-		const name = pendingFolderRenameName().trim();
-		const projectId = activeProject()?.id ?? "";
-
-		if (!draft) {
-			return;
-		}
-
-		if (!name) {
-			setPendingFolderRename(null);
-			setPendingFolderRenameName("");
-			return;
-		}
-
-		if (!projectId || !isUuidString(projectId)) {
-			cancelPendingFolderRename();
-			return;
-		}
-
-		try {
-			const response = await fetch(`${resolveAPIBase()}/projects/${projectId}/tree/folders`, {
-				method: "PATCH",
-				headers: {
-					Accept: "application/json",
-					"Content-Type": "application/json",
-				},
-				body: JSON.stringify({
-					folderId: draft.folderId,
-					name,
-				}),
-			});
-
-			const body = (await response.json()) as WorkspaceFoldersResponse;
-
-			if (!response.ok) {
-				throw new Error(body.message || "Failed to rename project tree folder.");
-			}
-
-			setPersistedFolders(readPersistedWorkspaceFolders(body));
-			setPendingFolderRename(null);
-			setPendingFolderRenameName("");
-
-			const previousFolderId = body.data?.previousFolderId;
-			const renamedFolderId = body.data?.renamedFolder?.id;
-			if (previousFolderId && renamedFolderId && previousFolderId !== renamedFolderId) {
-				setCollapsedFolderIds((current) =>
-					current.map((id) => (id === previousFolderId ? renamedFolderId : id)),
-				);
-			}
-		} catch (error) {
-			console.error(error);
-		}
-	};
-
-	const cancelPendingFolder = (): void => {
-		setPendingFolderDraft(null);
-		setPendingFolderName("");
-	};
-
-	const cancelPendingFolderRename = (): void => {
-		setPendingFolderRename(null);
-		setPendingFolderRenameName("");
-	};
-
-	const handleHeaderActionClick = (actionId: string): void => {
-		switch (actionId) {
-			case "toggle-workspace-folders":
-				toggleAllFolders();
-				return;
-			case "search-workspace":
-			default:
-				return;
-		}
-	};
-
-	const handleNodePointerDown = (event: PointerEvent, nodeId: string): void => {
-		if (event.button !== 0 || pendingFolderDraft()) {
-			return;
-		}
-
-		clearLongPressTimer();
-		longPressTimer = window.setTimeout(() => {
-			suppressTreeClickTemporarily();
-			setDragState({ draggedNodeId: nodeId, dropTarget: null });
-		}, LONG_PRESS_MS);
-	};
-
-	const handleNodePointerMove = (
-		event: PointerEvent,
-		parentId: string | null,
-		index: number,
-		node: WorkspaceTreeNode,
-	): void => {
-		const nextDragState = dragState();
-
-		if (!nextDragState || nextDragState.draggedNodeId === getWorkspaceTreeNodeId(node)) {
-			return;
-		}
-
-		const relativeY = getPointerRelativeY(event);
-		if (relativeY === null) {
-			return;
-		}
-
-		setDragState({
-			...nextDragState,
-			dropTarget: resolveTreeDropTarget({
-				parentId,
-				index,
-				node,
-				relativeY,
-				adapter: workspaceTreeAdapter,
-			}),
-		});
-	};
-
-	const handleContextActionSelect = (action: WorkspaceContextMenuAction, target: WorkspaceContextMenuTarget): void => {
-		switch (action.id) {
-			case "new-folder":
-				switch (target.kind) {
-					case "workspace":
-					case "home":
-						beginFolderDraft(null, 0);
-						return;
-					case "folder":
-						beginFolderDraft(target.id, (findTreeNodeDepth(workspaceTreeNodes(), target.id, workspaceTreeAdapter) ?? 0) + 1);
-						return;
-					case "settings":
-					case "item":
-						return;
-				}
-				return;
-			case "delete-folder":
-				if (target.kind === "folder") {
-					void deletePersistedFolder(target.id);
-				}
-				return;
-			case "rename-folder":
-				if (target.kind === "folder") {
-					beginFolderRename(target.id, target.label, findTreeNodeDepth(workspaceTreeNodes(), target.id, workspaceTreeAdapter) ?? 0);
-				}
-				return;
-			default:
-				return;
-		}
 	};
 
 	return (
@@ -809,13 +169,12 @@ export const WorkspaceSidebar = (props: WorkspaceSidebarProps): JSX.Element => {
 				classList={{
 					[styles.sidebar]: true,
 					[styles.sidebarCollapsed]: props.collapsed,
-					[styles.sidebarDragMode]: !!dragState(),
 				}}
 				aria-label="Left workspace sidebar"
 				data-ui="workspace-sidebar"
 				data-collapsed={props.collapsed ? "true" : "false"}
 				onContextMenu={(event): void => {
-					contextMenu.openMenu(event, sidebarContextMenuTarget);
+					contextMenu.openMenu(event, sidebarContextMenuTarget());
 				}}
 			>
 				<div
@@ -841,30 +200,12 @@ export const WorkspaceSidebar = (props: WorkspaceSidebarProps): JSX.Element => {
 							{props.railCollapsed ? <ChevronRight size={16} strokeWidth={2} /> : <ChevronLeft size={16} strokeWidth={2} />}
 						</button>
 
-					<For each={workspaceSidebarHeaderActions}>
+						<For each={workspaceSidebarHeaderActions}>
-						{(action): JSX.Element => {
+							{(action): JSX.Element => {
-							const label =
+								const Icon = action.icon;
-								action.id === "toggle-workspace-folders"
-										? workspaceFolderToggleLabel()
-										: action.label;
-							const Icon =
-								action.id === "toggle-workspace-folders"
-										? areAllFoldersCollapsed()
-											? UnfoldVertical
-											: ListCollapse
-										: action.icon;
 
-							return (
+								return (
-								<button
+									<button type="button" class={styles.headerActionButton} aria-label={action.label} title={action.label} data-slot="workspace-sidebar-header-action" data-action-id={action.id}>
-									type="button"
-									class={styles.headerActionButton}
-									aria-label={label}
-									title={label}
-									data-slot="workspace-sidebar-header-action"
-									data-action-id={action.id}
-									disabled={action.id === "toggle-workspace-folders" && totalFolderCount() === 0}
-									onClick={(): void => handleHeaderActionClick(action.id)}
-									>
 										<Icon size={16} strokeWidth={2} />
 									</button>
 								);
@@ -914,44 +255,19 @@ export const WorkspaceSidebar = (props: WorkspaceSidebarProps): JSX.Element => {
 						</Show>
 
 						<div data-slot="workspace-tree-root">
-							<WorkspaceTreeBranch
+						<WorkspaceTreeBranch
-								nodes={workspaceTreeNodes()}
+							nodes={appShellData.workspaceTree()}
-								parentId={null}
+							onOpenContextMenu={contextMenu.openMenu}
-								isFolderCollapsed={isFolderCollapsed}
+							onOpenContextMenuFromKeyboard={contextMenu.openMenuFromElement}
-								onToggleFolder={toggleFolder}
+						/>
-								pendingFolderDraft={pendingFolderDraft()}
-								pendingFolderName={pendingFolderName()}
-								onPendingFolderNameChange={setPendingFolderName}
-								onSubmitPendingFolder={submitPendingFolder}
-								onCancelPendingFolder={cancelPendingFolder}
-								pendingFolderRename={pendingFolderRename()}
-								pendingFolderRenameName={pendingFolderRenameName()}
-								onPendingFolderRenameChange={setPendingFolderRenameName}
-								onSubmitPendingFolderRename={submitPendingFolderRename}
-								onCancelPendingFolderRename={cancelPendingFolderRename}
-								onOpenContextMenu={contextMenu.openMenu}
-								onOpenContextMenuFromKeyboard={contextMenu.openMenuFromElement}
-								onNodePointerDown={handleNodePointerDown}
-								onNodePointerMove={handleNodePointerMove}
-								dragState={dragState()}
-								isTreeClickSuppressed={suppressNextTreeClick}
-							/>
 						</div>
 					</div>
 				</div>
 			</aside>
 
 			<WorkspaceContextMenu
-				target={contextMenu.menuState()?.target ?? null}
+				target={contextMenuTarget()}
-				position={(() => {
+				position={contextMenuPosition()}
-					const state = contextMenu.menuState();
-					return state
-						? {
-							x: state.x,
-							y: state.y,
-						}
-						: null;
-				})()}
 				menuRef={contextMenu.setMenuRef}
 				onClose={contextMenu.closeMenu}
 				onSelect={handleContextActionSelect}

Frontend/src/components/shell/data/app-shell.context.tsx

@@ -34,7 +34,6 @@ import {
 
 type AppShellInstallation = {
 	id: string;
-	name: string;
 	mode: "personal" | "organizational" | string;
 	access: string;
 	protocol: string;
@@ -152,12 +151,11 @@ const buildRailItems = (payload: AppShellPayload | null): readonly RailItem[] =>
 	}
 
 	const kind = payload.installation.mode === "personal" ? "personal" : "organization";
-	const serverName = payload.installation.name || payload.organizations[0]?.name || payload.installation.host;
 
 	return payload.organizations.map((organization, index) => ({
 		id: organization.id,
-		label: serverName || organization.name,
+		label: organization.name,
-		abbreviation: buildAbbreviation(serverName || organization.name, kind === "personal" ? "P" : "O"),
+		abbreviation: buildAbbreviation(organization.name, kind === "personal" ? "P" : "O"),
 		kind,
 		active: index === 0,
 	}));
@@ -172,12 +170,11 @@ const buildActiveServer = (payload: AppShellPayload | null): ActiveServer => {
 	}
 
 	const kind = installation.mode === "personal" ? "personal" : "organization";
-	const serverName = installation.name || organization.name || installation.host;
 
 	return {
 		id: installation.id,
-		name: serverName || fallbackActiveServer.name,
+		name: organization.name || installation.host || fallbackActiveServer.name,
-		abbreviation: buildAbbreviation(serverName, kind === "personal" ? "P" : "O"),
+		abbreviation: buildAbbreviation(organization.name || installation.host, kind === "personal" ? "P" : "O"),
 		kind,
 		connectedLabel: kind === "organization" ? `${payload?.teams.length ?? 0} connected` : undefined,
 		subtitle: kind === "personal" ? installation.host || payload?.admin?.homeTitle || "Personal home" : undefined,
@@ -194,16 +191,6 @@ const buildProjectItems = (payload: AppShellPayload | null): readonly ProjectIte
 		id: project.id,
 		name: project.name,
 		description: project.slug || "Persisted project workspace",
-		groupLabel: payload.departments.find((department) => department.id === project.departmentId)?.name || "Projects",
-		parentLabel:
-			payload.teams.find((team) => team.id === project.teamId)?.name ||
-			payload.departments.find((department) => department.id === project.departmentId)?.name ||
-			"Shared project",
-		meta: (() => {
-			const workspaceCount = payload.workspaces.filter((workspace) => workspace.projectId === project.id).length;
-
-			return workspaceCount > 0 ? `${workspaceCount} workspace${workspaceCount === 1 ? "" : "s"}` : undefined;
-		})(),
 		active: index === 0,
 	}));
 };
@@ -268,7 +255,7 @@ const buildActiveUserProfile = (payload: AppShellPayload | null): ActiveUserProf
 		return fallbackActiveUserProfile;
 	}
 
-	const organizationName = payload.installation?.name || payload.organizations[0]?.name || fallbackActiveServer.name;
+	const organizationName = payload.organizations[0]?.name ?? fallbackActiveServer.name;
 	const departmentName = payload.departments[0]?.name;
 
 	return {
@@ -295,20 +282,10 @@ export const AppShellDataProvider = (props: { children: JSX.Element }): JSX.Elem
 				},
 			});
 
-			const body = (await response.json()) as {
+			const body = (await response.json()) as { data?: AppShellPayload; error?: { message?: string } };
-				data?: AppShellPayload;
-				error?: { message?: string } | string;
-				message?: string;
-			};
-			const errorMessage =
-				typeof body.message === "string"
-					? body.message
-					: typeof body.error === "string"
-						? body.error
-						: body.error?.message;
 
 			if (!response.ok || !body.data) {
-				throw new Error(errorMessage || "Failed to load app shell state.");
+				throw new Error(body.error?.message || "Failed to load app shell state.");
 			}
 
 			setPayload(normalizeAppShellPayload(body.data));

Frontend/src/components/shell/data/shell.data.ts

@@ -9,7 +9,6 @@ import {
 	Home,
 	Keyboard,
 	LayoutGrid,
-	ListCollapse,
 	LogOut,
 	Repeat,
 	Search,
@@ -72,43 +71,9 @@ export type ProjectItem = {
 	id: string;
 	name: string;
 	description: string;
-	groupLabel?: string;
-	parentLabel?: string;
-	meta?: string;
 	active?: boolean;
 };
 
-export type ProjectMenuTarget =
-	| {
-		id: string;
-		label: string;
-		kind: "surface";
-	  }
-	| {
-		id: string;
-		label: string;
-		kind: "folder";
-	  }
-	| {
-		id: string;
-		label: string;
-		kind: "project";
-	  };
-
-export type ProjectContextMenuAction = {
-	id: string;
-	label: string;
-	tone?: "default" | "danger";
-	shortcut?: WorkspaceContextMenuShortcut;
-	children?: readonly ProjectContextMenuAction[];
-};
-
-export type ProjectContextMenuSection = {
-	id: string;
-	label?: string;
-	items: readonly ProjectContextMenuAction[];
-};
-
 export type SidebarItem = {
 	id: string;
 	label: string;
@@ -399,31 +364,9 @@ export const activeDepartment: ActiveDepartment = {
 };
 
 export const projectItems: readonly ProjectItem[] = [
-	{
+	{ id: "general", name: "General", description: "Default shared project", active: true },
-		id: "general",
+	{ id: "operations", name: "Operations", description: "Cross-team planning and delivery" },
-		name: "General",
+	{ id: "hiring", name: "Hiring", description: "Candidate pipeline and interview loops" },
-		description: "Default shared project",
-		groupLabel: "Shared space",
-		parentLabel: "Workspace home",
-		meta: "1 workspace",
-		active: true,
-	},
-	{
-		id: "operations",
-		name: "Operations",
-		description: "Cross-team planning and delivery",
-		groupLabel: "Team folders",
-		parentLabel: "Shared Services",
-		meta: "2 workspaces",
-	},
-	{
-		id: "hiring",
-		name: "Hiring",
-		description: "Candidate pipeline and interview loops",
-		groupLabel: "Team folders",
-		parentLabel: "People Ops",
-		meta: "1 workspace",
-	},
 ] as const;
 
 export const departmentItems: readonly DepartmentItem[] = [
@@ -477,7 +420,6 @@ export const workspaceTree: readonly WorkspaceTreeNode[] = [
 
 export const workspaceSidebarHeaderActions: readonly SidebarHeaderAction[] = [
 	{ id: "search-workspace", label: "Search workspace", icon: Search },
-	{ id: "toggle-workspace-folders", label: "Collapse all folders", icon: ListCollapse },
 ] as const;
 
 export const mobileBottomNavItems: readonly MobileBottomNavItem[] = [
@@ -591,79 +533,6 @@ export const getWorkspaceContextMenuSections = (
 	}
 };
 
-const getProjectCreateActions = (): readonly ProjectContextMenuAction[] =>
-	[
-		{ id: "new-project", label: "New project" },
-		{ id: "new-folder", label: "New folder" },
-	] as const;
-
-const getProjectFolderDangerActions = (): readonly ProjectContextMenuAction[] =>
-	[
-		{ id: "rename-folder", label: "Rename", shortcut: { modifiers: ["meta"], key: "r" } },
-		{ id: "delete-folder", label: "Delete", shortcut: { modifiers: ["meta"], key: "delete" }, tone: "danger" },
-	] as const;
-
-export const createProjectSurfaceTarget = (label = "Projects"): ProjectMenuTarget => ({
-	id: "project-surface",
-	label,
-	kind: "surface",
-});
-
-export const createProjectFolderTarget = (id: string, label: string): ProjectMenuTarget => ({
-	id,
-	label,
-	kind: "folder",
-});
-
-export const createProjectTarget = (project: ProjectItem): ProjectMenuTarget => ({
-	id: project.id,
-	label: project.name,
-	kind: "project",
-});
-
-export const getProjectContextMenuEyebrow = (target: ProjectMenuTarget): string => {
-	switch (target.kind) {
-		case "surface":
-			return "Projects";
-		case "folder":
-			return "Folder";
-		case "project":
-			return "Project";
-	}
-};
-
-export const getProjectContextMenuSections = (target: ProjectMenuTarget): readonly ProjectContextMenuSection[] => {
-	const createActions = getProjectCreateActions();
-
-	switch (target.kind) {
-		case "surface":
-			return [
-				{
-					id: "create",
-					items: createActions,
-				},
-			] as const;
-		case "folder":
-			return [
-				{
-					id: "create",
-					items: createActions,
-				},
-				{
-					id: "organize",
-					items: getProjectFolderDangerActions(),
-				},
-			] as const;
-		case "project":
-			return [
-				{
-					id: "create",
-					items: createActions,
-				},
-			] as const;
-	}
-};
-
 export const topBarActions: readonly TopBarAction[] = [
 	{ id: "search", label: "Search", icon: Search },
 ] as const;

Frontend/src/components/shell/shared/_tree-nav.scss

@@ -1,188 +0,0 @@
-@use "../../../styles/tools/mixins" as *;
-
-@mixin section-label {
-	@include text-caption;
-	color: var(--color-text-subtle);
-	text-transform: uppercase;
-	letter-spacing: 0.04em;
-}
-
-@mixin tree-list {
-	list-style: none;
-	display: grid;
-	gap: var(--space-1);
-	padding: 0;
-}
-
-@mixin empty-slot {
-	min-height: calc(var(--control-size-lg) - var(--space-2));
-	padding-left: calc(var(--space-3) + (var(--tree-depth, 0) * var(--space-4)));
-	border-radius: var(--radius-lg);
-	border: 1px dashed color-mix(in srgb, var(--color-border) 38%, transparent);
-	opacity: 0.35;
-}
-
-@mixin input-row {
-	width: 100%;
-	min-width: 0;
-	display: grid;
-	grid-template-columns: auto minmax(0, 1fr);
-	align-items: center;
-	gap: var(--space-2);
-	min-height: calc(var(--control-size-lg) - var(--space-2));
-	padding: var(--space-2) var(--space-3);
-	padding-left: calc(var(--space-3) + (var(--tree-depth, 0) * var(--space-4)));
-	border: 1px solid color-mix(in srgb, var(--color-border) 42%, transparent);
-	border-radius: var(--radius-lg);
-	background: color-mix(in srgb, var(--color-surface) 94%, transparent);
-}
-
-@mixin input {
-	width: 100%;
-	min-width: 0;
-	border: 0;
-	background: transparent;
-	color: var(--color-text);
-	font: inherit;
-	outline: none;
-
-	&::placeholder {
-		color: var(--color-text-muted);
-	}
-}
-
-@mixin item {
-	width: 100%;
-	min-width: 0;
-	display: grid;
-	position: relative;
-	isolation: isolate;
-	grid-template-columns: auto auto minmax(0, 1fr) auto;
-	align-items: center;
-	gap: var(--space-2);
-	min-height: calc(var(--control-size-lg) - var(--space-2));
-	padding: var(--space-2) var(--space-3);
-	padding-left: calc(var(--space-3) + (var(--tree-depth, 0) * var(--space-4)));
-	border: 0;
-	border-radius: 0;
-	background: transparent;
-	color: var(--color-text-muted);
-	text-align: left;
-	transition:
-		color 160ms var(--easing-standard),
-		box-shadow 160ms var(--easing-standard),
-		transform 180ms var(--easing-standard);
-
-	&::after {
-		content: "";
-		position: absolute;
-		inset: 0;
-		border: 1px solid transparent;
-		border-radius: var(--radius-lg);
-		background: transparent;
-		transition:
-			background 160ms var(--easing-standard),
-			border-color 160ms var(--easing-standard),
-			box-shadow 160ms var(--easing-standard);
-		pointer-events: none;
-		z-index: 0;
-	}
-
-	> * {
-		position: relative;
-		z-index: 1;
-	}
-}
-
-@mixin item-hover {
-	color: var(--color-text);
-
-	&::after {
-		background: color-mix(in srgb, var(--color-surface-hover) 80%, var(--color-accent-soft) 20%);
-		box-shadow: inset 0 1px 0 color-mix(in srgb, white 4%, transparent);
-	}
-}
-
-@mixin item-folder {
-	color: var(--color-text);
-}
-
-@mixin item-dragging {
-	opacity: 0.45;
-	transform: scale(0.985);
-	box-shadow: none;
-}
-
-@mixin item-drop-before {
-	&::before {
-		content: "";
-		position: absolute;
-		left: calc(var(--space-3) + (var(--tree-depth, 0) * var(--space-4)));
-		right: var(--space-3);
-		top: calc((var(--space-1) * -0.5) - 1px);
-		height: 2px;
-		border-radius: 999px;
-		background: color-mix(in srgb, var(--color-accent-strong) 78%, transparent);
-		pointer-events: none;
-		z-index: 2;
-	}
-}
-
-@mixin item-drop-after {
-	&::before {
-		content: "";
-		position: absolute;
-		left: calc(var(--space-3) + (var(--tree-depth, 0) * var(--space-4)));
-		right: var(--space-3);
-		bottom: calc((var(--space-1) * -0.5) - 1px);
-		height: 2px;
-		border-radius: 999px;
-		background: color-mix(in srgb, var(--color-accent-strong) 78%, transparent);
-		pointer-events: none;
-		z-index: 2;
-	}
-}
-
-@mixin item-drop-inside {
-	color: var(--color-text);
-
-	&::after {
-		border-color: color-mix(in srgb, var(--color-accent-strong) 55%, transparent);
-		background: color-mix(in srgb, var(--color-accent-soft) 36%, var(--color-surface));
-		box-shadow: inset 0 1px 0 color-mix(in srgb, white 4%, transparent);
-	}
-}
-
-@mixin folder-chevron {
-	color: var(--color-text-muted);
-	transition: transform 160ms var(--easing-standard);
-}
-
-@mixin folder-chevron-open {
-	transform: rotate(90deg);
-}
-
-@mixin item-active {
-	color: var(--color-text);
-
-	&::after {
-		border-color: var(--color-border);
-		background: var(--color-surface);
-		box-shadow: inset 0 1px 0 color-mix(in srgb, white 4%, transparent);
-	}
-}
-
-@mixin icon {
-	color: inherit;
-	opacity: 0.85;
-}
-
-@mixin label {
-	@include text-label;
-	min-width: 0;
-}
-
-@mixin item-meta {
-	@include text-caption;
-	color: var(--color-text-muted);
-}

Frontend/src/components/shell/shared/navTreeDnd.ts

@@ -1,278 +0,0 @@
-export type NavTreeDropIntent = "before" | "after" | "inside";
-
-export type NavTreeDropTarget = {
-	parentId: string | null;
-	index: number;
-	intent: NavTreeDropIntent;
-	targetNodeId?: string;
-};
-
-export type NavTreeDragState = {
-	draggedNodeId: string;
-	dropTarget: NavTreeDropTarget | null;
-};
-
-export type NavTreeLocation<TNode> = {
-	parentId: string | null;
-	index: number;
-	node: TNode;
-};
-
-export type NavTreeAdapter<TNode> = {
-	getNodeId: (node: TNode) => string;
-	isBranchNode: (node: TNode) => boolean;
-	getChildren: (node: TNode) => readonly TNode[];
-	withChildren: (node: TNode, children: readonly TNode[]) => TNode;
-};
-
-const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-
-export const isUuidString = (value: string | null | undefined): boolean => {
-	if (typeof value !== "string") {
-		return false;
-	}
-
-	return UUID_PATTERN.test(value.trim());
-};
-
-export const collectBranchNodeIds = <TNode>(
-	nodes: readonly TNode[],
-	adapter: NavTreeAdapter<TNode>,
-): string[] => {
-	const ids: string[] = [];
-
-	for (const node of nodes) {
-		if (!adapter.isBranchNode(node)) {
-			continue;
-		}
-
-		ids.push(adapter.getNodeId(node));
-		ids.push(...collectBranchNodeIds(adapter.getChildren(node), adapter));
-	}
-
-	return ids;
-};
-
-export const findTreeNodeLocation = <TNode>(
-	nodes: readonly TNode[],
-	nodeId: string,
-	adapter: NavTreeAdapter<TNode>,
-	parentId: string | null = null,
-): NavTreeLocation<TNode> | null => {
-	for (let index = 0; index < nodes.length; index += 1) {
-		const node = nodes[index];
-
-		if (adapter.getNodeId(node) === nodeId) {
-			return { parentId, index, node };
-		}
-
-		if (!adapter.isBranchNode(node)) {
-			continue;
-		}
-
-		const nestedLocation = findTreeNodeLocation(adapter.getChildren(node), nodeId, adapter, adapter.getNodeId(node));
-		if (nestedLocation) {
-			return nestedLocation;
-		}
-	}
-
-	return null;
-};
-
-export const findTreeNodeDepth = <TNode>(
-	nodes: readonly TNode[],
-	nodeId: string,
-	adapter: NavTreeAdapter<TNode>,
-	depth = 0,
-): number | null => {
-	for (const node of nodes) {
-		if (adapter.getNodeId(node) === nodeId) {
-			return depth;
-		}
-
-		if (!adapter.isBranchNode(node)) {
-			continue;
-		}
-
-		const nestedDepth = findTreeNodeDepth(adapter.getChildren(node), nodeId, adapter, depth + 1);
-		if (nestedDepth !== null) {
-			return nestedDepth;
-		}
-	}
-
-	return null;
-};
-
-export const treeContainsNode = <TNode>(
-	nodes: readonly TNode[],
-	nodeId: string,
-	adapter: NavTreeAdapter<TNode>,
-): boolean => {
-	for (const node of nodes) {
-		if (adapter.getNodeId(node) === nodeId) {
-			return true;
-		}
-
-		if (adapter.isBranchNode(node) && treeContainsNode(adapter.getChildren(node), nodeId, adapter)) {
-			return true;
-		}
-	}
-
-	return false;
-};
-
-export const removeTreeNode = <TNode>(
-	nodes: readonly TNode[],
-	nodeId: string,
-	adapter: NavTreeAdapter<TNode>,
-): { nodes: TNode[]; removed: TNode | null } => {
-	const nextNodes: TNode[] = [];
-	let removed: TNode | null = null;
-
-	for (const node of nodes) {
-		if (adapter.getNodeId(node) === nodeId) {
-			removed = node;
-			continue;
-		}
-
-		if (adapter.isBranchNode(node)) {
-			const result = removeTreeNode(adapter.getChildren(node), nodeId, adapter);
-
-			if (result.removed) {
-				removed = result.removed;
-				nextNodes.push(adapter.withChildren(node, result.nodes));
-				continue;
-			}
-		}
-
-		nextNodes.push(node);
-	}
-
-	return { nodes: nextNodes, removed };
-};
-
-export const insertTreeNode = <TNode>(
-	nodes: readonly TNode[],
-	parentId: string | null,
-	index: number,
-	nodeToInsert: TNode,
-	adapter: NavTreeAdapter<TNode>,
-): TNode[] => {
-	if (parentId === null) {
-		const nextNodes = [...nodes];
-		nextNodes.splice(Math.max(0, Math.min(index, nextNodes.length)), 0, nodeToInsert);
-		return nextNodes;
-	}
-
-	return nodes.map((node) => {
-		if (!adapter.isBranchNode(node)) {
-			return node;
-		}
-
-		if (adapter.getNodeId(node) === parentId) {
-			const nextChildren = [...adapter.getChildren(node)];
-			nextChildren.splice(Math.max(0, Math.min(index, nextChildren.length)), 0, nodeToInsert);
-			return adapter.withChildren(node, nextChildren);
-		}
-
-		return adapter.withChildren(node, insertTreeNode(adapter.getChildren(node), parentId, index, nodeToInsert, adapter));
-	});
-};
-
-export const moveTreeNode = <TNode>(
-	nodes: readonly TNode[],
-	draggedNodeId: string,
-	dropTarget: NavTreeDropTarget,
-	adapter: NavTreeAdapter<TNode>,
-): TNode[] => {
-	const location = findTreeNodeLocation(nodes, draggedNodeId, adapter);
-
-	if (!location) {
-		return [...nodes];
-	}
-
-	if (
-		adapter.isBranchNode(location.node) &&
-		dropTarget.parentId !== null &&
-		(treeContainsNode(adapter.getChildren(location.node), dropTarget.parentId, adapter) ||
-			dropTarget.parentId === adapter.getNodeId(location.node))
-	) {
-		return [...nodes];
-	}
-
-	let normalizedIndex = dropTarget.index;
-	if (dropTarget.parentId === location.parentId && dropTarget.index > location.index) {
-		normalizedIndex -= 1;
-	}
-
-	if (dropTarget.parentId === location.parentId && normalizedIndex === location.index) {
-		return [...nodes];
-	}
-
-	const removalResult = removeTreeNode(nodes, draggedNodeId, adapter);
-	if (!removalResult.removed) {
-		return [...nodes];
-	}
-
-	return insertTreeNode(removalResult.nodes, dropTarget.parentId, normalizedIndex, removalResult.removed, adapter);
-};
-
-export const getPointerRelativeY = (event: PointerEvent): number | null => {
-	const currentTarget = event.currentTarget;
-	if (!(currentTarget instanceof HTMLElement)) {
-		return null;
-	}
-
-	const bounds = currentTarget.getBoundingClientRect();
-	return bounds.height <= 0 ? 0.5 : (event.clientY - bounds.top) / bounds.height;
-};
-
-export const resolveTreeDropTarget = <TNode>(params: {
-	parentId: string | null;
-	index: number;
-	node: TNode;
-	relativeY: number;
-	adapter: NavTreeAdapter<TNode>;
-	beforeThreshold?: number;
-	beforeThresholdFirstSibling?: number;
-	afterThreshold?: number;
-}): NavTreeDropTarget => {
-	const {
-		parentId,
-		index,
-		node,
-		relativeY,
-		adapter,
-		beforeThreshold = 0.28,
-		beforeThresholdFirstSibling = 0.42,
-		afterThreshold = 0.72,
-	} = params;
-
-	const targetNodeId = adapter.getNodeId(node);
-
-	if (adapter.isBranchNode(node)) {
-		const nextBeforeThreshold = index === 0 ? beforeThresholdFirstSibling : beforeThreshold;
-
-		if (relativeY < nextBeforeThreshold) {
-			return { parentId, index, intent: "before", targetNodeId };
-		}
-
-		if (relativeY > afterThreshold) {
-			return { parentId, index: index + 1, intent: "after", targetNodeId };
-		}
-
-		return {
-			parentId: targetNodeId,
-			index: adapter.getChildren(node).length,
-			intent: "inside",
-			targetNodeId,
-		};
-	}
-
-	return {
-		parentId,
-		index: relativeY < 0.5 ? index : index + 1,
-		intent: relativeY < 0.5 ? "before" : "after",
-		targetNodeId,
-	};
-};

Frontend/src/components/workspace-home/WorkspaceHome/WorkspaceHome.module.scss

@@ -92,6 +92,12 @@
   flex-wrap: wrap;
 }
 
+.eyebrow {
+  @include text-caption;
+  color: var(--color-text-muted);
+  text-transform: uppercase;
+}
+
 .title {
   @include text-display;
   font-family: var(--font-family-display);
@@ -240,16 +246,10 @@
   color: var(--color-text-muted);
 }
 
-.fieldHelp {
-  @include text-caption;
-  color: var(--color-text-muted);
-}
-
 .field input,
 .field select {
   min-height: var(--control-size-md);
   width: 100%;
-  font: inherit;
   border: 1px solid var(--color-border);
   border-radius: var(--radius-lg);
   background: var(--color-surface-elevated);
@@ -527,45 +527,13 @@
   }
 
   .wizardPanel {
-    width: 100vw;
+    width: calc(100vw - (var(--space-4) * 2));
-    max-height: 100dvh;
+    max-height: calc(100dvh - (var(--space-4) * 2));
-    margin: 0;
+    margin: var(--space-4) auto;
     padding: var(--space-3);
-    padding-bottom: calc(var(--space-3) + env(safe-area-inset-bottom, 0px));
-    border-radius: 0;
-  }
-
-  .wizardHeader,
-  .wizardBody,
-  .wizardSidebar {
-    gap: var(--space-3);
-  }
-
-  .wizardSteps {
-    grid-auto-flow: column;
-    grid-auto-columns: minmax(10rem, 1fr);
-    overflow-x: auto;
-    padding-bottom: var(--space-1);
-    scrollbar-width: thin;
-  }
-
-  .wizardStepButton {
-    min-width: 10rem;
   }
 
   .wizardFormActions {
     gap: var(--space-2);
-    flex-direction: column-reverse;
-    align-items: stretch;
-  }
-
-  .wizardFormActions .primaryButton {
-    margin-left: 0;
-  }
-
-  .wizardFormActions .primaryButton,
-  .wizardFormActions .secondaryButton,
-  .wizardCloseButton {
-    width: 100%;
   }
 }

Frontend/src/components/workspace-home/WorkspaceHome/WorkspaceHome.tsx

@@ -52,7 +52,6 @@ const defaultInstanceForm = {
 
 const defaultModeForm = {
 	mode: "personal",
-	name: "",
 } as const;
 
 const defaultAdminForm = {
@@ -95,52 +94,6 @@ const readResponseBody = async (response: Response): Promise<unknown> => {
 	}
 };
 
-const readResponseError = (step: BootstrapStepKey, data: unknown): string => {
-	const fallback = `Bootstrap ${step} request failed.`;
-
-	if (typeof data === "string") {
-		const message = data.trim();
-		return message || fallback;
-	}
-
-	if (!data || typeof data !== "object") {
-		return fallback;
-	}
-
-	const record = data as {
-		error?: string;
-		message?: string;
-		requestId?: string;
-	};
-	const message = typeof record.message === "string" ? record.message.trim() : "";
-	const errorCode = typeof record.error === "string" ? record.error.trim() : "";
-	const requestId = typeof record.requestId === "string" ? record.requestId.trim() : "";
-
-	if (!message && !errorCode && !requestId) {
-		return fallback;
-	}
-
-	const details: string[] = [];
-
-	if (errorCode) {
-		details.push(`code: ${errorCode}`);
-	}
-
-	if (requestId) {
-		details.push(`request: ${requestId}`);
-	}
-
-	if (message && details.length > 0) {
-		return `${message} (${details.join(", ")})`;
-	}
-
-	if (message) {
-		return message;
-	}
-
-	return `${fallback} (${details.join(", ")})`;
-};
-
 type WorkspaceHomeProps = {
 	sidebarCollapsed: boolean;
 	onToggleSidebarCollapse: () => void;
@@ -193,14 +146,15 @@ export const WorkspaceHome = (props: WorkspaceHomeProps): JSX.Element => {
 		const installationAccessor = appShellData.installation;
 		const installation = typeof installationAccessor === "function" ? installationAccessor() : undefined;
 		const isPersistedBootstrap = installation?.isBootstrapped ?? false;
-
+		const wasComplete = isBootstrapComplete();
-		if (!isPersistedBootstrap) {
-			resetWizardState();
-		}
 
 		setIsBootstrapComplete(isPersistedBootstrap);
 		setIsWizardOpen(!isPersistedBootstrap);
 		setIsBootstrapStateResolved(true);
+
+		if (!isPersistedBootstrap && wasComplete) {
+			resetWizardState();
+		}
 	});
 
 	const sidebarToggleLabel = (): string =>
@@ -209,8 +163,6 @@ export const WorkspaceHome = (props: WorkspaceHomeProps): JSX.Element => {
 	const apiBase = (): string => resolveAPIBase();
 	const bootstrapTargetLabel = (): string =>
 		modeForm.mode === "personal" ? "Personal server" : "Organization server";
-	const bootstrapNamePlaceholder = (): string =>
-		modeForm.mode === "personal" ? "Personal server name" : "Organization server name";
 	const currentStep = createMemo<BootstrapStepDefinition>(
 		() => bootstrapStepDefinitions[currentStepIndex()] ?? bootstrapStepDefinitions[0]!,
 	);
@@ -248,7 +200,11 @@ export const WorkspaceHome = (props: WorkspaceHomeProps): JSX.Element => {
 			const data = await readResponseBody(response);
 
 			if (!response.ok) {
-				throw new Error(readResponseError(step, data));
+				throw new Error(
+					typeof data?.error?.message === "string"
+						? data.error.message
+						: `Bootstrap ${step} request failed.`,
+				);
 			}
 
 			setStepState(step, {
@@ -360,6 +316,7 @@ export const WorkspaceHome = (props: WorkspaceHomeProps): JSX.Element => {
 				</div>
 
 				<section class={styles.hero} data-slot="workspace-home-hero">
+					<span class={styles.eyebrow}>Bootstrap</span>
 					<h1 class={styles.title}>{isBootstrapComplete() ? appShellData.activeServer().name : bootstrapTargetLabel()}</h1>
 					<Show when={isBootstrapStateResolved() && !isBootstrapComplete()}>
 						<div class={styles.heroActions}>
@@ -457,27 +414,15 @@ export const WorkspaceHome = (props: WorkspaceHomeProps): JSX.Element => {
 											</>
 										</Show>
 
-						<Show when={currentStep().id === "mode"}>
+										<Show when={currentStep().id === "mode"}>
-							<>
+											<label class={styles.field}>
-								<label class={styles.field}>
+												<span class={styles.fieldLabel}>Mode</span>
-									<span class={styles.fieldLabel}>Mode</span>
+												<select value={modeForm.mode} onInput={(event): void => setModeForm("mode", event.currentTarget.value)}>
-									<select value={modeForm.mode} onInput={(event): void => setModeForm("mode", event.currentTarget.value)}>
+													<option value="personal">personal</option>
-										<option value="personal">personal</option>
+													<option value="organizational">organizational</option>
-										<option value="organizational">organizational</option>
+												</select>
-									</select>
+											</label>
-								</label>
+										</Show>
-								<label class={styles.field}>
-									<span class={styles.fieldLabel}>Server name</span>
-									<input
-										type="text"
-										value={modeForm.name}
-										required
-										onInput={(event): void => setModeForm("name", event.currentTarget.value)}
-										placeholder={bootstrapNamePlaceholder()}
-									/>
-								</label>
-							</>
-						</Show>
 
 										<Show when={currentStep().id === "admin"}>
 											<>
@@ -501,16 +446,13 @@ export const WorkspaceHome = (props: WorkspaceHomeProps): JSX.Element => {
 												</label>
 												<label class={styles.field}>
 													<span class={styles.fieldLabel}>Password</span>
-												<input
+													<input
-													type="password"
+														type="password"
-													value={adminForm.password}
+														value={adminForm.password}
-													onInput={(event): void => setAdminForm("password", event.currentTarget.value)}
+														onInput={(event): void => setAdminForm("password", event.currentTarget.value)}
-													placeholder="Create a strong password"
+														placeholder="Temporary for echo testing"
-												/>
+													/>
-												<small class={styles.fieldHelp}>
+												</label>
-													Use at least 12 characters with uppercase, lowercase, numbers, and symbols.
-												</small>
-											</label>
 											</>
 										</Show>
 

Frontend/src/lib/icons/index.ts

@@ -10,7 +10,6 @@ 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";
@@ -19,6 +18,5 @@ 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";

Justfile

@@ -1,7 +1,6 @@
 set shell := ["bash", "-cu"]
 
 mod local "Commands/Local"
-mod test "Commands/Test"
 
 [default]
 help: