Fix: Make bootstrap state backend authoritative

.gitignore

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

Backend/cmd/posix/main.go

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

Backend/db/migrations/000003_installation_name.sql

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

Backend/db/migrations/000004_posix_nodes.sql

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

Backend/internal/bootstrap/service.go

@@ -4,17 +4,13 @@ package bootstrap
 
 import (
 	"context"
-	"encoding/json"
 	"errors"
 	"fmt"
-	"os"
-	"path/filepath"
 	"strings"
 
 	"github.com/jackc/pgx/v5"
 
 	"moku-backend/internal/database"
-	"moku-backend/internal/posixproj"
 )
 
 const (
@@ -46,7 +42,6 @@ var (
 
 type Service struct {
 	db *database.DB
-	posixRoot string
 }
 
 type SaveInstanceInput struct {
@@ -57,7 +52,6 @@ type SaveInstanceInput struct {
 
 type SaveModeInput struct {
 	Mode string
-	Name string
 }
 
 type SaveAdminInput struct {
@@ -75,7 +69,6 @@ type SaveStructureInput struct {
 
 type InstallationRecord struct {
 	ID             string `json:"id"`
-	Name           string `json:"name"`
 	Mode           string `json:"mode"`
 	Access         string `json:"access"`
 	Protocol       string `json:"protocol"`
@@ -177,16 +170,15 @@ type namedRecord struct {
 	Slug string `json:"slug"`
 }
 
-func NewService(db *database.DB, posixRoot string) *Service {
-	return &Service{db: db, posixRoot: strings.TrimSpace(posixRoot)}
+func NewService(db *database.DB) *Service {
+	return &Service{db: db}
 }
 
 func (service *Service) SaveInstance(ctx context.Context, input SaveInstanceInput) (InstallationRecord, error) {
 	row := service.db.Pool.QueryRow(ctx, `
-		INSERT INTO installations (singleton, name, mode, access, protocol, host)
+		INSERT INTO installations (singleton, mode, access, protocol, host)
 		VALUES (
 			TRUE,
-			COALESCE((SELECT name FROM installations WHERE singleton = TRUE LIMIT 1), ''),
 			COALESCE((SELECT mode FROM installations WHERE singleton = TRUE LIMIT 1), 'personal'::instance_mode),
 			$1::instance_access,
 			$2::instance_protocol,
@@ -198,7 +190,7 @@ func (service *Service) SaveInstance(ctx context.Context, input SaveInstanceInpu
 			protocol = EXCLUDED.protocol,
 			host = EXCLUDED.host,
 			updated_at = NOW()
-		RETURNING id::text, name, mode::text, access::text, protocol::text, host, is_bootstrapped;
+		RETURNING id::text, mode::text, access::text, protocol::text, host, is_bootstrapped;
 	`, input.Access, input.Protocol, input.Host)
 
 	return scanInstallationRecord(row)
@@ -206,22 +198,20 @@ func (service *Service) SaveInstance(ctx context.Context, input SaveInstanceInpu
 
 func (service *Service) SaveMode(ctx context.Context, input SaveModeInput) (InstallationRecord, error) {
 	row := service.db.Pool.QueryRow(ctx, `
-		INSERT INTO installations (singleton, name, mode, access, protocol, host)
+		INSERT INTO installations (singleton, mode, access, protocol, host)
 		VALUES (
 			TRUE,
-			$2,
 			$1::instance_mode,
 			COALESCE((SELECT access FROM installations WHERE singleton = TRUE LIMIT 1), 'local'::instance_access),
 			COALESCE((SELECT protocol FROM installations WHERE singleton = TRUE LIMIT 1), 'http'::instance_protocol),
-			COALESCE((SELECT host FROM installations WHERE singleton = TRUE LIMIT 1), $3)
+			COALESCE((SELECT host FROM installations WHERE singleton = TRUE LIMIT 1), $2)
 		)
 		ON CONFLICT (singleton) DO UPDATE
 		SET
-			name = EXCLUDED.name,
 			mode = EXCLUDED.mode,
 			updated_at = NOW()
-		RETURNING id::text, name, mode::text, access::text, protocol::text, host, is_bootstrapped;
-	`, input.Mode, input.Name, defaultInstallationHost)
+		RETURNING id::text, mode::text, access::text, protocol::text, host, is_bootstrapped;
+	`, input.Mode, defaultInstallationHost)
 
 	return scanInstallationRecord(row)
 }
@@ -311,7 +301,7 @@ func (service *Service) SaveStructure(ctx context.Context, input SaveStructureIn
 
 	organizationName := strings.TrimSpace(input.OrganizationName)
 	if organizationName == "" {
-		organizationName = defaultRootOrganizationName(installation.Name, installation.Mode, installation.Host, admin.DisplayName)
+		organizationName = defaultRootOrganizationName(installation.Mode, installation.Host, admin.DisplayName)
 	}
 
 	organization, err := upsertNamedRecord(ctx, tx, `
@@ -410,14 +400,6 @@ func (service *Service) SaveStructure(ctx context.Context, input SaveStructureIn
 		return StructureRecord{}, err
 	}
 
-	if err := service.ensureBootstrapPOSIXSkeleton(installation, admin, organization, department, team, project); err != nil {
-		return StructureRecord{}, err
-	}
-
-	if err := posixproj.NewProjector(service.db, service.posixRoot).Rebuild(ctx); err != nil {
-		return StructureRecord{}, fmt.Errorf("rebuild POSIX projection: %w", err)
-	}
-
 	return StructureRecord{
 		Installation: installation,
 		Organization: organization,
@@ -460,7 +442,7 @@ func (service *Service) ResetDevelopmentState(ctx context.Context) error {
 
 func (service *Service) GetInstallation(ctx context.Context) (*InstallationRecord, error) {
 	record, err := scanInstallationRecord(service.db.Pool.QueryRow(ctx, `
-		SELECT id::text, name, mode::text, access::text, protocol::text, host, is_bootstrapped
+		SELECT id::text, mode::text, access::text, protocol::text, host, is_bootstrapped
 		FROM installations
 		WHERE singleton = TRUE
 		LIMIT 1;
@@ -615,7 +597,7 @@ func (service *Service) GetAppShellState(ctx context.Context) (AppShellState, er
 
 func scanInstallationRecord(row pgx.Row) (InstallationRecord, error) {
 	var record InstallationRecord
-	if err := row.Scan(&record.ID, &record.Name, &record.Mode, &record.Access, &record.Protocol, &record.Host, &record.IsBootstrapped); err != nil {
+	if err := row.Scan(&record.ID, &record.Mode, &record.Access, &record.Protocol, &record.Host, &record.IsBootstrapped); err != nil {
 		return InstallationRecord{}, err
 	}
 
@@ -820,7 +802,7 @@ func (service *Service) listWorkspaces(ctx context.Context) ([]WorkspaceRecord,
 
 func loadInstallation(ctx context.Context, tx pgx.Tx) (InstallationRecord, error) {
 	return scanInstallationRecord(tx.QueryRow(ctx, `
-		SELECT id::text, name, mode::text, access::text, protocol::text, host, is_bootstrapped
+		SELECT id::text, mode::text, access::text, protocol::text, host, is_bootstrapped
 		FROM installations
 		WHERE singleton = TRUE
 		LIMIT 1;
@@ -847,7 +829,7 @@ func updateBootstrappedInstallation(ctx context.Context, tx pgx.Tx) (Installatio
 		UPDATE installations
 		SET is_bootstrapped = TRUE, bootstrapped_at = COALESCE(bootstrapped_at, NOW()), updated_at = NOW()
 		WHERE singleton = TRUE
-		RETURNING id::text, name, mode::text, access::text, protocol::text, host, is_bootstrapped;
+		RETURNING id::text, mode::text, access::text, protocol::text, host, is_bootstrapped;
 	`))
 }
 
@@ -878,15 +860,10 @@ func upsertWorkspace(ctx context.Context, tx pgx.Tx, organizationID, name, slug,
 	return err
 }
 
-func defaultRootOrganizationName(installationName, mode, host, adminDisplayName string) string {
-	trimmedInstallationName := strings.TrimSpace(installationName)
+func defaultRootOrganizationName(mode, host, adminDisplayName string) string {
 	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)
@@ -914,173 +891,3 @@ func personalHomeTitle(displayName string) string {
 
 	return fmt.Sprintf("%s's Home", trimmedDisplayName)
 }
-
-func (service *Service) ensureBootstrapPOSIXSkeleton(
-	installation InstallationRecord,
-	admin AdminSummary,
-	organization namedRecord,
-	department namedRecord,
-	team namedRecord,
-	project namedRecord,
-) error {
-	rootPath := strings.TrimSpace(service.posixRoot)
-	if rootPath == "" {
-		return nil
-	}
-
-	if err := os.MkdirAll(rootPath, 0o755); err != nil {
-		return fmt.Errorf("create POSIX root: %w", err)
-	}
-
-	if err := writeJSONFile(filepath.Join(rootPath, "settings.json"), map[string]any{
-		"installation": map[string]any{
-			"id":             installation.ID,
-			"name":           installation.Name,
-			"mode":           installation.Mode,
-			"access":         installation.Access,
-			"protocol":       installation.Protocol,
-			"host":           installation.Host,
-			"isBootstrapped": installation.IsBootstrapped,
-		},
-		"organization": map[string]any{
-			"id":   organization.ID,
-			"name": organization.Name,
-			"slug": organization.Slug,
-		},
-	}); err != nil {
-		return fmt.Errorf("write tenant settings.json: %w", err)
-	}
-
-	if err := writeJSONFile(filepath.Join(rootPath, "layout.json"), map[string]any{
-		"version": 1,
-		"type":    "tenant-layout",
-		"home": map[string]any{
-			"defaultProjectSlug": project.Slug,
-		},
-	}); err != nil {
-		return fmt.Errorf("write tenant layout.json: %w", err)
-	}
-
-	if err := os.MkdirAll(filepath.Join(rootPath, "catalog", "packs"), 0o755); err != nil {
-		return fmt.Errorf("create catalog packs root: %w", err)
-	}
-
-	if err := os.MkdirAll(filepath.Join(rootPath, "catalog", "standalone"), 0o755); err != nil {
-		return fmt.Errorf("create catalog standalone root: %w", err)
-	}
-
-	departmentPath := filepath.Join(rootPath, "departments", slugDir("department", department.Slug))
-	teamPath := filepath.Join(departmentPath, "teams", slugDir("team", team.Slug))
-	projectPath := filepath.Join(rootPath, "projects", slugDir("project", project.Slug))
-	usersPath := filepath.Join(rootPath, "users")
-
-	for _, dirPath := range []string{
-		departmentPath,
-		teamPath,
-		projectPath,
-		filepath.Join(projectPath, "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

@@ -1,113 +0,0 @@
-package bootstrap
-
-import (
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestEnsureBootstrapPOSIXSkeletonInitializesEmptyRoot(t *testing.T) {
-	rootPath := filepath.Join(t.TempDir(), "POSIX")
-	t.Setenv("POSIX_ROOT", rootPath)
-
-	if _, err := os.Stat(rootPath); !os.IsNotExist(err) {
-		t.Fatalf("expected isolated POSIX root to start absent, got err=%v", err)
-	}
-
-	service := NewService(nil, os.Getenv("POSIX_ROOT"))
-
-	err := service.ensureBootstrapPOSIXSkeleton(
-		InstallationRecord{
-			ID:             "installation-1",
-			Name:           "MangoPig",
-			Mode:           "personal",
-			Access:         "local",
-			Protocol:       "http",
-			Host:           "localhost",
-			IsBootstrapped: true,
-		},
-		AdminSummary{
-			ID:          "admin-1",
-			Email:       "ronald@example.com",
-			DisplayName: "Ronald",
-		},
-		namedRecord{ID: "org-1", Name: "Primary Organization", Slug: "primary-organization"},
-		namedRecord{ID: "dept-1", Name: "Primary Department", Slug: "primary-department"},
-		namedRecord{ID: "team-1", Name: "Primary Team", Slug: "primary-team"},
-		namedRecord{ID: "project-1", Name: "Primary Project", Slug: "primary-project"},
-	)
-	if err != nil {
-		t.Fatalf("ensure bootstrap POSIX skeleton: %v", err)
-	}
-
-	requiredPaths := []string{
-		filepath.Join(rootPath, "settings.json"),
-		filepath.Join(rootPath, "layout.json"),
-		filepath.Join(rootPath, "catalog", "packs"),
-		filepath.Join(rootPath, "catalog", "standalone"),
-		filepath.Join(rootPath, "departments", "department-primary-department", "settings.json"),
-		filepath.Join(rootPath, "departments", "department-primary-department", "users.json"),
-		filepath.Join(rootPath, "departments", "department-primary-department", "teams", "team-primary-team", "settings.json"),
-		filepath.Join(rootPath, "departments", "department-primary-department", "teams", "team-primary-team", "users.json"),
-		filepath.Join(rootPath, "projects", "project-primary-project", "settings.json"),
-		filepath.Join(rootPath, "projects", "project-primary-project", "home.json"),
-		filepath.Join(rootPath, "projects", "project-primary-project", "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,7 +17,6 @@ type Config struct {
 	APIPort         string
 	PostgresURL     string
 	ValkeyURL       string
-	POSIXRoot       string
 	ShutdownTimeout time.Duration
 }
 
@@ -30,7 +29,6 @@ func Load() *Config {
 		APIPort:         getEnv("BACKEND_API_PORT", "8081"),
 		PostgresURL:     getEnv("DATABASE_URL", "postgres://moku:moku_dev_password@localhost:5432/moku?sslmode=disable"),
 		ValkeyURL:       getEnv("VALKEY_URL", "redis://localhost:6379/0"),
-		POSIXRoot:       getEnv("POSIX_ROOT", "../POSIX"),
 		ShutdownTimeout: getDurationEnv("BACKEND_SHUTDOWN_TIMEOUT", 10*time.Second),
 	}
 }

Backend/internal/httpx/api_bootstrap_routes.go

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

Backend/internal/posixproj/projector.go

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

Backend/internal/posixproj/projector_test.go

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

Commands/Local/Dev/backend.just

@@ -9,22 +9,18 @@ migrate-up:
 migrate-down:
 	cd '{{backend_dir}}' && go run ./cmd/migrate down
 
-# Reset all embedded database migrations.
+# Reset all embedded database migrations and reapply from scratch.
 migrate-reset:
 	cd '{{backend_dir}}' && go run ./cmd/migrate reset
 
-# Reset embedded database migrations and apply them again from scratch.
-migrate-rebuild:
-	cd '{{backend_dir}}' && go run ./cmd/migrate reset && go run ./cmd/migrate up
-
 # Show the embedded database migration status.
 migrate-status:
 	cd '{{backend_dir}}' && go run ./cmd/migrate status
 
-# Rebuild the POSIX-to-DB projection from the current POSIX root.
-posix-rebuild:
-	cd '{{backend_dir}}' && go run ./cmd/posix rebuild
-
 # Format backend Go source files.
 fmt:
 	cd '{{backend_dir}}' && gofmt -w ./cmd ./db ./internal
+
+# Run backend test suite.
+test:
+	cd '{{backend_dir}}' && go test ./...

Commands/Test/backend.just

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

Commands/Test/mod.just

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

Docker/docker-compose.local.dev.yaml

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

Docker/docker-compose.local.prod.yaml

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

Documentation/POSIX-Structure.md

@@ -1,61 +0,0 @@
-# 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,149 +4,87 @@
 
 ### Version 0.1.0
 
-**Goal:** Finish the base application shell, auth, and platform foundations.
+**Goal:** Barebone frontend with a real backend core.
 
-#### Architecture and Delivery
+#### Architecture
 
-- [x] Project-Structure
-- [x] Stack-Decisions
-- [x] Proxy
-  - [x] Local-Dev-Vite-Proxy
-  - [x] Local-Prod-NGINX-Proxy
-- [x] First-Request-Web-Loader
-  - [x] Bootstrap-Document
-  - [x] Route-Intent-Handoff
-  - [x] Tiny-First-Paint-Budget
-- [x] Dev-and-Prod-Builds
+- [ ] Project-Structure
+- [ ] Stack-Decisions
+- [ ] Proxy
+  - [ ] Local-Prod-NGINX-Proxy
+  - [ ] Static-Frontend-Serving
+- [ ] First-Request-Web-Loader
+  - [ ] Bootstrap-Document
+  - [ ] Route-Intent-Handoff
+  - [ ] Tiny-First-Paint-Budget
+- [ ] Dev-and-Prod-Builds
   - [x] Local-Dev-Just-Commands
   - [x] Local-Dev-Docker-Compose
-  - [x] Local-Prod-Just-Commands
-  - [x] Local-Prod-Docker-Compose
-  - [x] Frontend-Production-Dockerfile
-  - [x] Frontend-docker-bake
+  - [ ] Local-Prod-Just-Commands
+  - [ ] Local-Prod-Docker-Compose
+  - [ ] Frontend-Production-Dockerfile
+  - [ ] Frontend-docker-bake
 
-#### 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
+#### Backend
 
 - [ ] Auth
   - [ ] Session-Flow
   - [ ] Login-Logout-Foundation
   - [ ] Authentication
-- [ ] Current-User-Implementation
-- [ ] 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
+- [ ] User
+  - [ ] Base-Model
   - [ ] 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 — Done Foundations
+#### Frontend
 
 - [x] Foundation
 - [x] Typography
 - [x] Icons
-- [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
-
+- [ ] App Shell
 - [ ] Primitives
   - [ ] Button
   - [ ] IconButton
   - [ ] Input
   - [ ] Surface
+- [ ] Nav-Bar
 - [ ] Workspace-Switching
-- [ ] Real-Workspace-Home
-- [ ] Real-Workspace-Tree-Hydration
-- [ ] Create-Project-Flow
-- [ ] Persist-Tree-Mutations
-- [ ] Connect-Tree-Interactions-To-Backend-Data
+- [ ] Workspace-Home
 
 ### Version 0.2.0
 
-**Goal:** Build the plugin app system on top of the base platform. And core app plugins like calendar, board, docs and text channels
+**Goal:** First real work surface.
+
+- [ ] Table
+- [ ] CVA
+- [ ] Storyboard
+- [ ] Theme-System
+  - [ ] Theme-Registry
+  - [ ] Built-In-Theme-Presets
+  - [ ] Active-Theme-Persistence
+  - [ ] Theme-Switcher
+  - [ ] Theme-JSON-Upload
+  - [ ] Theme-JSON-Import-Validation
+  - [ ] Community-Theme-Readiness
 
 ### Version 0.3.0
 
-**Goal:** Communications and Collaboration (Email System, Reminder System, and Live Collaboration on Documents)
+**Goal:** Documents and system hardening.
+
+- [ ] Document
+- [ ] Accessibility-Rules
+- [ ] Motion-Foundation
 
 ### Version 0.4.0
 
-**Goal:** Introduce the POSIX-based file system drive direction with OnlyOffice + S3 blob storage + Per File Versioning
-
-### 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)
+- [ ] Gantt-Board
+- [ ] Calendar
+- [ ] Timeline

Env/.env.example

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

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

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

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

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

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

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

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

@@ -1,17 +1,8 @@
 // Path: Frontend/src/components/shell/ProjectSelector/ProjectSelector.tsx
 
-import { For, Show, createEffect, createSignal, onCleanup, onMount, type JSX } from "solid-js";
-import { ChevronDown, ChevronRight, Folder, LayoutGrid } from "../../../lib/icons";
-import { ProjectContextMenu } from "../ProjectContextMenu/ProjectContextMenu";
+import { For, createEffect, createSignal, onCleanup, onMount, type JSX } from "solid-js";
+import { ChevronDown, Folder } from "../../../lib/icons";
 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 = {
@@ -21,532 +12,27 @@ 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());
 	});
 
-	createEffect(() => {
-		setProjectTreeNodes(buildProjectTree(appShellData.projectItems()));
-		setCollapsedFolderIds([]);
-		setPendingFolderDraft(null);
-		setPendingFolderName("");
-		setDragState(null);
-	});
-
 	onMount(() => {
-		if (triggerRef) {
+		if (!triggerRef) {
+			return;
+		}
+
 		const updateDrawerTop = (): void => {
 			if (!triggerRef) {
 				return;
 			}
 
-				setDrawerTop(triggerRef.offsetTop + triggerRef.offsetHeight + 8);
+			setDrawerTop(triggerRef.offsetTop + triggerRef.offsetHeight);
 		};
 
 		updateDrawerTop();
@@ -562,81 +48,6 @@ 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 => {
@@ -649,163 +60,27 @@ export const ProjectSelector = (props: ProjectSelectorProps): JSX.Element => {
 	};
 
 	const selectProject = (projectId: string): void => {
-		const location = findProjectNodeLocation(projectTreeNodes(), projectId);
+		const nextProject = appShellData.projectItems().find((item): boolean => item.id === projectId);
 
-		if (!location || location.node.kind !== "project") {
+		if (!nextProject) {
 			return;
 		}
 
-		setSelectedProject({ id: location.node.item.id, name: location.node.item.name });
+		setSelectedProject({ id: nextProject.id, name: nextProject.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}
@@ -814,9 +89,8 @@ export const ProjectSelector = (props: ProjectSelectorProps): JSX.Element => {
 					[styles.triggerCompact]: !!props.compact,
 					[styles.triggerOpen]: props.isOpen,
 				}}
-				aria-label={`Open project menu for ${selectedProject().name}`}
+				aria-label={`Open left workspace sidebar menu for ${selectedProject().name}`}
 				aria-expanded={props.isOpen}
-				aria-haspopup="menu"
 				title={selectedProject().name}
 				onClick={toggleOpen}
 			>
@@ -839,8 +113,7 @@ export const ProjectSelector = (props: ProjectSelectorProps): JSX.Element => {
 				/>
 			</button>
 
-			<Show when={props.isOpen}>
-				<>
+			{/* Outside-click scrim */}
 			<button
 				type="button"
 				classList={{
@@ -852,62 +125,42 @@ 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}>
-							<Show when={!props.compact}>
-								<div class={styles.treeSectionLabel}>Projects</div>
-							</Show>
+					<ul class={styles.projectList} role="list">
+					<For each={appShellData.projectItems()}>
+							{(item): JSX.Element => {
+								const isSelected = (): boolean => selectedProject().id === item.id;
 
-							<ProjectFolderBranch
-								nodes={projectTreeNodes()}
-								depth={0}
-								parentId={null}
-								selectedProjectId={selectedProject().id}
-								isFolderCollapsed={isFolderCollapsed}
-								onToggleFolder={toggleFolder}
-								onSelectProject={selectProject}
-								onOpenFolderMenu={(event, folder): void => {
-									event.stopPropagation();
-									contextMenu.openMenu(event, createProjectFolderTarget(folder.id, folder.label));
+								return (
+									<li>
+										<button
+											type="button"
+											classList={{
+												[styles.projectItem]: true,
+												[styles.projectItemActive]: isSelected(),
 											}}
-								onOpenProjectMenu={(event, item): void => {
-									event.stopPropagation();
-									contextMenu.openMenu(event, createProjectTarget(item));
+											onClick={(): void => selectProject(item.id)}
+										>
+											<span class={styles.projectItemCopy}>
+												<span class={styles.projectItemName}>{item.name}</span>
+												<span class={styles.projectItemDescription}>{item.description}</span>
+											</span>
+										</button>
+									</li>
+								);
 							}}
-								onNodePointerDown={handleNodePointerDown}
-								onNodePointerMove={handleNodePointerMove}
-								pendingFolderDraft={pendingFolderDraft()}
-								pendingFolderName={pendingFolderName()}
-								onPendingFolderNameChange={setPendingFolderName}
-								onSubmitPendingFolder={submitPendingFolder}
-								onCancelPendingFolder={cancelPendingFolder}
-								dragState={dragState()}
-							/>
+						</For>
+					</ul>
 				</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,15 +12,6 @@
   isolation: isolate;
 }
 
-.sidebarDragMode {
-	user-select: none;
-	cursor: grabbing;
-}
-
-.sidebarDragMode .treeItem {
-	cursor: grabbing;
-}
-
 .header {
   display: grid;
   gap: var(--space-3);
@@ -132,43 +123,6 @@
   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;
@@ -187,7 +141,7 @@
   width: 100%;
   min-width: 0;
   display: grid;
-  grid-template-columns: auto auto minmax(0, 1fr) auto;
+  grid-template-columns: auto minmax(0, 1fr) auto;
   align-items: center;
   gap: var(--space-2);
   min-height: calc(var(--control-size-lg) - var(--space-2));
@@ -202,51 +156,19 @@
     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: color-mix(in srgb, var(--color-surface-hover) 80%, var(--color-accent-soft) 20%);
+  background: var(--color-surface-hover);
   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, createEffect, createSignal, onCleanup, onMount, type JSX } from "solid-js";
-import { ChevronLeft, ChevronRight, Folder } from "../../../lib/icons";
+import { For, Show, createMemo, createSignal, type JSX } from "solid-js";
+import { ChevronLeft, ChevronRight } from "../../../lib/icons";
 import { useAppShellData } from "../data/app-shell.context";
 import { ProjectSelector } from "../ProjectSelector/ProjectSelector";
 import {
@@ -26,276 +26,12 @@ 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);
@@ -339,41 +75,18 @@ 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, indexAccessor): JSX.Element => {
+				{(node): JSX.Element => {
 					const Icon = getWorkspaceNodeIcon(node);
 					const target = createWorkspaceTreeTarget(node);
-					const isCollapsed = (): boolean => (node.kind === "folder" ? props.isFolderCollapsed(node.id) : false);
-					const 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>
@@ -383,13 +96,8 @@ 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}
@@ -397,28 +105,10 @@ 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;
@@ -428,16 +118,6 @@ 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}>
@@ -445,40 +125,18 @@ const WorkspaceTreeBranch = (props: {
 								</Show>
 							</button>
 
-							<Show when={node.kind === "folder" && !isCollapsed() && (((node.children?.length ?? 0) > 0) || props.pendingFolderDraft?.parentId === node.id)}>
+							<Show when={node.children?.length}>
 								<WorkspaceTreeBranch
 									nodes={node.children ?? []}
-									parentId={node.id}
 									depth={depth() + 1}
-									isFolderCollapsed={props.isFolderCollapsed}
-									onToggleFolder={props.onToggleFolder}
-									pendingFolderDraft={props.pendingFolderDraft}
-									pendingFolderName={props.pendingFolderName}
-									onPendingFolderNameChange={props.onPendingFolderNameChange}
-									onSubmitPendingFolder={props.onSubmitPendingFolder}
-									onCancelPendingFolder={props.onCancelPendingFolder}
 									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>
 	);
 };
@@ -486,209 +144,23 @@ 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 = createWorkspaceSurfaceTarget(appShellData.activeProject());
-	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],
-		);
-	};
-	const clearLongPressTimer = (): void => {
-		if (longPressTimer !== undefined) {
-			window.clearTimeout(longPressTimer);
-			longPressTimer = undefined;
+	const sidebarContextMenuTarget = createMemo(() => createWorkspaceSurfaceTarget(appShellData.activeProject()));
+	const contextMenuTarget = createMemo(() => contextMenu.menuState()?.target ?? null);
+	const contextMenuPosition = createMemo(() => {
+		const state = contextMenu.menuState();
+
+		return state
+			? {
+				x: state.x,
+				y: state.y,
 			}
-	};
-	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);
+			: null;
 	});
 
-	onMount(() => {
-		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;
-		}
+	const handleContextActionSelect = (_action: WorkspaceContextMenuAction, _target: WorkspaceContextMenuTarget): void => {
+		// Initial implementation only establishes the menu IA and placement.
 	};
 
 	return (
@@ -697,13 +169,12 @@ export const WorkspaceSidebar = (props: WorkspaceSidebarProps): JSX.Element => {
 				classList={{
 					[styles.sidebar]: true,
 					[styles.sidebarCollapsed]: props.collapsed,
-					[styles.sidebarDragMode]: !!dragState(),
 				}}
 				aria-label="Left workspace sidebar"
 				data-ui="workspace-sidebar"
 				data-collapsed={props.collapsed ? "true" : "false"}
 				onContextMenu={(event): void => {
-					contextMenu.openMenu(event, sidebarContextMenuTarget);
+					contextMenu.openMenu(event, sidebarContextMenuTarget());
 				}}
 			>
 				<div
@@ -785,21 +256,9 @@ export const WorkspaceSidebar = (props: WorkspaceSidebarProps): JSX.Element => {
 
 						<div data-slot="workspace-tree-root">
 						<WorkspaceTreeBranch
-								nodes={workspaceTreeNodes()}
-								parentId={null}
-								isFolderCollapsed={isFolderCollapsed}
-								onToggleFolder={toggleFolder}
-								pendingFolderDraft={pendingFolderDraft()}
-								pendingFolderName={pendingFolderName()}
-								onPendingFolderNameChange={setPendingFolderName}
-								onSubmitPendingFolder={submitPendingFolder}
-								onCancelPendingFolder={cancelPendingFolder}
+							nodes={appShellData.workspaceTree()}
 							onOpenContextMenu={contextMenu.openMenu}
 							onOpenContextMenuFromKeyboard={contextMenu.openMenuFromElement}
-								onNodePointerDown={handleNodePointerDown}
-								onNodePointerMove={handleNodePointerMove}
-								dragState={dragState()}
-								isTreeClickSuppressed={suppressNextTreeClick}
 						/>
 						</div>
 					</div>
@@ -807,16 +266,8 @@ export const WorkspaceSidebar = (props: WorkspaceSidebarProps): JSX.Element => {
 			</aside>
 
 			<WorkspaceContextMenu
-				target={contextMenu.menuState()?.target ?? null}
-				position={(() => {
-					const state = contextMenu.menuState();
-					return state
-						? {
-							x: state.x,
-							y: state.y,
-						}
-						: null;
-				})()}
+				target={contextMenuTarget()}
+				position={contextMenuPosition()}
 				menuRef={contextMenu.setMenuRef}
 				onClose={contextMenu.closeMenu}
 				onSelect={handleContextActionSelect}

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

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

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

@@ -71,43 +71,9 @@ export type ProjectItem = {
 	id: string;
 	name: string;
 	description: string;
-	groupLabel?: string;
-	parentLabel?: string;
-	meta?: string;
 	active?: boolean;
 };
 
-export type ProjectMenuTarget =
-	| {
-		id: string;
-		label: string;
-		kind: "surface";
-	  }
-	| {
-		id: string;
-		label: string;
-		kind: "folder";
-	  }
-	| {
-		id: string;
-		label: string;
-		kind: "project";
-	  };
-
-export type ProjectContextMenuAction = {
-	id: string;
-	label: string;
-	tone?: "default" | "danger";
-	shortcut?: WorkspaceContextMenuShortcut;
-	children?: readonly ProjectContextMenuAction[];
-};
-
-export type ProjectContextMenuSection = {
-	id: string;
-	label?: string;
-	items: readonly ProjectContextMenuAction[];
-};
-
 export type SidebarItem = {
 	id: string;
 	label: string;
@@ -398,31 +364,9 @@ export const activeDepartment: ActiveDepartment = {
 };
 
 export const projectItems: readonly ProjectItem[] = [
-	{
-		id: "general",
-		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",
-	},
+	{ id: "general", name: "General", description: "Default shared project", active: true },
+	{ id: "operations", name: "Operations", description: "Cross-team planning and delivery" },
+	{ id: "hiring", name: "Hiring", description: "Candidate pipeline and interview loops" },
 ] as const;
 
 export const departmentItems: readonly DepartmentItem[] = [
@@ -589,69 +533,6 @@ 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,6 +92,12 @@
   flex-wrap: wrap;
 }
 
+.eyebrow {
+  @include text-caption;
+  color: var(--color-text-muted);
+  text-transform: uppercase;
+}
+
 .title {
   @include text-display;
   font-family: var(--font-family-display);
@@ -240,16 +246,10 @@
   color: var(--color-text-muted);
 }
 
-.fieldHelp {
-  @include text-caption;
-  color: var(--color-text-muted);
-}
-
 .field input,
 .field select {
   min-height: var(--control-size-md);
   width: 100%;
-  font: inherit;
   border: 1px solid var(--color-border);
   border-radius: var(--radius-lg);
   background: var(--color-surface-elevated);
@@ -527,45 +527,13 @@
   }
 
   .wizardPanel {
-    width: 100vw;
-    max-height: 100dvh;
-    margin: 0;
+    width: calc(100vw - (var(--space-4) * 2));
+    max-height: calc(100dvh - (var(--space-4) * 2));
+    margin: var(--space-4) auto;
     padding: var(--space-3);
-    padding-bottom: calc(var(--space-3) + env(safe-area-inset-bottom, 0px));
-    border-radius: 0;
-  }
-
-  .wizardHeader,
-  .wizardBody,
-  .wizardSidebar {
-    gap: var(--space-3);
-  }
-
-  .wizardSteps {
-    grid-auto-flow: column;
-    grid-auto-columns: minmax(10rem, 1fr);
-    overflow-x: auto;
-    padding-bottom: var(--space-1);
-    scrollbar-width: thin;
-  }
-
-  .wizardStepButton {
-    min-width: 10rem;
   }
 
   .wizardFormActions {
     gap: var(--space-2);
-    flex-direction: column-reverse;
-    align-items: stretch;
-  }
-
-  .wizardFormActions .primaryButton {
-    margin-left: 0;
-  }
-
-  .wizardFormActions .primaryButton,
-  .wizardFormActions .secondaryButton,
-  .wizardCloseButton {
-    width: 100%;
   }
 }

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

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

Justfile

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