Merge branch 'Features/Backend/Posix-Lite-Persistence'

.gitignore

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

Backend/db/migrations/000003_installation_name.sql

@@ -0,0 +1,9 @@
+-- +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/internal/bootstrap/service.go

@@ -4,8 +4,11 @@ package bootstrap
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
+	"os"
+	"path/filepath"
 	"strings"
 
 	"github.com/jackc/pgx/v5"
@@ -42,6 +45,7 @@ var (
 
 type Service struct {
 	db        *database.DB
+	posixRoot string
 }
 
 type SaveInstanceInput struct {
@@ -52,6 +56,7 @@ type SaveInstanceInput struct {
 
 type SaveModeInput struct {
 	Mode string
+	Name string
 }
 
 type SaveAdminInput struct {
@@ -69,6 +74,7 @@ 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"`
@@ -170,15 +176,16 @@ type namedRecord struct {
 	Slug string `json:"slug"`
 }
 
-func NewService(db *database.DB) *Service {
+func NewService(db *database.DB, posixRoot string) *Service {
-	return &Service{db: db}
+	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, mode, access, protocol, host)
+		INSERT INTO installations (singleton, name, 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,
@@ -190,7 +197,7 @@ func (service *Service) SaveInstance(ctx context.Context, input SaveInstanceInpu
 			protocol = EXCLUDED.protocol,
 			host = EXCLUDED.host,
 			updated_at = NOW()
-		RETURNING id::text, mode::text, access::text, protocol::text, host, is_bootstrapped;
+		RETURNING id::text, name, mode::text, access::text, protocol::text, host, is_bootstrapped;
 	`, input.Access, input.Protocol, input.Host)
 
 	return scanInstallationRecord(row)
@@ -198,20 +205,22 @@ 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, mode, access, protocol, host)
+		INSERT INTO installations (singleton, name, 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), $2)
+			COALESCE((SELECT host FROM installations WHERE singleton = TRUE LIMIT 1), $3)
 		)
 		ON CONFLICT (singleton) DO UPDATE
 		SET
+			name = EXCLUDED.name,
 			mode = EXCLUDED.mode,
 			updated_at = NOW()
-		RETURNING id::text, mode::text, access::text, protocol::text, host, is_bootstrapped;
+		RETURNING id::text, name, mode::text, access::text, protocol::text, host, is_bootstrapped;
-	`, input.Mode, defaultInstallationHost)
+	`, input.Mode, input.Name, defaultInstallationHost)
 
 	return scanInstallationRecord(row)
 }
@@ -301,7 +310,7 @@ func (service *Service) SaveStructure(ctx context.Context, input SaveStructureIn
 
 	organizationName := strings.TrimSpace(input.OrganizationName)
 	if organizationName == "" {
-		organizationName = defaultRootOrganizationName(installation.Mode, installation.Host, admin.DisplayName)
+		organizationName = defaultRootOrganizationName(installation.Name, installation.Mode, installation.Host, admin.DisplayName)
 	}
 
 	organization, err := upsertNamedRecord(ctx, tx, `
@@ -400,6 +409,10 @@ 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
+	}
+
 	return StructureRecord{
 		Installation: installation,
 		Organization: organization,
@@ -442,7 +455,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, mode::text, access::text, protocol::text, host, is_bootstrapped
+		SELECT id::text, name, mode::text, access::text, protocol::text, host, is_bootstrapped
 		FROM installations
 		WHERE singleton = TRUE
 		LIMIT 1;
@@ -597,7 +610,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.Mode, &record.Access, &record.Protocol, &record.Host, &record.IsBootstrapped); err != nil {
+	if err := row.Scan(&record.ID, &record.Name, &record.Mode, &record.Access, &record.Protocol, &record.Host, &record.IsBootstrapped); err != nil {
 		return InstallationRecord{}, err
 	}
 
@@ -802,7 +815,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, mode::text, access::text, protocol::text, host, is_bootstrapped
+		SELECT id::text, name, mode::text, access::text, protocol::text, host, is_bootstrapped
 		FROM installations
 		WHERE singleton = TRUE
 		LIMIT 1;
@@ -829,7 +842,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, mode::text, access::text, protocol::text, host, is_bootstrapped;
+		RETURNING id::text, name, mode::text, access::text, protocol::text, host, is_bootstrapped;
 	`))
 }
 
@@ -860,10 +873,15 @@ func upsertWorkspace(ctx context.Context, tx pgx.Tx, organizationID, name, slug,
 	return err
 }
 
-func defaultRootOrganizationName(mode, host, adminDisplayName string) string {
+func defaultRootOrganizationName(installationName, 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)
@@ -891,3 +909,173 @@ 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, "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(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 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

@@ -0,0 +1,113 @@
+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", "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"])
+	}
+
+	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 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,6 +17,7 @@ type Config struct {
 	APIPort         string
 	PostgresURL     string
 	ValkeyURL       string
+	POSIXRoot       string
 	ShutdownTimeout time.Duration
 }
 
@@ -29,6 +30,7 @@ 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,6 +20,7 @@ type bootstrapInstanceStepRequest struct {
 
 type bootstrapModeStepRequest struct {
 	Mode string `json:"mode"`
+	Name string `json:"name"`
 }
 
 type bootstrapAdminStepRequest struct {
@@ -234,13 +235,19 @@ 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
 	}
 
-	record, err := routes.bootstrapService().SaveMode(r.Context(), bootstrapservice.SaveModeInput{Mode: payload.Mode})
+	if payload.Name == "" {
+		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
@@ -334,7 +341,7 @@ func (routes apiRoutes) handleBootstrapStructureStep(w http.ResponseWriter, r *h
 }
 
 func (routes apiRoutes) bootstrapService() *bootstrapservice.Service {
-	return bootstrapservice.NewService(routes.cfg.Database)
+	return bootstrapservice.NewService(routes.cfg.Database, routes.cfg.Config.POSIXRoot)
 }
 
 func (routes apiRoutes) writeBootstrapStepResponse(w http.ResponseWriter, status int, step string, payload any) {
@@ -356,7 +363,11 @@ 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)
-		WriteError(w, http.StatusInternalServerError, RequestIDFromContext(r.Context()), "bootstrap_persist_failed", "Failed to persist bootstrap data.")
+		message := "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)
 	}
 }
 

Commands/Local/Dev/backend.just

@@ -9,10 +9,14 @@ migrate-up:
 migrate-down:
 	cd '{{backend_dir}}' && go run ./cmd/migrate down
 
-# Reset all embedded database migrations and reapply from scratch.
+# Reset all embedded database migrations.
 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
@@ -20,7 +24,3 @@ migrate-status:
 # 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

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

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

Docker/docker-compose.local.dev.yaml

@@ -6,6 +6,7 @@ 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
@@ -13,6 +14,7 @@ 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,11 +5,14 @@ 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

@@ -0,0 +1,61 @@
+# POSIX Structure
+
+``` 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
+│       └── 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,87 +4,149 @@
 
 ### Version 0.1.0
 
-**Goal:** Barebone frontend with a real backend core.
+**Goal:** Finish the base application shell, auth, and platform foundations.
 
-#### Architecture
+#### Architecture and Delivery
 
-- [ ] Project-Structure
+- [x] Project-Structure
-- [ ] Stack-Decisions
+- [x] Stack-Decisions
-- [ ] Proxy
+- [x] Proxy
-  - [ ] Local-Prod-NGINX-Proxy
+  - [x] Local-Dev-Vite-Proxy
-  - [ ] Static-Frontend-Serving
+  - [x] Local-Prod-NGINX-Proxy
-- [ ] First-Request-Web-Loader
+- [x] First-Request-Web-Loader
-  - [ ] Bootstrap-Document
+  - [x] Bootstrap-Document
-  - [ ] Route-Intent-Handoff
+  - [x] Route-Intent-Handoff
-  - [ ] Tiny-First-Paint-Budget
+  - [x] Tiny-First-Paint-Budget
-- [ ] Dev-and-Prod-Builds
+- [x] Dev-and-Prod-Builds
   - [x] Local-Dev-Just-Commands
   - [x] Local-Dev-Docker-Compose
-  - [ ] Local-Prod-Just-Commands
+  - [x] Local-Prod-Just-Commands
-  - [ ] Local-Prod-Docker-Compose
+  - [x] Local-Prod-Docker-Compose
-  - [ ] Frontend-Production-Dockerfile
+  - [x] Frontend-Production-Dockerfile
-  - [ ] Frontend-docker-bake
+  - [x] Frontend-docker-bake
 
-#### Backend
+#### Backend — Done Foundations
+
+- [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
-- [ ] User
+- [ ] Current-User-Implementation
-  - [ ] Base-Model
+- [ ] POSIX-Lite-File-Persistence-Foundation
+  - [ ] 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
-    - [ ] Folders-and-Subfolders
   - [ ] 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
+#### Frontend — Done Foundations
 
 - [x] Foundation
 - [x] Typography
 - [x] Icons
-- [ ] App Shell
+- [x] 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
-- [ ] Workspace-Home
+- [ ] Real-Workspace-Home
+- [ ] Real-Workspace-Tree-Hydration
+- [ ] Create-Project-Flow
+- [ ] Persist-Tree-Mutations
+- [ ] Connect-Tree-Interactions-To-Backend-Data
 
 ### Version 0.2.0
 
-**Goal:** First real work surface.
+**Goal:** Build the plugin app system on top of the base platform. And core app plugins like calendar, board, docs and text channels
-
-- [ ] 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:** Documents and system hardening.
+**Goal:** Communications and Collaboration (Email System, Reminder System, and Live Collaboration on Documents)
-
-- [ ] Document
-- [ ] Accessibility-Rules
-- [ ] Motion-Foundation
 
 ### Version 0.4.0
 
-- [ ] Gantt-Board
+**Goal:** Introduce the POSIX-based file system drive direction with OnlyOffice + S3 blob storage + Per File Versioning
-- [ ] Calendar
+
-- [ ] Timeline
+### Version 0.5.0
+
+**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,6 +10,7 @@ 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

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

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

@@ -9,6 +9,15 @@
   justify-items: center;
 }
 
+.rootDragMode {
+	user-select: none;
+	cursor: grabbing;
+}
+
+.rootDragMode .treeItem {
+	cursor: grabbing;
+}
+
 .trigger {
   width: 100%;
   min-width: 0;
@@ -38,9 +47,9 @@
 }
 
 .triggerOpen {
-  border-color: color-mix(in srgb, var(--color-border-strong) 22%, transparent);
+  border-color: color-mix(in srgb, var(--color-accent-strong) 22%, var(--color-border-strong));
-  background: color-mix(in srgb, var(--color-surface) 92%, transparent);
+  background: color-mix(in srgb, var(--color-accent-soft) 26%, var(--color-surface));
-  box-shadow: var(--shadow-soft);
+  box-shadow: 0 10px 28px color-mix(in srgb, black 8%, transparent);
 }
 
 .triggerCompact {
@@ -83,19 +92,14 @@
   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;
 }
 
@@ -175,7 +179,7 @@
   min-height: 0;
   display: grid;
   align-content: start;
-  gap: var(--space-3);
+  gap: var(--space-2);
   padding: var(--space-4);
   overflow-y: auto;
   overscroll-behavior: contain;
@@ -186,49 +190,148 @@
 	width: 0;
 }
 
-.projectList {
+.treeSectionLabel {
+  @include text-caption;
+  margin: 0 0 var(--space-2);
+  padding: 0 var(--space-3);
+  color: var(--color-text-subtle);
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+}
+
+.treeList {
   list-style: none;
   display: grid;
-  gap: 0.2rem;
+  gap: var(--space-1);
   padding: 0;
 }
 
-.projectItem {
+.treeEmptySlot {
+	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;
+}
+
+.treeInputRow {
 	width: 100%;
 	min-width: 0;
-  min-height: calc(var(--control-size-md) + var(--space-2));
+	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);
+}
+
+.treeInput {
+	width: 100%;
+	min-width: 0;
+	border: 0;
+	background: transparent;
+	color: var(--color-text);
+	font: inherit;
+	outline: none;
+}
+
+.treeInput::placeholder {
+	color: var(--color-text-muted);
+}
+
+.treeItem {
+  width: 100%;
+  min-width: 0;
+  display: grid;
+  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: 1px solid transparent;
-  border-radius: var(--radius-sm);
+  border-radius: var(--radius-lg);
   background: transparent;
   color: var(--color-text-muted);
   transition:
     background 160ms var(--easing-standard),
     color 160ms var(--easing-standard),
     border-color 160ms var(--easing-standard),
+    box-shadow 160ms var(--easing-standard),
     transform 180ms var(--easing-standard);
   text-align: left;
 }
 
-.projectItem:hover {
+.treeItem:hover,
-  background: color-mix(in srgb, var(--color-surface-hover) 82%, transparent);
+.treeItem:focus-visible {
+  background: color-mix(in srgb, var(--color-surface-hover) 80%, var(--color-accent-soft) 20%);
   color: var(--color-text);
-  border-color: color-mix(in srgb, var(--color-border) 22%, transparent);
+  box-shadow: inset 0 1px 0 color-mix(in srgb, white 4%, transparent);
 }
 
-.projectItemActive {
+.treeItemFolder {
-  border-color: color-mix(in srgb, var(--color-border) 28%, transparent);
-  background: color-mix(in srgb, var(--color-surface) 82%, transparent);
   color: var(--color-text);
+}
+
+.treeItemDragging {
+	opacity: 0.45;
+	transform: scale(0.985);
 	box-shadow: none;
 }
 
-.projectItemCopy {
+.treeItemDropBefore {
-  min-width: 0;
+	box-shadow: inset 0 2px 0 color-mix(in srgb, var(--color-accent-strong) 78%, transparent);
-  display: grid;
-  gap: 0.05rem;
 }
 
-.projectItemDescription {
+.treeItemDropAfter {
-  color: color-mix(in srgb, var(--color-text-muted) 84%, transparent);
+	box-shadow: inset 0 -2px 0 color-mix(in srgb, var(--color-accent-strong) 78%, transparent);
+}
+
+.treeItemDropInside {
+	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));
+	color: var(--color-text);
+	box-shadow: inset 0 1px 0 color-mix(in srgb, white 4%, transparent);
+}
+
+.folderChevron {
+  color: var(--color-text-muted);
+  transition: transform 160ms var(--easing-standard);
+}
+
+.folderChevronOpen {
+  transform: rotate(90deg);
+}
+
+.treeItemActive {
+  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);
+}
+
+.icon {
+  color: inherit;
+  opacity: 0.85;
+}
+
+.label {
+  @include text-label;
+  min-width: 0;
+}
+
+.itemMeta {
+  @include text-caption;
+  color: var(--color-text-muted);
+}
+
+@media (max-width: 720px) {
+  .rootCompact .scrim,
+  .rootCompact .drawer {
+    width: min(18rem, calc(100vw - 5rem));
+  }
 }

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

@@ -1,8 +1,17 @@
 // Path: Frontend/src/components/shell/ProjectSelector/ProjectSelector.tsx
 
-import { For, createEffect, createSignal, onCleanup, onMount, type JSX } from "solid-js";
+import { For, Show, createEffect, createSignal, onCleanup, onMount, type JSX } from "solid-js";
-import { ChevronDown, Folder } from "../../../lib/icons";
+import { ChevronDown, ChevronRight, Folder, LayoutGrid } from "../../../lib/icons";
+import { ProjectContextMenu } from "../ProjectContextMenu/ProjectContextMenu";
 import { useAppShellData } from "../data/app-shell.context";
+import {
+	createProjectFolderTarget,
+	createProjectSurfaceTarget,
+	createProjectTarget,
+	type ProjectItem,
+	type ProjectMenuTarget,
+} from "../data/shell.data";
+import { createProjectContextMenuController } from "../ProjectContextMenu/createProjectContextMenuController";
 import styles from "./ProjectSelector.module.scss";
 
 type ProjectSelectorProps = {
@@ -12,27 +21,532 @@ type ProjectSelectorProps = {
 	onClose: () => void;
 };
 
+type ProjectFolderNode = {
+	kind: "folder";
+	id: string;
+	label: string;
+	meta?: string;
+	children: ProjectTreeNode[];
+};
+
+type ProjectLeafNode = {
+	kind: "project";
+	item: ProjectItem;
+};
+
+type ProjectTreeNode = ProjectFolderNode | ProjectLeafNode;
+
+type PendingProjectFolderDraft = {
+	parentId: string | null;
+	depth: number;
+};
+
+type ProjectDragTarget = {
+	parentId: string | null;
+	index: number;
+	intent: "before" | "after" | "inside";
+	targetNodeId?: string;
+};
+
+type ProjectDragState = {
+	draggedNodeId: string;
+	dropTarget: ProjectDragTarget | null;
+};
+
+type ProjectNodeLocation = {
+	parentId: string | null;
+	index: number;
+	node: ProjectTreeNode;
+};
+
+const LONG_PRESS_MS = 320;
+
+const createProjectFolderId = (): string => `project-folder-${Math.random().toString(36).slice(2, 10)}`;
+
+const getProjectTreeNodeId = (node: ProjectTreeNode): string =>
+	node.kind === "folder" ? node.id : node.item.id;
+
+const buildProjectTree = (items: readonly ProjectItem[]): ProjectTreeNode[] =>
+	items.map((item) => ({
+		kind: "project",
+		item,
+	}));
+
+const cloneProjectTreeNode = (node: ProjectTreeNode): ProjectTreeNode => {
+	if (node.kind === "project") {
+		return {
+			kind: "project",
+			item: { ...node.item },
+		};
+	}
+
+	return {
+		kind: "folder",
+		id: node.id,
+		label: node.label,
+		meta: node.meta,
+		children: node.children.map(cloneProjectTreeNode),
+	};
+};
+
+const insertProjectFolderNode = (
+	nodes: readonly ProjectTreeNode[],
+	parentId: string | null,
+	folder: ProjectFolderNode,
+): ProjectTreeNode[] => {
+	if (parentId === null) {
+		return [...nodes, folder];
+	}
+
+	return nodes.map((node) => {
+		if (node.kind !== "folder") {
+			return node;
+		}
+
+		if (node.id === parentId) {
+			return {
+				...node,
+				children: [...node.children, folder],
+			};
+		}
+
+		return {
+			...node,
+			children: insertProjectFolderNode(node.children, parentId, folder),
+		};
+	});
+};
+
+const findProjectNodeLocation = (
+	nodes: readonly ProjectTreeNode[],
+	nodeId: string,
+	parentId: string | null = null,
+): ProjectNodeLocation | null => {
+	for (let index = 0; index < nodes.length; index += 1) {
+		const node = nodes[index];
+
+		if (getProjectTreeNodeId(node) === nodeId) {
+			return { parentId, index, node };
+		}
+
+		if (node.kind === "folder") {
+			const nestedLocation = findProjectNodeLocation(node.children, nodeId, node.id);
+
+			if (nestedLocation) {
+				return nestedLocation;
+			}
+		}
+	}
+
+	return null;
+};
+
+const findProjectNodeDepth = (nodes: readonly ProjectTreeNode[], nodeId: string, depth = 0): number | null => {
+	for (const node of nodes) {
+		if (getProjectTreeNodeId(node) === nodeId) {
+			return depth;
+		}
+
+		if (node.kind === "folder") {
+			const nestedDepth = findProjectNodeDepth(node.children, nodeId, depth + 1);
+
+			if (nestedDepth !== null) {
+				return nestedDepth;
+			}
+		}
+	}
+
+	return null;
+};
+
+const projectTreeContainsNode = (nodes: readonly ProjectTreeNode[], nodeId: string): boolean => {
+	for (const node of nodes) {
+		if (getProjectTreeNodeId(node) === nodeId) {
+			return true;
+		}
+
+		if (node.kind === "folder" && projectTreeContainsNode(node.children, nodeId)) {
+			return true;
+		}
+	}
+
+	return false;
+};
+
+const removeProjectTreeNode = (
+	nodes: readonly ProjectTreeNode[],
+	nodeId: string,
+): { nodes: ProjectTreeNode[]; removed: ProjectTreeNode | null } => {
+	const nextNodes: ProjectTreeNode[] = [];
+	let removed: ProjectTreeNode | null = null;
+
+	for (const node of nodes) {
+		if (getProjectTreeNodeId(node) === nodeId) {
+			removed = node;
+			continue;
+		}
+
+		if (node.kind === "folder") {
+			const result = removeProjectTreeNode(node.children, nodeId);
+
+			if (result.removed) {
+				removed = result.removed;
+				nextNodes.push({
+					...node,
+					children: result.nodes,
+				});
+				continue;
+			}
+		}
+
+		nextNodes.push(node);
+	}
+
+	return { nodes: nextNodes, removed };
+};
+
+const insertProjectTreeNode = (
+	nodes: readonly ProjectTreeNode[],
+	parentId: string | null,
+	index: number,
+	nodeToInsert: ProjectTreeNode,
+): ProjectTreeNode[] => {
+	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 (node.kind !== "folder") {
+			return node;
+		}
+
+		if (node.id === parentId) {
+			const nextChildren = [...node.children];
+			nextChildren.splice(Math.max(0, Math.min(index, nextChildren.length)), 0, nodeToInsert);
+			return {
+				...node,
+				children: nextChildren,
+			};
+		}
+
+		return {
+			...node,
+			children: insertProjectTreeNode(node.children, parentId, index, nodeToInsert),
+		};
+	});
+};
+
+const moveProjectTreeNode = (
+	nodes: readonly ProjectTreeNode[],
+	draggedNodeId: string,
+	dropTarget: ProjectDragTarget,
+): ProjectTreeNode[] => {
+	const location = findProjectNodeLocation(nodes, draggedNodeId);
+
+	if (!location) {
+		return [...nodes];
+	}
+
+	if (
+		location.node.kind === "folder" &&
+		dropTarget.parentId !== null &&
+		(projectTreeContainsNode(location.node.children, dropTarget.parentId) || dropTarget.parentId === location.node.id)
+	) {
+		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 = removeProjectTreeNode(nodes, draggedNodeId);
+
+	if (!removalResult.removed) {
+		return [...nodes];
+	}
+
+	return insertProjectTreeNode(removalResult.nodes, dropTarget.parentId, normalizedIndex, removalResult.removed);
+};
+
+const ProjectFolderDraftRow = (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 ProjectFolderBranch = (props: {
+	nodes: readonly ProjectTreeNode[];
+	depth: number;
+	parentId: string | null;
+	selectedProjectId: string;
+	isFolderCollapsed: (folderId: string) => boolean;
+	onToggleFolder: (folderId: string) => void;
+	onSelectProject: (projectId: string) => void;
+	onOpenFolderMenu: (event: MouseEvent, folder: ProjectFolderNode) => void;
+	onOpenProjectMenu: (event: MouseEvent, item: ProjectItem) => void;
+	onNodePointerDown: (event: PointerEvent, nodeId: string) => void;
+	onNodePointerMove: (event: PointerEvent, parentId: string | null, index: number, node: ProjectTreeNode) => void;
+	pendingFolderDraft: PendingProjectFolderDraft | null;
+	pendingFolderName: string;
+	onPendingFolderNameChange: (value: string) => void;
+	onSubmitPendingFolder: () => void;
+	onCancelPendingFolder: () => void;
+	dragState: ProjectDragState | null;
+}): JSX.Element => (
+	<ul class={styles.treeList} role="list">
+		<Show when={props.nodes.length === 0 && props.pendingFolderDraft?.parentId !== props.parentId}>
+			<li>
+				<div class={styles.treeEmptySlot} style={{ "--tree-depth": String(props.depth) }} />
+			</li>
+		</Show>
+
+		<For each={props.nodes}>
+			{(node, indexAccessor): JSX.Element => {
+				const nodeId = (): string => getProjectTreeNodeId(node);
+				const isDraggedNode = (): boolean => props.dragState?.draggedNodeId === nodeId();
+				const dropIntent = (): ProjectDragTarget["intent"] | null => {
+					if (props.dragState?.dropTarget?.targetNodeId !== nodeId()) {
+						return null;
+					}
+
+					return props.dragState.dropTarget.intent;
+				};
+
+				if (node.kind === "folder") {
+					const isCollapsed = (): boolean => props.isFolderCollapsed(node.id);
+
+					return (
+						<li>
+							<button
+								type="button"
+								classList={{
+									[styles.treeItem]: true,
+									[styles.treeItemFolder]: true,
+									[styles.treeItemDragging]: isDraggedNode(),
+									[styles.treeItemDropBefore]: dropIntent() === "before",
+									[styles.treeItemDropAfter]: dropIntent() === "after",
+									[styles.treeItemDropInside]: dropIntent() === "inside",
+								}}
+								style={{ "--tree-depth": String(props.depth) }}
+								aria-expanded={!isCollapsed()}
+								onClick={() => {
+									if (props.dragState || suppressNextTreeClick()) {
+										return;
+									}
+
+									props.onToggleFolder(node.id);
+								}}
+								onContextMenu={(event): void => props.onOpenFolderMenu(event, node)}
+								onPointerDown={(event): void => props.onNodePointerDown(event, node.id)}
+								onPointerMove={(event): void =>
+									props.onNodePointerMove(event, props.parentId, indexAccessor(), node)
+								}
+								onPointerEnter={(event): void =>
+									props.onNodePointerMove(event, props.parentId, indexAccessor(), node)
+								}
+							>
+								<ChevronRight
+									classList={{
+										[styles.folderChevron]: true,
+										[styles.folderChevronOpen]: !isCollapsed(),
+									}}
+									size={16}
+									strokeWidth={2}
+								/>
+								<Folder 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>
+
+							<Show when={!isCollapsed() && (node.children.length > 0 || props.pendingFolderDraft?.parentId === node.id)}>
+								<ProjectFolderBranch
+									nodes={node.children}
+									depth={props.depth + 1}
+									parentId={node.id}
+									selectedProjectId={props.selectedProjectId}
+									isFolderCollapsed={props.isFolderCollapsed}
+									onToggleFolder={props.onToggleFolder}
+									onSelectProject={props.onSelectProject}
+									onOpenFolderMenu={props.onOpenFolderMenu}
+									onOpenProjectMenu={props.onOpenProjectMenu}
+									onNodePointerDown={props.onNodePointerDown}
+									onNodePointerMove={props.onNodePointerMove}
+									pendingFolderDraft={props.pendingFolderDraft}
+									pendingFolderName={props.pendingFolderName}
+									onPendingFolderNameChange={props.onPendingFolderNameChange}
+									onSubmitPendingFolder={props.onSubmitPendingFolder}
+									onCancelPendingFolder={props.onCancelPendingFolder}
+									dragState={props.dragState}
+								/>
+							</Show>
+						</li>
+					);
+				}
+
+				return (
+					<li>
+						<button
+							type="button"
+							classList={{
+								[styles.treeItem]: true,
+								[styles.treeItemActive]: props.selectedProjectId === node.item.id,
+								[styles.treeItemDragging]: isDraggedNode(),
+								[styles.treeItemDropBefore]: dropIntent() === "before",
+								[styles.treeItemDropAfter]: dropIntent() === "after",
+							}}
+							style={{ "--tree-depth": String(props.depth) }}
+							onClick={(): void => {
+								if (props.dragState || suppressNextTreeClick()) {
+									return;
+								}
+
+								props.onSelectProject(node.item.id);
+							}}
+							onContextMenu={(event): void => props.onOpenProjectMenu(event, node.item)}
+							onPointerDown={(event): void => props.onNodePointerDown(event, node.item.id)}
+							onPointerMove={(event): void =>
+								props.onNodePointerMove(event, props.parentId, indexAccessor(), node)
+							}
+							onPointerEnter={(event): void =>
+								props.onNodePointerMove(event, props.parentId, indexAccessor(), node)
+							}
+						>
+							<LayoutGrid class={styles.icon} size={18} strokeWidth={2} />
+							<span class={styles.label}>{node.item.name}</span>
+							<Show when={node.item.meta}>
+								<span class={styles.itemMeta}>{node.item.meta}</span>
+							</Show>
+						</button>
+					</li>
+				);
+			}}
+		</For>
+
+		<Show when={props.pendingFolderDraft?.parentId === props.parentId}>
+			<ProjectFolderDraftRow
+				depth={props.pendingFolderDraft?.depth ?? props.depth}
+				value={props.pendingFolderName}
+				onInput={props.onPendingFolderNameChange}
+				onSubmit={props.onSubmitPendingFolder}
+				onCancel={props.onCancelPendingFolder}
+			/>
+		</Show>
+	</ul>
+);
+
 export const ProjectSelector = (props: ProjectSelectorProps): JSX.Element => {
 	const appShellData = useAppShellData();
 	const [selectedProject, setSelectedProject] = createSignal(appShellData.activeProject());
 	const [drawerTop, setDrawerTop] = createSignal<number>(0);
+	const [collapsedFolderIds, setCollapsedFolderIds] = createSignal<readonly string[]>([]);
+	const [projectTreeNodes, setProjectTreeNodes] = createSignal<ProjectTreeNode[]>(
+		buildProjectTree(appShellData.projectItems()),
+	);
+	const [pendingFolderDraft, setPendingFolderDraft] = createSignal<PendingProjectFolderDraft | null>(null);
+	const [pendingFolderName, setPendingFolderName] = createSignal("");
+	const [dragState, setDragState] = createSignal<ProjectDragState | null>(null);
+	const [suppressNextTreeClick, setSuppressNextTreeClick] = createSignal(false);
+	let rootRef: HTMLDivElement | undefined;
 	let triggerRef: HTMLButtonElement | undefined;
+	let contextMenuRef: HTMLDivElement | undefined;
+	let longPressTimer: number | undefined;
+	let suppressClickTimer: number | undefined;
+	const contextMenu = createProjectContextMenuController();
+
+	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);
+	};
+
+	const isFolderCollapsed = (folderId: string): boolean => collapsedFolderIds().includes(folderId);
+
+	const toggleFolder = (folderId: string): void => {
+		setCollapsedFolderIds((current) =>
+			current.includes(folderId) ? current.filter((id) => id !== folderId) : [...current, folderId],
+		);
+	};
 
 	createEffect(() => {
 		setSelectedProject(appShellData.activeProject());
 	});
 
-	onMount(() => {
+	createEffect(() => {
-		if (!triggerRef) {
+		setProjectTreeNodes(buildProjectTree(appShellData.projectItems()));
-			return;
+		setCollapsedFolderIds([]);
-		}
+		setPendingFolderDraft(null);
+		setPendingFolderName("");
+		setDragState(null);
+	});
 
+	onMount(() => {
+		if (triggerRef) {
 			const updateDrawerTop = (): void => {
 				if (!triggerRef) {
 					return;
 				}
 
-			setDrawerTop(triggerRef.offsetTop + triggerRef.offsetHeight);
+				setDrawerTop(triggerRef.offsetTop + triggerRef.offsetHeight + 8);
 			};
 
 			updateDrawerTop();
@@ -48,6 +562,81 @@ export const ProjectSelector = (props: ProjectSelectorProps): JSX.Element => {
 				observer.disconnect();
 				window.removeEventListener("resize", updateDrawerTop);
 			});
+		}
+
+		const handlePointerDown = (event: PointerEvent): void => {
+			if (!props.isOpen || !rootRef) {
+				return;
+			}
+
+			const target = event.target;
+
+			if (target instanceof Node && rootRef.contains(target)) {
+				return;
+			}
+
+			if (target instanceof Node && contextMenuRef?.contains(target)) {
+				return;
+			}
+
+			props.onClose();
+		};
+
+		const handlePointerUp = (): void => {
+			clearLongPressTimer();
+
+			const nextDragState = dragState();
+
+			if (!nextDragState?.dropTarget) {
+				if (nextDragState) {
+					suppressTreeClickTemporarily();
+				}
+				setDragState(null);
+				return;
+			}
+
+			suppressTreeClickTemporarily();
+			setProjectTreeNodes((current) =>
+				moveProjectTreeNode(current, nextDragState.draggedNodeId, nextDragState.dropTarget as ProjectDragTarget),
+			);
+			setDragState(null);
+		};
+
+		const handleEscape = (event: KeyboardEvent): void => {
+			if (event.key !== "Escape") {
+				return;
+			}
+
+			clearLongPressTimer();
+
+			if (dragState()) {
+				setDragState(null);
+				return;
+			}
+
+			if (!props.isOpen) {
+				return;
+			}
+
+			props.onClose();
+			triggerRef?.focus();
+		};
+
+		document.addEventListener("pointerdown", handlePointerDown);
+		window.addEventListener("pointerup", handlePointerUp);
+		window.addEventListener("pointercancel", handlePointerUp);
+		window.addEventListener("keydown", handleEscape);
+
+		onCleanup(() => {
+			clearLongPressTimer();
+			if (suppressClickTimer !== undefined) {
+				window.clearTimeout(suppressClickTimer);
+			}
+			document.removeEventListener("pointerdown", handlePointerDown);
+			window.removeEventListener("pointerup", handlePointerUp);
+			window.removeEventListener("pointercancel", handlePointerUp);
+			window.removeEventListener("keydown", handleEscape);
+		});
 	});
 
 	const toggleOpen = (): void => {
@@ -60,27 +649,163 @@ export const ProjectSelector = (props: ProjectSelectorProps): JSX.Element => {
 	};
 
 	const selectProject = (projectId: string): void => {
-		const nextProject = appShellData.projectItems().find((item): boolean => item.id === projectId);
+		const location = findProjectNodeLocation(projectTreeNodes(), projectId);
 
-		if (!nextProject) {
+		if (!location || location.node.kind !== "project") {
 			return;
 		}
 
-		setSelectedProject({ id: nextProject.id, name: nextProject.name });
+		setSelectedProject({ id: location.node.item.id, name: location.node.item.name });
 		props.onClose();
 	};
 
+	const beginFolderDraft = (parentId: string | null, depth: number): void => {
+		if (parentId) {
+			setCollapsedFolderIds((current) => current.filter((id) => id !== parentId));
+		}
+
+		setPendingFolderName("");
+		setPendingFolderDraft({ parentId, depth });
+	};
+
+	const submitPendingFolder = (): void => {
+		const name = pendingFolderName().trim();
+		const draft = pendingFolderDraft();
+
+		if (!draft) {
+			return;
+		}
+
+		if (!name) {
+			setPendingFolderDraft(null);
+			setPendingFolderName("");
+			return;
+		}
+
+		setProjectTreeNodes((current) =>
+			insertProjectFolderNode(current, draft.parentId, {
+				kind: "folder",
+				id: createProjectFolderId(),
+				label: name,
+				children: [],
+			}),
+		);
+		setPendingFolderDraft(null);
+		setPendingFolderName("");
+	};
+
+	const cancelPendingFolder = (): void => {
+		setPendingFolderDraft(null);
+		setPendingFolderName("");
+	};
+
+	const handleContextActionSelect = (action: { id: string; label: string }, target: ProjectMenuTarget): void => {
+		if (action.id !== "new-folder") {
+			return;
+		}
+
+		switch (target.kind) {
+			case "surface":
+				beginFolderDraft(null, 0);
+				return;
+			case "folder":
+				beginFolderDraft(target.id, (findProjectNodeDepth(projectTreeNodes(), target.id) ?? 0) + 1);
+				return;
+			case "project": {
+				const parentId = findProjectNodeLocation(projectTreeNodes(), target.id)?.parentId ?? null;
+				beginFolderDraft(parentId, parentId ? (findProjectNodeDepth(projectTreeNodes(), parentId) ?? 0) + 1 : 0);
+				return;
+			}
+		}
+	};
+
+	const handleSurfaceContextMenu = (event: MouseEvent): void => {
+		event.stopPropagation();
+		contextMenu.openMenu(event, createProjectSurfaceTarget("Projects"));
+	};
+
+	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: ProjectTreeNode,
+	): void => {
+		const nextDragState = dragState();
+
+		if (!nextDragState) {
+			return;
+		}
+
+		if (nextDragState.draggedNodeId === getProjectTreeNodeId(node)) {
+			return;
+		}
+
+		const bounds = event.currentTarget.getBoundingClientRect();
+		const relativeY = bounds.height <= 0 ? 0.5 : (event.clientY - bounds.top) / bounds.height;
+		let nextTarget: ProjectDragTarget;
+
+		if (node.kind === "folder") {
+			if (relativeY < 0.28) {
+				nextTarget = {
+					parentId,
+					index,
+					intent: "before",
+					targetNodeId: node.id,
+				};
+			} else if (relativeY > 0.72) {
+				nextTarget = {
+					parentId,
+					index: index + 1,
+					intent: "after",
+					targetNodeId: node.id,
+				};
+			} else {
+				nextTarget = {
+					parentId: node.id,
+					index: node.children.length,
+					intent: "inside",
+					targetNodeId: node.id,
+				};
+			}
+		} else {
+			nextTarget = {
+				parentId,
+				index: relativeY < 0.5 ? index : index + 1,
+				intent: relativeY < 0.5 ? "before" : "after",
+				targetNodeId: node.item.id,
+			};
+		}
+
+		setDragState({
+			...nextDragState,
+			dropTarget: nextTarget,
+		});
+	};
+
 	return (
 		<div
+			ref={rootRef}
 			classList={{
 				[styles.root]: true,
 				[styles.rootCompact]: !!props.compact,
+				[styles.rootDragMode]: !!dragState(),
 			}}
 			style={{
 				"--project-drawer-top": `${drawerTop()}px`,
 			}}
 		>
-			{/* Project trigger */}
 			<button
 				type="button"
 				ref={triggerRef}
@@ -89,8 +814,9 @@ export const ProjectSelector = (props: ProjectSelectorProps): JSX.Element => {
 					[styles.triggerCompact]: !!props.compact,
 					[styles.triggerOpen]: props.isOpen,
 				}}
-				aria-label={`Open left workspace sidebar menu for ${selectedProject().name}`}
+				aria-label={`Open project menu for ${selectedProject().name}`}
 				aria-expanded={props.isOpen}
+				aria-haspopup="menu"
 				title={selectedProject().name}
 				onClick={toggleOpen}
 			>
@@ -113,7 +839,8 @@ export const ProjectSelector = (props: ProjectSelectorProps): JSX.Element => {
 				/>
 			</button>
 
-			{/* Outside-click scrim */}
+			<Show when={props.isOpen}>
+				<>
 					<button
 						type="button"
 						classList={{
@@ -125,42 +852,62 @@ export const ProjectSelector = (props: ProjectSelectorProps): JSX.Element => {
 						onClick={props.onClose}
 					/>
 
-			{/* Slide-out project list */}
 					<div
 						classList={{
 							[styles.drawer]: true,
 							[styles.drawerOpen]: props.isOpen,
 						}}
 						aria-hidden={!props.isOpen}
+						onContextMenu={handleSurfaceContextMenu}
 					>
 						<div class={styles.drawerBody}>
-					<ul class={styles.projectList} role="list">
+							<Show when={!props.compact}>
-					<For each={appShellData.projectItems()}>
+								<div class={styles.treeSectionLabel}>Projects</div>
-							{(item): JSX.Element => {
+							</Show>
-								const isSelected = (): boolean => selectedProject().id === item.id;
 
-								return (
+							<ProjectFolderBranch
-									<li>
+								nodes={projectTreeNodes()}
-										<button
+								depth={0}
-											type="button"
+								parentId={null}
-											classList={{
+								selectedProjectId={selectedProject().id}
-												[styles.projectItem]: true,
+								isFolderCollapsed={isFolderCollapsed}
-												[styles.projectItemActive]: isSelected(),
+								onToggleFolder={toggleFolder}
+								onSelectProject={selectProject}
+								onOpenFolderMenu={(event, folder): void => {
+									event.stopPropagation();
+									contextMenu.openMenu(event, createProjectFolderTarget(folder.id, folder.label));
 								}}
-											onClick={(): void => selectProject(item.id)}
+								onOpenProjectMenu={(event, item): void => {
-										>
+									event.stopPropagation();
-											<span class={styles.projectItemCopy}>
+									contextMenu.openMenu(event, createProjectTarget(item));
-												<span class={styles.projectItemName}>{item.name}</span>
-												<span class={styles.projectItemDescription}>{item.description}</span>
-											</span>
-										</button>
-									</li>
-								);
 								}}
-						</For>
+								onNodePointerDown={handleNodePointerDown}
-					</ul>
+								onNodePointerMove={handleNodePointerMove}
+								pendingFolderDraft={pendingFolderDraft()}
+								pendingFolderName={pendingFolderName()}
+								onPendingFolderNameChange={setPendingFolderName}
+								onSubmitPendingFolder={submitPendingFolder}
+								onCancelPendingFolder={cancelPendingFolder}
+								dragState={dragState()}
+							/>
 						</div>
 					</div>
+				</>
+			</Show>
+
+			<ProjectContextMenu
+				target={contextMenu.menuState()?.target ?? null}
+				position={(() => {
+					const state = contextMenu.menuState();
+					return state ? { x: state.x, y: state.y } : null;
+				})()}
+				menuRef={(element) => {
+					contextMenuRef = element;
+					contextMenu.setMenuRef(element);
+				}}
+				onClose={contextMenu.closeMenu}
+				onSelect={handleContextActionSelect}
+			/>
 		</div>
 	);
 };

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

@@ -12,6 +12,15 @@
   isolation: isolate;
 }
 
+.sidebarDragMode {
+	user-select: none;
+	cursor: grabbing;
+}
+
+.sidebarDragMode .treeItem {
+	cursor: grabbing;
+}
+
 .header {
   display: grid;
   gap: var(--space-3);
@@ -123,6 +132,43 @@
   padding: 0;
 }
 
+.treeEmptySlot {
+	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;
+}
+
+.treeInputRow {
+	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);
+}
+
+.treeInput {
+	width: 100%;
+	min-width: 0;
+	border: 0;
+	background: transparent;
+	color: var(--color-text);
+	font: inherit;
+	outline: none;
+}
+
+.treeInput::placeholder {
+	color: var(--color-text-muted);
+}
+
 .navItem {
   width: 100%;
   min-width: 0;
@@ -141,7 +187,7 @@
   width: 100%;
   min-width: 0;
   display: grid;
-  grid-template-columns: auto minmax(0, 1fr) auto;
+  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));
@@ -156,19 +202,51 @@
     background 160ms var(--easing-standard),
     color 160ms var(--easing-standard),
     border-color 160ms var(--easing-standard),
+    box-shadow 160ms var(--easing-standard),
     transform 180ms var(--easing-standard);
 }
 
 .treeItem:hover,
 .treeItem:focus-visible {
-  background: var(--color-surface-hover);
+  background: color-mix(in srgb, var(--color-surface-hover) 80%, var(--color-accent-soft) 20%);
   color: var(--color-text);
+  box-shadow: inset 0 1px 0 color-mix(in srgb, white 4%, transparent);
 }
 
 .treeItemFolder {
   color: var(--color-text);
 }
 
+.treeItemDragging {
+	opacity: 0.45;
+	transform: scale(0.985);
+	box-shadow: none;
+}
+
+.treeItemDropBefore {
+	box-shadow: inset 0 2px 0 color-mix(in srgb, var(--color-accent-strong) 78%, transparent);
+}
+
+.treeItemDropAfter {
+	box-shadow: inset 0 -2px 0 color-mix(in srgb, var(--color-accent-strong) 78%, transparent);
+}
+
+.treeItemDropInside {
+	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));
+	color: var(--color-text);
+	box-shadow: inset 0 1px 0 color-mix(in srgb, white 4%, transparent);
+}
+
+.folderChevron {
+  color: var(--color-text-muted);
+  transition: transform 160ms var(--easing-standard);
+}
+
+.folderChevronOpen {
+  transform: rotate(90deg);
+}
+
 .treeItemActive {
   border-color: var(--color-border);
   background: var(--color-surface);

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

@@ -1,7 +1,7 @@
 // Path: Frontend/src/components/shell/WorkspaceSidebar/WorkspaceSidebar.tsx
 
-import { For, Show, createMemo, createSignal, type JSX } from "solid-js";
+import { For, Show, createEffect, createSignal, onCleanup, onMount, type JSX } from "solid-js";
-import { ChevronLeft, ChevronRight } from "../../../lib/icons";
+import { ChevronLeft, ChevronRight, Folder } from "../../../lib/icons";
 import { useAppShellData } from "../data/app-shell.context";
 import { ProjectSelector } from "../ProjectSelector/ProjectSelector";
 import {
@@ -26,12 +26,276 @@ type WorkspaceSidebarProps = {
 	onToggleRailCollapse: () => void;
 };
 
+type PendingWorkspaceFolderDraft = {
+	parentId: string | null;
+	depth: number;
+};
+
+type WorkspaceDragTarget = {
+	parentId: string | null;
+	index: number;
+	intent: "before" | "after" | "inside";
+	targetNodeId?: string;
+};
+
+type WorkspaceDragState = {
+	draggedNodeId: string;
+	dropTarget: WorkspaceDragTarget | null;
+};
+
+type WorkspaceNodeLocation = {
+	parentId: string | null;
+	index: number;
+	node: WorkspaceTreeNode;
+};
+
+const LONG_PRESS_MS = 320;
+
+const createWorkspaceFolderId = (): string => `folder-${Math.random().toString(36).slice(2, 10)}`;
+
+const getWorkspaceTreeNodeId = (node: WorkspaceTreeNode): string => node.id;
+
+const insertWorkspaceFolderNode = (
+	nodes: readonly WorkspaceTreeNode[],
+	parentId: string | null,
+	folder: WorkspaceTreeNode,
+): readonly WorkspaceTreeNode[] => {
+	if (parentId === null) {
+		return [...nodes, folder];
+	}
+
+	return nodes.map((node) => {
+		if (node.kind !== "folder") {
+			return node;
+		}
+
+		if (node.id === parentId) {
+			return {
+				...node,
+				children: [...(node.children ?? []), folder],
+			};
+		}
+
+		return {
+			...node,
+			children: node.children ? insertWorkspaceFolderNode(node.children, parentId, folder) : node.children,
+		};
+	});
+};
+
+const findWorkspaceFolderDepth = (nodes: readonly WorkspaceTreeNode[], folderId: string, depth = 0): number | null => {
+	for (const node of nodes) {
+		if (node.kind !== "folder") {
+			continue;
+		}
+
+		if (node.id === folderId) {
+			return depth;
+		}
+
+		const nestedDepth = node.children ? findWorkspaceFolderDepth(node.children, folderId, depth + 1) : null;
+		if (nestedDepth !== null) {
+			return nestedDepth;
+		}
+	}
+
+	return null;
+};
+
+const findWorkspaceNodeLocation = (
+	nodes: readonly WorkspaceTreeNode[],
+	nodeId: string,
+	parentId: string | null = null,
+): WorkspaceNodeLocation | null => {
+	for (let index = 0; index < nodes.length; index += 1) {
+		const node = nodes[index];
+
+		if (node.id === nodeId) {
+			return { parentId, index, node };
+		}
+
+		if (node.kind === "folder" && node.children) {
+			const nestedLocation = findWorkspaceNodeLocation(node.children, nodeId, node.id);
+
+			if (nestedLocation) {
+				return nestedLocation;
+			}
+		}
+	}
+
+	return null;
+};
+
+const workspaceTreeContainsNode = (nodes: readonly WorkspaceTreeNode[], nodeId: string): boolean => {
+	for (const node of nodes) {
+		if (node.id === nodeId) {
+			return true;
+		}
+
+		if (node.kind === "folder" && node.children && workspaceTreeContainsNode(node.children, nodeId)) {
+			return true;
+		}
+	}
+
+	return false;
+};
+
+const removeWorkspaceTreeNode = (
+	nodes: readonly WorkspaceTreeNode[],
+	nodeId: string,
+): { nodes: WorkspaceTreeNode[]; removed: WorkspaceTreeNode | null } => {
+	const nextNodes: WorkspaceTreeNode[] = [];
+	let removed: WorkspaceTreeNode | null = null;
+
+	for (const node of nodes) {
+		if (node.id === nodeId) {
+			removed = node;
+			continue;
+		}
+
+		if (node.kind === "folder" && node.children) {
+			const result = removeWorkspaceTreeNode(node.children, nodeId);
+
+			if (result.removed) {
+				removed = result.removed;
+				nextNodes.push({
+					...node,
+					children: result.nodes,
+				});
+				continue;
+			}
+		}
+
+		nextNodes.push(node);
+	}
+
+	return { nodes: nextNodes, removed };
+};
+
+const insertWorkspaceTreeNode = (
+	nodes: readonly WorkspaceTreeNode[],
+	parentId: string | null,
+	index: number,
+	nodeToInsert: WorkspaceTreeNode,
+): WorkspaceTreeNode[] => {
+	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 (node.kind !== "folder") {
+			return node;
+		}
+
+		if (node.id === parentId) {
+			const nextChildren = [...(node.children ?? [])];
+			nextChildren.splice(Math.max(0, Math.min(index, nextChildren.length)), 0, nodeToInsert);
+			return {
+				...node,
+				children: nextChildren,
+			};
+		}
+
+		return {
+			...node,
+			children: node.children ? insertWorkspaceTreeNode(node.children, parentId, index, nodeToInsert) : node.children,
+		};
+	});
+};
+
+const moveWorkspaceTreeNode = (
+	nodes: readonly WorkspaceTreeNode[],
+	draggedNodeId: string,
+	dropTarget: WorkspaceDragTarget,
+): WorkspaceTreeNode[] => {
+	const location = findWorkspaceNodeLocation(nodes, draggedNodeId);
+
+	if (!location) {
+		return [...nodes];
+	}
+
+	if (
+		location.node.kind === "folder" &&
+		dropTarget.parentId !== null &&
+		((location.node.children && workspaceTreeContainsNode(location.node.children, dropTarget.parentId)) ||
+			dropTarget.parentId === location.node.id)
+	) {
+		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 = removeWorkspaceTreeNode(nodes, draggedNodeId);
+
+	if (!removalResult.removed) {
+		return [...nodes];
+	}
+
+	return insertWorkspaceTreeNode(removalResult.nodes, dropTarget.parentId, normalizedIndex, removalResult.removed);
+};
+
+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: {
 	item: WorkspaceStaticItem;
 	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 Icon = props.item.icon;
 	const target = createWorkspaceStaticTarget(props.item);
@@ -75,18 +339,41 @@ 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;
 	onOpenContextMenu: (event: MouseEvent, target: WorkspaceContextMenuTarget) => void;
 	onOpenContextMenuFromKeyboard: (element: HTMLElement, target: WorkspaceContextMenuTarget) => void;
 }): 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): JSX.Element => {
+				{(node, indexAccessor): JSX.Element => {
 					const Icon = getWorkspaceNodeIcon(node);
 					const target = createWorkspaceTreeTarget(node);
+					const isCollapsed = (): boolean => (node.kind === "folder" ? props.isFolderCollapsed(node.id) : false);
+					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>
@@ -96,8 +383,13 @@ const WorkspaceTreeBranch = (props: {
 									[styles.treeItem]: true,
 									[styles.treeItemActive]: !!node.active,
 									[styles.treeItemFolder]: node.kind === "folder",
+									[styles.treeItemDragging]: isDraggedNode(),
+									[styles.treeItemDropBefore]: dropIntent() === "before",
+									[styles.treeItemDropAfter]: dropIntent() === "after",
+									[styles.treeItemDropInside]: dropIntent() === "inside",
 								}}
 								style={{ "--tree-depth": String(depth()) }}
+								aria-expanded={node.kind === "folder" ? !isCollapsed() : undefined}
 								aria-current={node.active ? "page" : undefined}
 								aria-label={node.label}
 								title={node.label}
@@ -105,10 +397,28 @@ const WorkspaceTreeBranch = (props: {
 								data-kind={node.kind}
 								data-item-type={node.kind === "item" ? node.itemType : undefined}
 								data-active={node.active ? "true" : "false"}
+								onClick={(): void => {
+									if (props.dragState || props.isTreeClickSuppressed()) {
+										return;
+									}
+
+									if (node.kind !== "folder") {
+										return;
+									}
+
+									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;
@@ -118,6 +428,16 @@ const WorkspaceTreeBranch = (props: {
 									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}>
@@ -125,18 +445,40 @@ const WorkspaceTreeBranch = (props: {
 								</Show>
 							</button>
 
-							<Show when={node.children?.length}>
+							<Show when={node.kind === "folder" && !isCollapsed() && (((node.children?.length ?? 0) > 0) || props.pendingFolderDraft?.parentId === node.id)}>
 								<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}
 									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>
 	);
 };
@@ -144,23 +486,209 @@ const WorkspaceTreeBranch = (props: {
 export const WorkspaceSidebar = (props: WorkspaceSidebarProps): JSX.Element => {
 	const appShellData = useAppShellData();
 	const [isProjectDrawerOpen, setIsProjectDrawerOpen] = createSignal(false);
+	const [workspaceTreeNodes, setWorkspaceTreeNodes] = createSignal<readonly WorkspaceTreeNode[]>(appShellData.workspaceTree());
+	const [collapsedFolderIds, setCollapsedFolderIds] = createSignal<readonly string[]>([]);
+	const [pendingFolderDraft, setPendingFolderDraft] = createSignal<PendingWorkspaceFolderDraft | null>(null);
+	const [pendingFolderName, setPendingFolderName] = createSignal("");
+	const [dragState, setDragState] = createSignal<WorkspaceDragState | null>(null);
+	const [suppressNextTreeClick, setSuppressNextTreeClick] = createSignal(false);
 	const contextMenu = createWorkspaceContextMenuController();
+	let longPressTimer: number | undefined;
+	let suppressClickTimer: number | undefined;
 	const railToggleLabel = (): string => (props.railCollapsed ? "Expand server rail" : "Collapse server rail");
-	const sidebarContextMenuTarget = createMemo(() => createWorkspaceSurfaceTarget(appShellData.activeProject()));
+	const sidebarContextMenuTarget = createWorkspaceSurfaceTarget(appShellData.activeProject());
-	const contextMenuTarget = createMemo(() => contextMenu.menuState()?.target ?? null);
+	const isFolderCollapsed = (folderId: string): boolean => collapsedFolderIds().includes(folderId);
-	const contextMenuPosition = createMemo(() => {
+	const toggleFolder = (folderId: string): void => {
-		const state = contextMenu.menuState();
+		setCollapsedFolderIds((current) =>
-
+			current.includes(folderId) ? current.filter((id) => id !== folderId) : [...current, folderId],
-		return state
+		);
-			? {
+	};
-				x: state.x,
+	const clearLongPressTimer = (): void => {
-				y: state.y,
+		if (longPressTimer !== undefined) {
+			window.clearTimeout(longPressTimer);
+			longPressTimer = undefined;
 		}
-			: null;
+	};
+	const suppressTreeClickTemporarily = (): void => {
+		setSuppressNextTreeClick(true);
+
+		if (suppressClickTimer !== undefined) {
+			window.clearTimeout(suppressClickTimer);
+		}
+
+		suppressClickTimer = window.setTimeout(() => {
+			setSuppressNextTreeClick(false);
+			suppressClickTimer = undefined;
+		}, 80);
+	};
+
+	createEffect(() => {
+		setWorkspaceTreeNodes(appShellData.workspaceTree());
+		setCollapsedFolderIds([]);
+		setPendingFolderDraft(null);
+		setPendingFolderName("");
+		setDragState(null);
 	});
 
-	const handleContextActionSelect = (_action: WorkspaceContextMenuAction, _target: WorkspaceContextMenuTarget): void => {
+	onMount(() => {
-		// Initial implementation only establishes the menu IA and placement.
+		const handlePointerUp = (): void => {
+			clearLongPressTimer();
+
+			const nextDragState = dragState();
+
+			if (!nextDragState?.dropTarget) {
+				if (nextDragState) {
+					suppressTreeClickTemporarily();
+				}
+				setDragState(null);
+				return;
+			}
+
+			suppressTreeClickTemporarily();
+			setWorkspaceTreeNodes((current) =>
+				moveWorkspaceTreeNode(current, nextDragState.draggedNodeId, nextDragState.dropTarget as WorkspaceDragTarget),
+			);
+			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));
+		}
+
+		setPendingFolderName("");
+		setPendingFolderDraft({ parentId, depth });
+	};
+
+	const submitPendingFolder = (): void => {
+		const name = pendingFolderName().trim();
+		const draft = pendingFolderDraft();
+
+		if (!draft) {
+			return;
+		}
+
+		if (!name) {
+			setPendingFolderDraft(null);
+			setPendingFolderName("");
+			return;
+		}
+
+		setWorkspaceTreeNodes((current) =>
+			insertWorkspaceFolderNode(current, draft.parentId, {
+				id: createWorkspaceFolderId(),
+				label: name,
+				kind: "folder",
+				icon: Folder,
+				children: [],
+			}),
+		);
+		setPendingFolderDraft(null);
+		setPendingFolderName("");
+	};
+
+	const cancelPendingFolder = (): void => {
+		setPendingFolderDraft(null);
+		setPendingFolderName("");
+	};
+
+	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 bounds = event.currentTarget.getBoundingClientRect();
+		const relativeY = bounds.height <= 0 ? 0.5 : (event.clientY - bounds.top) / bounds.height;
+		let nextTarget: WorkspaceDragTarget;
+
+		if (node.kind === "folder") {
+			if (relativeY < 0.28) {
+				nextTarget = { parentId, index, intent: "before", targetNodeId: node.id };
+			} else if (relativeY > 0.72) {
+				nextTarget = { parentId, index: index + 1, intent: "after", targetNodeId: node.id };
+			} else {
+				nextTarget = {
+					parentId: node.id,
+					index: (node.children ?? []).length,
+					intent: "inside",
+					targetNodeId: node.id,
+				};
+			}
+		} else {
+			nextTarget = {
+				parentId,
+				index: relativeY < 0.5 ? index : index + 1,
+				intent: relativeY < 0.5 ? "before" : "after",
+				targetNodeId: node.id,
+			};
+		}
+
+		setDragState({ ...nextDragState, dropTarget: nextTarget });
+	};
+
+	const handleContextActionSelect = (action: WorkspaceContextMenuAction, target: WorkspaceContextMenuTarget): void => {
+		if (action.id !== "new-folder") {
+			return;
+		}
+
+		switch (target.kind) {
+			case "workspace":
+			case "home":
+				beginFolderDraft(null, 0);
+				return;
+			case "folder":
+				beginFolderDraft(target.id, (findWorkspaceFolderDepth(workspaceTreeNodes(), target.id) ?? 0) + 1);
+				return;
+			case "settings":
+			case "item":
+				return;
+		}
 	};
 
 	return (
@@ -169,12 +697,13 @@ 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
@@ -256,9 +785,21 @@ export const WorkspaceSidebar = (props: WorkspaceSidebarProps): JSX.Element => {
 
 						<div data-slot="workspace-tree-root">
 							<WorkspaceTreeBranch
-							nodes={appShellData.workspaceTree()}
+								nodes={workspaceTreeNodes()}
+								parentId={null}
+								isFolderCollapsed={isFolderCollapsed}
+								onToggleFolder={toggleFolder}
+								pendingFolderDraft={pendingFolderDraft()}
+								pendingFolderName={pendingFolderName()}
+								onPendingFolderNameChange={setPendingFolderName}
+								onSubmitPendingFolder={submitPendingFolder}
+								onCancelPendingFolder={cancelPendingFolder}
 								onOpenContextMenu={contextMenu.openMenu}
 								onOpenContextMenuFromKeyboard={contextMenu.openMenuFromElement}
+								onNodePointerDown={handleNodePointerDown}
+								onNodePointerMove={handleNodePointerMove}
+								dragState={dragState()}
+								isTreeClickSuppressed={suppressNextTreeClick}
 							/>
 						</div>
 					</div>
@@ -266,8 +807,16 @@ export const WorkspaceSidebar = (props: WorkspaceSidebarProps): JSX.Element => {
 			</aside>
 
 			<WorkspaceContextMenu
-				target={contextMenuTarget()}
+				target={contextMenu.menuState()?.target ?? null}
-				position={contextMenuPosition()}
+				position={(() => {
+					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,6 +34,7 @@ import {
 
 type AppShellInstallation = {
 	id: string;
+	name: string;
 	mode: "personal" | "organizational" | string;
 	access: string;
 	protocol: string;
@@ -151,11 +152,12 @@ 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: organization.name,
+		label: serverName || organization.name,
-		abbreviation: buildAbbreviation(organization.name, kind === "personal" ? "P" : "O"),
+		abbreviation: buildAbbreviation(serverName || organization.name, kind === "personal" ? "P" : "O"),
 		kind,
 		active: index === 0,
 	}));
@@ -170,11 +172,12 @@ 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: organization.name || installation.host || fallbackActiveServer.name,
+		name: serverName || fallbackActiveServer.name,
-		abbreviation: buildAbbreviation(organization.name || installation.host, kind === "personal" ? "P" : "O"),
+		abbreviation: buildAbbreviation(serverName, 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,
@@ -191,6 +194,16 @@ 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,
 	}));
 };
@@ -255,7 +268,7 @@ const buildActiveUserProfile = (payload: AppShellPayload | null): ActiveUserProf
 		return fallbackActiveUserProfile;
 	}
 
-	const organizationName = payload.organizations[0]?.name ?? fallbackActiveServer.name;
+	const organizationName = payload.installation?.name || payload.organizations[0]?.name || fallbackActiveServer.name;
 	const departmentName = payload.departments[0]?.name;
 
 	return {
@@ -282,10 +295,20 @@ export const AppShellDataProvider = (props: { children: JSX.Element }): JSX.Elem
 				},
 			});
 
-			const body = (await response.json()) as { data?: AppShellPayload; error?: { message?: string } };
+			const body = (await response.json()) as {
+				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(body.error?.message || "Failed to load app shell state.");
+				throw new Error(errorMessage || "Failed to load app shell state.");
 			}
 
 			setPayload(normalizeAppShellPayload(body.data));

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

@@ -71,9 +71,43 @@ 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;
@@ -364,9 +398,31 @@ export const activeDepartment: ActiveDepartment = {
 };
 
 export const projectItems: readonly ProjectItem[] = [
-	{ id: "general", name: "General", description: "Default shared project", active: true },
+	{
-	{ id: "operations", name: "Operations", description: "Cross-team planning and delivery" },
+		id: "general",
-	{ id: "hiring", name: "Hiring", description: "Candidate pipeline and interview loops" },
+		name: "General",
+		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[] = [
@@ -533,6 +589,69 @@ export const getWorkspaceContextMenuSections = (
 	}
 };
 
+const getProjectCreateActions = (): readonly ProjectContextMenuAction[] =>
+	[
+		{ id: "new-project", label: "New project" },
+		{ id: "new-folder", label: "New folder" },
+	] 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,
+				},
+			] 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/workspace-home/WorkspaceHome/WorkspaceHome.module.scss

@@ -92,12 +92,6 @@
   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);
@@ -246,10 +240,16 @@
   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,13 +527,45 @@
   }
 
   .wizardPanel {
-    width: calc(100vw - (var(--space-4) * 2));
+    width: 100vw;
-    max-height: calc(100dvh - (var(--space-4) * 2));
+    max-height: 100dvh;
-    margin: var(--space-4) auto;
+    margin: 0;
     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

@@ -1,6 +1,6 @@
 // Path: Frontend/src/components/workspace-home/WorkspaceHome/WorkspaceHome.tsx
 
-import { For, Show, createEffect, createMemo, createSignal, onMount, type JSX } from "solid-js";
+import { For, Show, createEffect, createMemo, createSignal, type JSX } from "solid-js";
 import { Portal } from "solid-js/web";
 import { createStore } from "solid-js/store";
 import { resolveAPIBase } from "../../../lib/api";
@@ -44,8 +44,6 @@ const bootstrapStepDefinitions: readonly BootstrapStepDefinition[] = [
 	},
 ];
 
-const bootstrapCompletionStorageKey = "moku.bootstrap.completed";
-
 const defaultInstanceForm = {
 	protocol: "http",
 	access: "local",
@@ -54,6 +52,7 @@ const defaultInstanceForm = {
 
 const defaultModeForm = {
 	mode: "personal",
+	name: "",
 } as const;
 
 const defaultAdminForm = {
@@ -82,27 +81,6 @@ const initialSubmissionState = (): BootstrapSubmissionState => ({
 	error: "",
 });
 
-const readBootstrapCompletion = (): boolean => {
-	if (typeof window === "undefined") {
-		return false;
-	}
-
-	return window.localStorage.getItem(bootstrapCompletionStorageKey) === "true";
-};
-
-const writeBootstrapCompletion = (isComplete: boolean): void => {
-	if (typeof window === "undefined") {
-		return;
-	}
-
-	if (isComplete) {
-		window.localStorage.setItem(bootstrapCompletionStorageKey, "true");
-		return;
-	}
-
-	window.localStorage.removeItem(bootstrapCompletionStorageKey);
-};
-
 const readResponseBody = async (response: Response): Promise<unknown> => {
 	const raw = await response.text();
 
@@ -117,6 +95,52 @@ 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;
@@ -139,13 +163,6 @@ export const WorkspaceHome = (props: WorkspaceHomeProps): JSX.Element => {
 	const [isWizardOpen, setIsWizardOpen] = createSignal(false);
 	const [currentStepIndex, setCurrentStepIndex] = createSignal(0);
 
-	onMount(() => {
-		const isComplete = readBootstrapCompletion();
-		setIsBootstrapComplete(isComplete);
-		setIsWizardOpen(!isComplete);
-		setIsBootstrapStateResolved(true);
-	});
-
 	createEffect(() => {
 		if (modeForm.mode === "personal") {
 			setStructureForm("departmentName", personalStructureDefaults.departmentName);
@@ -163,29 +180,27 @@ export const WorkspaceHome = (props: WorkspaceHomeProps): JSX.Element => {
 	});
 
 	createEffect(() => {
-		if (!isBootstrapStateResolved()) {
+		const shellStatus = appShellData.status();
+
+		if (shellStatus === "idle" || shellStatus === "loading") {
 			return;
 		}
 
-		if (appShellData.status() !== "success") {
+		if (shellStatus !== "success") {
 			return;
 		}
 
-		const installation = appShellData.installation();
+		const installationAccessor = appShellData.installation;
+		const installation = typeof installationAccessor === "function" ? installationAccessor() : undefined;
 		const isPersistedBootstrap = installation?.isBootstrapped ?? false;
 
-		if (isPersistedBootstrap) {
+		if (!isPersistedBootstrap) {
-			return;
-		}
-
-		if (!isBootstrapComplete() && isWizardOpen()) {
-			return;
-		}
-
-		writeBootstrapCompletion(false);
-		setIsBootstrapComplete(false);
-		setIsWizardOpen(true);
 			resetWizardState();
+		}
+
+		setIsBootstrapComplete(isPersistedBootstrap);
+		setIsWizardOpen(!isPersistedBootstrap);
+		setIsBootstrapStateResolved(true);
 	});
 
 	const sidebarToggleLabel = (): string =>
@@ -194,6 +209,8 @@ 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]!,
 	);
@@ -231,11 +248,7 @@ export const WorkspaceHome = (props: WorkspaceHomeProps): JSX.Element => {
 			const data = await readResponseBody(response);
 
 			if (!response.ok) {
-				throw new Error(
+				throw new Error(readResponseError(step, data));
-					typeof data?.error?.message === "string"
-						? data.error.message
-						: `Bootstrap ${step} request failed.`,
-				);
 			}
 
 			setStepState(step, {
@@ -277,9 +290,13 @@ export const WorkspaceHome = (props: WorkspaceHomeProps): JSX.Element => {
 
 		if (isLastStep()) {
 			await appShellData.reload();
-			writeBootstrapCompletion(true);
+			const installationAccessor = appShellData.installation;
-			setIsBootstrapComplete(true);
+			const installation = typeof installationAccessor === "function" ? installationAccessor() : undefined;
-			setIsWizardOpen(false);
+			const isPersistedBootstrap = installation?.isBootstrapped ?? false;
+
+			setIsBootstrapComplete(isPersistedBootstrap);
+			setIsWizardOpen(!isPersistedBootstrap);
+			setIsBootstrapStateResolved(true);
 			return;
 		}
 
@@ -343,7 +360,6 @@ 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}>
@@ -442,6 +458,7 @@ export const WorkspaceHome = (props: WorkspaceHomeProps): JSX.Element => {
 										</Show>
 
 						<Show when={currentStep().id === "mode"}>
+							<>
 								<label class={styles.field}>
 									<span class={styles.fieldLabel}>Mode</span>
 									<select value={modeForm.mode} onInput={(event): void => setModeForm("mode", event.currentTarget.value)}>
@@ -449,6 +466,17 @@ export const WorkspaceHome = (props: WorkspaceHomeProps): JSX.Element => {
 										<option value="organizational">organizational</option>
 									</select>
 								</label>
+								<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"}>
@@ -477,8 +505,11 @@ export const WorkspaceHome = (props: WorkspaceHomeProps): JSX.Element => {
 													type="password"
 													value={adminForm.password}
 													onInput={(event): void => setAdminForm("password", event.currentTarget.value)}
-														placeholder="Temporary for echo testing"
+													placeholder="Create a strong password"
 												/>
+												<small class={styles.fieldHelp}>
+													Use at least 12 characters with uppercase, lowercase, numbers, and symbols.
+												</small>
 											</label>
 											</>
 										</Show>

Justfile

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