diff --git a/README.md b/README.md
index f13d372..68f44c0 100644
--- a/README.md
+++ b/README.md
@@ -36,9 +36,20 @@ restauração) e autenticação por **token** (Bearer para API / cookie HttpOnly
   o formato ativo (desabilitada em texto puro).
 - **Modo Edição ↔ Preview**: Markdown é renderizado no servidor (goldmark, GFM, HTML cru escapado);
   HTML é pré-visualizado em `<iframe sandbox>`; texto puro é exibido como está.
-- **Categorias/pastas** no painel lateral e **tags `#tag`** extraídas automaticamente do conteúdo
-  (cabeçalhos Markdown como `# Título` não contam — só `#tag` sem espaço). Filtro por categoria,
-  por tag e busca em título/categoria/conteúdo.
+- **Categorias como árvore de pastas**: o painel lateral traz um explorador de arquivos —
+  categorias aninhadas (subpastas), expansão/colapso, contagem de notas por pasta e menu de
+  contexto (Nova subpasta / Renomear / Excluir, sem ciclos). Uma nota pode pertencer a
+  **várias categorias** ao mesmo tempo (seletor multi-marca no topo do editor). Filtro por
+  pasta é recursivo por padrão (`?recursive=0` desliga); há também "Todas as notas" e
+  "Sem categoria". Dados antigos com o campo único `category` são migrados automaticamente
+  na abertura (vira categoria raiz de mesmo nome).
+- **Tags `#tag`** extraídas automaticamente do conteúdo (cabeçalhos Markdown como `# Título`
+  não contam — só `#tag` sem espaço), com filtro por nuvem de tags e busca em
+  título/categorias/conteúdo.
+- **Abas de arquivos**: abra várias notas ao mesmo tempo (clique na lista, `Ctrl+N` ou botão
+  ✚); cada aba tem estado sujo próprio (●), botão ✕ com confirmação, fechar com clique do
+  meio, trocar com `Alt+←/→` ou `Alt+1..9`, fechar com `Alt+W`. As abas abertas (inclusive
+  rascunhos não salvos) são restauradas entre sessões via `localStorage`.
 - **Preferências do editor** (menu Editar → Preferências… ou `Ctrl+,`, em diálogo próprio):
   - **Números de linha** (gutter alinhado mesmo com quebra de linha; alternável pelo menu Exibir).
   - **Marcador de coluna** customizável — padrão **80** (linha vertical no editor, exibida com
@@ -60,10 +71,15 @@ restauração) e autenticação por **token** (Bearer para API / cookie HttpOnly
 - **Autenticação por token**: sem token, a interface exibe um diálogo pedindo o token; ele é
   guardado em **cookie HttpOnly/SameSite=Lax** (30 dias). A API também aceita
   `Authorization: Bearer <token>` para scripts.
+- **Responsivo para celular** (≤760px): barra lateral vira gaveta com backdrop (☰ fecha ao
+  tocar uma nota), painel de versões ocupa a tela toda, toolbar e menus rolam horizontalmente
+  sem rótulos, alvos de toque ampliados, diálogos em largura total, fonte do editor com mínimo
+  de 16px (evita zoom automático do iOS), altura em `dvh` e `safe-area-inset` para notch.
 - **Estilo Mousepad**: tema claro Greybird-like, menus nativos (Arquivo/Editar/Exibir/Ajuda),
   atalhos `Ctrl+S`, `Ctrl+N`, `Ctrl+E/R` (editar/preview), `Ctrl+H` (histórico), `F9` (barra
-  lateral), `Ctrl+B/I/K` (formatação), `Ctrl+,` (preferências), barra de status com arquivo,
-  formato, linha/coluna, contagem de palavras e estado de salvamento.
+  lateral), `Ctrl+B/I/K` (formatação), `Ctrl+,` (preferências), `Alt+W`/`Alt+←/→`/`Alt+1..9`
+  (abas), barra de status com arquivo, formato, linha/coluna, contagem de palavras e estado de
+  salvamento.
 
 ## Estrutura do projeto
 
@@ -121,19 +137,25 @@ Todos os endpoints sob `/api/*` exigem o token, exceto `login/logout/me` e o fro
 
 ```bash
 T=$NOTES_TOKEN; B=http://localhost:8080
-curl -H "Authorization: Bearer $T" $B/api/notes                 # lista (filtros: ?category=&tag=&q=)
+curl -H "Authorization: Bearer $T" $B/api/notes   # lista (?category=<id|none>&recursive=0&tag=&q=)
 curl -H "Authorization: Bearer $T" $B/api/notes/<id>            # nota + conteúdo
-curl -X POST -H "Authorization: Bearer $T" -H 'Content-Type: application/json' \
-     -d '{"title":"Olá","format":"md","category":"dev","content":"# Oi #linux"}' $B/api/notes
+curl -s -X POST -H "Authorization: Bearer $T" -H 'Content-Type: application/json' \
+     -d '{"title":"Olá","format":"md","categories":["<id>"],"content":"# Oi #linux"}' $B/api/notes
 curl -X PUT  -H "Authorization: Bearer $T" -H 'Content-Type: application/json' \
-     -d '{"title":"Olá","format":"md","category":"dev","content":"editado","author":"lg","message":"revisão 2"}' \
+     -d '{"title":"Olá","format":"md","categories":["<id>"],"content":"editado","author":"lg","message":"revisão 2"}' \
      $B/api/notes/<id>
 curl -H "Authorization: Bearer $T" $B/api/notes/<id>/revisions                # histórico
 curl -H "Authorization: Bearer $T" $B/api/notes/<id>/revisions/<hash>/diff     # diff unificado
 curl -X POST -H "Authorization: Bearer $T" $B/api/notes/<id>/revisions/<hash>/restore \
      -H 'Content-Type: application/json' -d '{"author":"lg"}'                  # restaurar
 curl -H "Authorization: Bearer $T" $B/api/notes/<id>/raw                      # download .txt/.md/.html
-curl -H "Authorization: Bearer $T" $B/api/tags   $B/api/categories
+curl -H "Authorization: Bearer $T" $B/api/tags   $B/api/categories            # agregações
+# árvore de categorias (lista plana; parent="" é raiz)
+curl -X POST -H "Authorization: Bearer $T" -H 'Content-Type: application/json' \
+     -d '{"name":"devops","parent":""}' $B/api/categories
+curl -X PUT  -H "Authorization: Bearer $T" -H 'Content-Type: application/json' \
+     -d '{"name":"infra","parent":"<novo-pai>"}' $B/api/categories/<id>       # renomear/mover
+curl -X DELETE -H "Authorization: Bearer $T" $B/api/categories/<id>           # remove subtree
 ```
 
 ## Como funciona o versionamento
@@ -142,7 +164,9 @@ curl -H "Authorization: Bearer $T" $B/api/tags   $B/api/categories
   Git): conteúdo repetido ocupa um único blob.
 - Cada nota tem `data/notes/<id>/meta.json` (estado atual) e `history.json` (lista ordenada de
   revisões: `hash`, `parent`, `author`, `when`, `message`, `bytes`).
-- Salvar sem alterar o conteúdo atualiza apenas os metadados (título/categoria/formato) — sem
+- A árvore de categorias fica em `data/categories.json` (lista plana com `parent`; nomes únicos
+  entre irmãos; mover para dentro de si mesma é recusado).
+- Salvar sem alterar o conteúdo atualiza apenas os metadados (título/categorias/formato) — sem
   revisão nova. Restaurar cria uma revisão nova apontando para o blob antigo.
 - Apagar uma nota faz GC dos blobs que ficaram sem referência.
 
diff --git a/internal/api/api_test.go b/internal/api/api_test.go
index 60e0bb1..ca15ec3 100644
--- a/internal/api/api_test.go
+++ b/internal/api/api_test.go
@@ -61,13 +61,13 @@ func decode(t *testing.T, resp *http.Response, v any) {
 }
 
 type noteView struct {
-	ID      string   `json:"id"`
-	Title   string   `json:"title"`
-	Format  string   `json:"format"`
-	Category string  `json:"category"`
-	Tags    []string `json:"tags"`
-	Hash    string   `json:"hash"`
-	Content string   `json:"content"`
+	ID         string   `json:"id"`
+	Title      string   `json:"title"`
+	Format     string   `json:"format"`
+	Categories []string `json:"categories"`
+	Tags       []string `json:"tags"`
+	Hash       string   `json:"hash"`
+	Content    string   `json:"content"`
 }
 
 func TestAuthRequiredAndLoginFlow(t *testing.T) {
@@ -130,15 +130,26 @@ func TestNoteLifecycleWithHistoryAndRestore(t *testing.T) {
 		return do(t, srv, method, path, body, testToken, "")
 	}
 
-	// Criar.
-	resp := call("POST", "/api/notes",
-		`{"title":"Servidor","format":"md","category":"devops","content":"# Notas\n\n#linux #systemd","author":"lg","message":""}`)
+	// Criar uma categoria raiz e uma filha para vincular à nota.
+	resp := call("POST", "/api/categories", `{"name":"devops","parent":""}`)
+	if resp.StatusCode != http.StatusCreated {
+		t.Fatalf("create category: %s", resp.Status)
+	}
+	var cat struct {
+		ID   string `json:"id"`
+		Name string `json:"name"`
+	}
+	decode(t, resp, &cat)
+
+	// Criar nota em múltiplas categorias.
+	resp = call("POST", "/api/notes",
+		`{"title":"Servidor","format":"md","categories":["`+cat.ID+`"],"content":"# Notas\n\n#linux #systemd","author":"lg","message":""}`)
 	if resp.StatusCode != http.StatusCreated {
 		t.Fatalf("create: %s", resp.Status)
 	}
 	var created noteView
 	decode(t, resp, &created)
-	if created.ID == "" || len(created.Tags) != 2 {
+	if created.ID == "" || len(created.Tags) != 2 || len(created.Categories) != 1 {
 		t.Fatalf("payload criado: %+v", created)
 	}
 	id := created.ID
@@ -161,7 +172,7 @@ func TestNoteLifecycleWithHistoryAndRestore(t *testing.T) {
 
 	// Atualizar: nova revisão.
 	resp = call("PUT", "/api/notes/"+id,
-		`{"title":"Servidor","format":"md","category":"devops","content":"# Notas\n\n#linux","author":"lg","message":"removi systemd"}`)
+		`{"title":"Servidor","format":"md","categories":["`+cat.ID+`"],"content":"# Notas\n\n#linux","author":"lg","message":"removi systemd"}`)
 	var updated noteView
 	decode(t, resp, &updated)
 	if updated.Hash == created.Hash {
@@ -231,7 +242,9 @@ func TestRenderMarkdownIsSafe(t *testing.T) {
 	srv := newTestServer(t)
 	resp := do(t, srv, "POST", "/api/render",
 		`{"content":"**negrito** <script>alert(1)</script>\nlinha1\nlinha2","format":"md"}`, testToken, "")
-	var out struct{ HTML string `json:"html"` }
+	var out struct {
+		HTML string `json:"html"`
+	}
 	decode(t, resp, &out)
 	if !strings.Contains(out.HTML, "<strong>negrito</strong>") {
 		t.Errorf("markdown não renderizado: %q", out.HTML)
@@ -251,6 +264,77 @@ func TestRenderMarkdownIsSafe(t *testing.T) {
 	resp.Body.Close()
 }
 
+func TestCategoryCRUDViaAPI(t *testing.T) {
+	srv := newTestServer(t)
+	call := func(method, path, body string) *http.Response {
+		return do(t, srv, method, path, body, testToken, "")
+	}
+
+	resp := call("POST", "/api/categories", `{"name":"infra","parent":""}`)
+	var infra struct{ ID string }
+	decode(t, resp, &infra)
+	resp = call("POST", "/api/categories", `{"name":"linux","parent":"`+infra.ID+`"}`)
+	var linux struct{ ID string }
+	decode(t, resp, &linux)
+
+	// duplicata entre irmãos → 400
+	resp = call("POST", "/api/categories", `{"name":"Infra","parent":""}`)
+	if resp.StatusCode != http.StatusBadRequest {
+		t.Fatalf("duplicata: %s", resp.Status)
+	}
+	resp.Body.Close()
+
+	// nota na subcategoria
+	resp = call("POST", "/api/notes", `{"title":"Kernel","format":"txt","categories":["`+linux.ID+`"],"content":"x","author":"","message":""}`)
+	var note noteView
+	decode(t, resp, &note)
+
+	// filtro recursivo pela raiz (padrão) → 1 nota; não-recursivo → 0
+	resp = call("GET", "/api/notes?category="+infra.ID, "")
+	var rec []noteView
+	decode(t, resp, &rec)
+	if len(rec) != 1 {
+		t.Fatalf("recursivo: %+v", rec)
+	}
+	resp = call("GET", "/api/notes?category="+infra.ID+"&recursive=0", "")
+	var nonrec []noteView
+	decode(t, resp, &nonrec)
+	if len(nonrec) != 0 {
+		t.Fatalf("não-recursivo: %+v", nonrec)
+	}
+
+	// ciclo: mover infra para dentro de linux → 400
+	resp = call("PUT", "/api/categories/"+infra.ID, `{"name":"","parent":"`+linux.ID+`"}`)
+	if resp.StatusCode != http.StatusBadRequest {
+		t.Fatalf("ciclo deveria dar 400, obtive %s", resp.Status)
+	}
+	resp.Body.Close()
+
+	// excluir raiz remove subtree e limpa a nota
+	resp = call("DELETE", "/api/categories/"+infra.ID, "")
+	if resp.StatusCode != http.StatusNoContent {
+		t.Fatalf("delete: %s", resp.Status)
+	}
+	resp = call("GET", "/api/notes/"+note.ID, "")
+	decode(t, resp, &note)
+	if len(note.Categories) != 0 {
+		t.Errorf("nota deveria ficar órfã: %+v", note.Categories)
+	}
+	resp = call("GET", "/api/categories", "")
+	var cats []map[string]any
+	decode(t, resp, &cats)
+	if len(cats) != 0 {
+		t.Errorf("árvore deveria estar vazia: %+v", cats)
+	}
+
+	// categoria inexistente em nota → 400
+	resp = call("POST", "/api/notes", `{"title":"x","format":"txt","categories":["zzzzzzzzzzzz"],"content":"", "author":"","message":""}`)
+	if resp.StatusCode != http.StatusBadRequest {
+		t.Fatalf("categoria fantasma: %s", resp.Status)
+	}
+	resp.Body.Close()
+}
+
 func TestInvalidPayloads(t *testing.T) {
 	srv := newTestServer(t)
 	resp := do(t, srv, "POST", "/api/notes", `{"format":"rtf","content":"x"}`, testToken, "")
diff --git a/internal/api/categories.go b/internal/api/categories.go
new file mode 100644
index 0000000..3ac19b4
--- /dev/null
+++ b/internal/api/categories.go
@@ -0,0 +1,50 @@
+package api
+
+import (
+	"net/http"
+)
+
+type categoryInput struct {
+	Name   string  `json:"name"`
+	Parent *string `json:"parent"` // ausente = não move; "" = raiz
+}
+
+func (s *Server) handleCreateCategory(w http.ResponseWriter, r *http.Request) {
+	var in categoryInput
+	if err := decodeJSON(r, &in, 1<<20); err != nil {
+		writeError(w, http.StatusBadRequest, "corpo JSON inválido")
+		return
+	}
+	parent := ""
+	if in.Parent != nil {
+		parent = *in.Parent
+	}
+	c, err := s.st.CreateCategory(in.Name, parent)
+	if err != nil {
+		mapStoreError(w, err)
+		return
+	}
+	writeJSON(w, http.StatusCreated, c)
+}
+
+func (s *Server) handleUpdateCategory(w http.ResponseWriter, r *http.Request) {
+	var in categoryInput
+	if err := decodeJSON(r, &in, 1<<20); err != nil {
+		writeError(w, http.StatusBadRequest, "corpo JSON inválido")
+		return
+	}
+	c, err := s.st.UpdateCategory(r.PathValue("id"), in.Name, in.Parent)
+	if err != nil {
+		mapStoreError(w, err)
+		return
+	}
+	writeJSON(w, http.StatusOK, c)
+}
+
+func (s *Server) handleDeleteCategory(w http.ResponseWriter, r *http.Request) {
+	if err := s.st.DeleteCategory(r.PathValue("id")); err != nil {
+		mapStoreError(w, err)
+		return
+	}
+	w.WriteHeader(http.StatusNoContent)
+}
diff --git a/internal/api/notes.go b/internal/api/notes.go
index cf7dc4d..ab04aeb 100644
--- a/internal/api/notes.go
+++ b/internal/api/notes.go
@@ -22,20 +22,20 @@ func (s *Server) serveIndex(w http.ResponseWriter, r *http.Request) {
 
 // noteInput é o corpo aceito por POST/PUT de notas.
 type noteInput struct {
-	Title    string `json:"title"`
-	Format   string `json:"format"`
-	Category string `json:"category"`
-	Content  string `json:"content"`
-	Author   string `json:"author"`
-	Message  string `json:"message"`
+	Title      string   `json:"title"`
+	Format     string   `json:"format"`
+	Categories []string `json:"categories"` // IDs da árvore de categorias
+	Content    string   `json:"content"`
+	Author     string   `json:"author"`
+	Message    string   `json:"message"`
 }
 
-func (in noteInput) fields() (string, string, string, string, string, string) {
+func (in noteInput) fields() (string, string, []string, string, string, string) {
 	f := in.Format
 	if f == "" {
 		f = store.FormatTxt
 	}
-	return in.Title, f, in.Category, in.Content, in.Author, in.Message
+	return in.Title, f, in.Categories, in.Content, in.Author, in.Message
 }
 
 // noteView é a representação completa (meta + conteúdo) de uma nota.
@@ -46,10 +46,12 @@ type noteView struct {
 
 func (s *Server) handleListNotes(w http.ResponseWriter, r *http.Request) {
 	q := r.URL.Query()
+	recursive := q.Get("recursive") != "0"
 	notes, err := s.st.List(store.Filter{
-		Category: q.Get("category"),
-		Tag:      q.Get("tag"),
-		Query:    q.Get("q"),
+		Category:  q.Get("category"),
+		Recursive: recursive,
+		Tag:       q.Get("tag"),
+		Query:     q.Get("q"),
 	})
 	if err != nil {
 		mapStoreError(w, err)
@@ -67,8 +69,8 @@ func (s *Server) handleCreateNote(w http.ResponseWriter, r *http.Request) {
 		writeError(w, http.StatusBadRequest, "corpo JSON inválido")
 		return
 	}
-	title, format, category, content, author, message := in.fields()
-	n, err := s.st.Create(title, format, category, content, author, message)
+	title, format, categories, content, author, message := in.fields()
+	n, err := s.st.Create(title, format, categories, content, author, message)
 	if err != nil {
 		mapStoreError(w, err)
 		return
@@ -91,8 +93,8 @@ func (s *Server) handleUpdateNote(w http.ResponseWriter, r *http.Request) {
 		writeError(w, http.StatusBadRequest, "corpo JSON inválido")
 		return
 	}
-	title, format, category, content, author, message := in.fields()
-	n, err := s.st.Update(r.PathValue("id"), title, format, category, content, author, message)
+	title, format, categories, content, author, message := in.fields()
+	n, err := s.st.Update(r.PathValue("id"), title, format, categories, content, author, message)
 	if err != nil {
 		mapStoreError(w, err)
 		return
@@ -159,7 +161,7 @@ func (s *Server) handleCategories(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	if cats == nil {
-		cats = []store.CatCount{}
+		cats = []store.CategoryView{}
 	}
 	writeJSON(w, http.StatusOK, cats)
 }
diff --git a/internal/api/server.go b/internal/api/server.go
index 4b5ea40..0597bd6 100644
--- a/internal/api/server.go
+++ b/internal/api/server.go
@@ -66,6 +66,9 @@ func (s *Server) Handler() http.Handler {
 
 	mux.HandleFunc("GET /api/tags", s.auth(s.handleTags))
 	mux.HandleFunc("GET /api/categories", s.auth(s.handleCategories))
+	mux.HandleFunc("POST /api/categories", s.auth(s.handleCreateCategory))
+	mux.HandleFunc("PUT /api/categories/{id}", s.auth(s.handleUpdateCategory))
+	mux.HandleFunc("DELETE /api/categories/{id}", s.auth(s.handleDeleteCategory))
 	mux.HandleFunc("POST /api/render", s.auth(s.handleRender))
 
 	mux.HandleFunc("GET /{$}", s.serveIndex)
diff --git a/internal/store/store.go b/internal/store/store.go
index 3fb06b3..261da94 100644
--- a/internal/store/store.go
+++ b/internal/store/store.go
@@ -44,24 +44,24 @@ const (
 
 // Erros sentinel da camada de armazenamento.
 var (
-	ErrNotFound     = errors.New("nota não encontrada")
-	ErrRevision     = errors.New("revisão não encontrada")
-	ErrInvalid      = errors.New("dados inválidos")
-	ErrTooLarge     = errors.New("conteúdo excede o limite de tamanho")
-	ErrUnchanged    = errors.New("conteúdo idêntico à versão atual")
+	ErrNotFound  = errors.New("nota não encontrada")
+	ErrRevision  = errors.New("revisão não encontrada")
+	ErrInvalid   = errors.New("dados inválidos")
+	ErrTooLarge  = errors.New("conteúdo excede o limite de tamanho")
+	ErrUnchanged = errors.New("conteúdo idêntico à versão atual")
 )
 
 // Note é o estado atual de uma nota (sem o conteúdo).
 type Note struct {
-	ID        string    `json:"id"`
-	Title     string    `json:"title"`
-	Format    string    `json:"format"`
-	Category  string    `json:"category"`
-	Tags      []string  `json:"tags"`
-	CreatedAt time.Time `json:"created_at"`
-	UpdatedAt time.Time `json:"updated_at"`
-	Hash      string    `json:"hash"` // blob do conteúdo atual
-	Bytes     int       `json:"bytes"`
+	ID         string    `json:"id"`
+	Title      string    `json:"title"`
+	Format     string    `json:"format"`
+	Categories []string  `json:"categories"` // IDs de categoria (árvore)
+	Tags       []string  `json:"tags"`
+	CreatedAt  time.Time `json:"created_at"`
+	UpdatedAt  time.Time `json:"updated_at"`
+	Hash       string    `json:"hash"` // blob do conteúdo atual
+	Bytes      int       `json:"bytes"`
 }
 
 // Filename devolve "titulo.ext" sanitizado para download.
@@ -105,27 +105,307 @@ type RevisionWithContent struct {
 	Content string `json:"content"`
 }
 
-// Filter restringe a Listagem de notas.
+// Filtro de listagem. Category aceita "" (todas), "none" (sem categoria) ou um
+// ID de categoria; Recursive (padrão) inclui notas de categorias descendentes.
 type Filter struct {
-	Category string // "" = todas
-	Tag      string // "" = todas (sem #)
-	Query    string // busca em título, categoria e conteúdo (case-insensitive)
+	Category  string
+	Recursive bool
+	Tag       string // "" = todas (sem #)
+	Query     string // busca em título, categoria e conteúdo (case-insensitive)
+}
+
+// Category é uma pasta da árvore de categorias.
+type Category struct {
+	ID        string    `json:"id"`
+	Name      string    `json:"name"`
+	Parent    string    `json:"parent"` // "" = raiz
+	CreatedAt time.Time `json:"created_at"`
+}
+
+// CategoryView é uma categoria com agregações para a UI.
+type CategoryView struct {
+	Category
+	NoteCount int  `json:"note_count"` // notas com esta categoria exata
+	HasChild  bool `json:"has_child"`  // tem subcategorias filhas
 }
 
 // Store é seguro para concorrência.
 type Store struct {
-	dir string
-	mu  sync.RWMutex
+	dir  string
+	mu   sync.RWMutex
+	cats []Category // cache da árvore; persistido em categories.json
 }
 
-// New abre (ou cria) o diretório raiz de dados.
+// New abre (ou cria) o diretório raiz de dados e migra metadados legados
+// (nota com campo único "category" vira categoria raiz de mesmo nome).
 func New(dir string) (*Store, error) {
 	for _, sub := range []string{"notes", "blobs"} {
 		if err := os.MkdirAll(filepath.Join(dir, sub), 0o750); err != nil {
 			return nil, err
 		}
 	}
-	return &Store{dir: dir}, nil
+	s := &Store{dir: dir}
+	if err := s.loadCats(); err != nil {
+		return nil, err
+	}
+	if err := s.migrateLegacy(); err != nil {
+		return nil, err
+	}
+	return s, nil
+}
+
+// ---------------------------------------------------------------------------
+// Árvore de categorias (categories.json)
+// ---------------------------------------------------------------------------
+
+func (s *Store) catsPath() string { return filepath.Join(s.dir, "categories.json") }
+
+func (s *Store) loadCats() error {
+	s.cats = nil
+	var cats []Category
+	err := readJSON(s.catsPath(), &cats)
+	switch {
+	case errors.Is(err, ErrNotFound):
+		return nil
+	case err != nil:
+		return err
+	}
+	s.cats = cats
+	return nil
+}
+
+func (s *Store) catByID(id string) *Category {
+	for i := range s.cats {
+		if s.cats[i].ID == id {
+			return &s.cats[i]
+		}
+	}
+	return nil
+}
+
+// catSubtree devolve id e todos os descendentes (ordem de percurso).
+func (s *Store) catSubtree(id string) []string {
+	out := []string{id}
+	for i := 0; i < len(out); i++ {
+		for _, c := range s.cats {
+			if c.Parent == out[i] {
+				out = append(out, c.ID)
+			}
+		}
+	}
+	return out
+}
+
+func (s *Store) catName(id string) string {
+	if c := s.catByID(id); c != nil {
+		return c.Name
+	}
+	return ""
+}
+
+// CreateCategory cria uma pasta; nomes únicos entre irmãos (case-insensitive).
+func (s *Store) CreateCategory(name, parent string) (*Category, error) {
+	name = strings.TrimSpace(name)
+	if r := []rune(name); name == "" || len(r) > maxCategoryLen {
+		return nil, fmt.Errorf("%w: nome de categoria inválido", ErrInvalid)
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if parent != "" && s.catByID(parent) == nil {
+		return nil, fmt.Errorf("%w: categoria pai inexistente", ErrInvalid)
+	}
+	lower := strings.ToLower(name)
+	for _, c := range s.cats {
+		if c.Parent == parent && strings.ToLower(c.Name) == lower {
+			return nil, fmt.Errorf("%w: já existe uma categoria %q nesse nível", ErrInvalid, name)
+		}
+	}
+	cat := Category{ID: newID(), Name: name, Parent: parent, CreatedAt: time.Now().UTC()}
+	s.cats = append(s.cats, cat)
+	if err := writeJSONAtomic(s.catsPath(), s.cats); err != nil {
+		return nil, err
+	}
+	return &cat, nil
+}
+
+// UpdateCategory renomeia (name == "" mantém) e/ou move (parent != nil) a categoria.
+func (s *Store) UpdateCategory(id, name string, parent *string) (*Category, error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	c := s.catByID(id)
+	if c == nil {
+		return nil, ErrNotFound
+	}
+	if parent != nil && *parent != c.Parent {
+		if *parent != "" && s.catByID(*parent) == nil {
+			return nil, fmt.Errorf("%w: categoria pai inexistente", ErrInvalid)
+		}
+		for _, d := range s.catSubtree(id) { // sem ciclos: pai não pode ser descendente
+			if d == *parent {
+				return nil, fmt.Errorf("%w: não é possível mover uma categoria para dentro dela mesma", ErrInvalid)
+			}
+		}
+		c.Parent = *parent
+	}
+	if n := strings.TrimSpace(name); n != "" && n != c.Name {
+		if len([]rune(n)) > maxCategoryLen {
+			return nil, fmt.Errorf("%w: nome de categoria inválido", ErrInvalid)
+		}
+		lower := strings.ToLower(n)
+		for _, other := range s.cats {
+			if other.ID != id && other.Parent == c.Parent && strings.ToLower(other.Name) == lower {
+				return nil, fmt.Errorf("%w: já existe uma categoria %q nesse nível", ErrInvalid, n)
+			}
+		}
+		c.Name = n
+	}
+	if err := writeJSONAtomic(s.catsPath(), s.cats); err != nil {
+		return nil, err
+	}
+	cp := *c
+	return &cp, nil
+}
+
+// DeleteCategory remove a categoria e suas descendentes; notas permanecem,
+// apenas perdem as vinculações removidas.
+func (s *Store) DeleteCategory(id string) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if s.catByID(id) == nil {
+		return ErrNotFound
+	}
+	sub := map[string]bool{}
+	for _, d := range s.catSubtree(id) {
+		sub[d] = true
+	}
+	kept := s.cats[:0]
+	for _, c := range s.cats {
+		if !sub[c.ID] {
+			kept = append(kept, c)
+		}
+	}
+	s.cats = kept
+	if err := writeJSONAtomic(s.catsPath(), s.cats); err != nil {
+		return err
+	}
+	ids, err := s.noteIDs()
+	if err != nil {
+		return err
+	}
+	for _, nid := range ids {
+		n, err := s.get(nid)
+		if err != nil {
+			continue
+		}
+		cleaned := make([]string, 0, len(n.Categories))
+		changed := false
+		for _, cid := range n.Categories {
+			if sub[cid] {
+				changed = true
+				continue
+			}
+			cleaned = append(cleaned, cid)
+		}
+		if changed {
+			n.Categories = cleaned
+			if err := writeJSONAtomic(s.metaPath(nid), n); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+// Categories devolve a árvore completa (lista plana; a UI monta os nós).
+func (s *Store) Categories() ([]CategoryView, error) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	counts := map[string]int{}
+	ids, err := s.noteIDs()
+	if err != nil {
+		return nil, err
+	}
+	for _, id := range ids {
+		n, err := s.get(id)
+		if err != nil {
+			continue
+		}
+		for _, cid := range n.Categories {
+			counts[cid]++
+		}
+	}
+	out := make([]CategoryView, 0, len(s.cats))
+	for _, c := range s.cats {
+		v := CategoryView{Category: c, NoteCount: counts[c.ID]}
+		for _, other := range s.cats {
+			if other.Parent == c.ID {
+				v.HasChild = true
+				break
+			}
+		}
+		out = append(out, v)
+	}
+	return out, nil
+}
+
+// validateCatIDs confere se todas as categorias existem (sob lock de escrita).
+func (s *Store) validateCatIDs(ids []string) ([]string, error) {
+	seen := map[string]bool{}
+	var out []string
+	for _, id := range ids {
+		if id == "" || s.catByID(id) == nil {
+			return nil, fmt.Errorf("%w: categoria inexistente %q", ErrInvalid, id)
+		}
+		if !seen[id] {
+			seen[id] = true
+			out = append(out, id)
+		}
+	}
+	return out, nil
+}
+
+// migrateLegacy converte o campo único "category" (pré-árvore) em categoria raiz.
+func (s *Store) migrateLegacy() error {
+	ids, err := s.noteIDs()
+	if err != nil {
+		return err
+	}
+	changed := false
+	for _, id := range ids {
+		var meta struct {
+			Note
+			Category string `json:"category"` // legado
+		}
+		if err := readJSON(s.metaPath(id), &meta); err != nil {
+			continue
+		}
+		legacy := strings.TrimSpace(meta.Category)
+		if legacy == "" || len(meta.Categories) > 0 {
+			continue
+		}
+		var cat *Category
+		lower := strings.ToLower(legacy)
+		for i := range s.cats {
+			if s.cats[i].Parent == "" && strings.ToLower(s.cats[i].Name) == lower {
+				cat = &s.cats[i]
+				break
+			}
+		}
+		if cat == nil {
+			cat = &Category{ID: newID(), Name: legacy, Parent: "", CreatedAt: time.Now().UTC()}
+			s.cats = append(s.cats, *cat)
+			changed = true
+		}
+		n := meta.Note
+		n.Categories = []string{cat.ID}
+		if err := writeJSONAtomic(s.metaPath(id), n); err != nil {
+			return err
+		}
+	}
+	if changed {
+		return writeJSONAtomic(s.catsPath(), s.cats)
+	}
+	return nil
 }
 
 // ---------------------------------------------------------------------------
@@ -236,15 +516,11 @@ func normalizeFormat(f string) (string, error) {
 	return f, nil
 }
 
-func cleanNoteFields(title, category *string, format *string) error {
+func cleanNoteFields(title, format *string) error {
 	*title = strings.TrimSpace(*title)
 	if r := []rune(*title); len(r) > maxTitleLen {
 		*title = string(r[:maxTitleLen])
 	}
-	*category = strings.TrimSpace(*category)
-	if r := []rune(*category); len(r) > maxCategoryLen {
-		*category = string(r[:maxCategoryLen])
-	}
 	f, err := normalizeFormat(*format)
 	if err != nil {
 		return err
@@ -267,8 +543,8 @@ var idRe = regexp.MustCompile(`^[a-z0-9]{6,32}$`)
 // ---------------------------------------------------------------------------
 
 // Create grava uma nova nota com sua primeira revisão.
-func (s *Store) Create(title, format, category, content, author, message string) (*Note, error) {
-	if err := cleanNoteFields(&title, &category, &format); err != nil {
+func (s *Store) Create(title, format string, categories []string, content, author, message string) (*Note, error) {
+	if err := cleanNoteFields(&title, &format); err != nil {
 		return nil, err
 	}
 	if err := validateContent(content); err != nil {
@@ -276,6 +552,10 @@ func (s *Store) Create(title, format, category, content, author, message string)
 	}
 	s.mu.Lock()
 	defer s.mu.Unlock()
+	cats, err := s.validateCatIDs(categories)
+	if err != nil {
+		return nil, err
+	}
 
 	id := newID()
 	now := time.Now().UTC()
@@ -287,7 +567,7 @@ func (s *Store) Create(title, format, category, content, author, message string)
 		return nil, err
 	}
 	n := &Note{
-		ID: id, Title: title, Format: format, Category: category,
+		ID: id, Title: title, Format: format, Categories: cats,
 		Tags: ExtractTags(content), CreatedAt: now, UpdatedAt: now,
 		Hash: hash, Bytes: len(content),
 	}
@@ -336,9 +616,9 @@ func (s *Store) Content(id string) (string, *Note, error) {
 }
 
 // Update salva metadados e, se o conteúdo mudou, uma nova revisão.
-// Um conteúdo inalterado atualiza apenas título/categoria/formato.
-func (s *Store) Update(id, title, format, category, content, author, message string) (*Note, error) {
-	if err := cleanNoteFields(&title, &category, &format); err != nil {
+// Um conteúdo inalterado atualiza apenas título/categorias/formato.
+func (s *Store) Update(id, title, format string, categories []string, content, author, message string) (*Note, error) {
+	if err := cleanNoteFields(&title, &format); err != nil {
 		return nil, err
 	}
 	if err := validateContent(content); err != nil {
@@ -346,6 +626,10 @@ func (s *Store) Update(id, title, format, category, content, author, message str
 	}
 	s.mu.Lock()
 	defer s.mu.Unlock()
+	cats, err := s.validateCatIDs(categories)
+	if err != nil {
+		return nil, err
+	}
 
 	n, err := s.get(id)
 	if err != nil {
@@ -375,7 +659,7 @@ func (s *Store) Update(id, title, format, category, content, author, message str
 		tags = ExtractTags(content)
 	}
 	now := time.Now().UTC()
-	meta := &Note{ID: n.ID, Title: title, Format: format, Category: category, Tags: tags,
+	meta := &Note{ID: n.ID, Title: title, Format: format, Categories: cats, Tags: tags,
 		CreatedAt: n.CreatedAt, UpdatedAt: now, Hash: newHash, Bytes: len(content)}
 	if err := writeJSONAtomic(s.metaPath(id), meta); err != nil {
 		return nil, err
@@ -468,6 +752,23 @@ func (s *Store) List(f Filter) ([]*Note, error) {
 
 	s.mu.RLock()
 	defer s.mu.RUnlock()
+
+	// Conjunto de categorias aceitas para o filtro (id + descendentes se recursivo).
+	var allowed map[string]bool
+	if f.Category != "" && f.Category != "none" {
+		if s.catByID(f.Category) == nil {
+			return nil, fmt.Errorf("%w: categoria inexistente", ErrInvalid)
+		}
+		allowed = map[string]bool{}
+		ids := []string{f.Category}
+		if f.Recursive {
+			ids = s.catSubtree(f.Category)
+		}
+		for _, id := range ids {
+			allowed[id] = true
+		}
+	}
+
 	ids, err := s.noteIDs()
 	if err != nil {
 		return nil, err
@@ -478,8 +779,23 @@ func (s *Store) List(f Filter) ([]*Note, error) {
 		if err != nil {
 			continue
 		}
-		if f.Category != "" && n.Category != f.Category {
-			continue
+		switch f.Category {
+		case "":
+		case "none":
+			if len(n.Categories) > 0 {
+				continue
+			}
+		default:
+			hit := false
+			for _, cid := range n.Categories {
+				if allowed[cid] {
+					hit = true
+					break
+				}
+			}
+			if !hit {
+				continue
+			}
 		}
 		if f.Tag != "" && !slices.Contains(n.Tags, f.Tag) {
 			continue
@@ -495,10 +811,14 @@ func (s *Store) List(f Filter) ([]*Note, error) {
 
 func (s *Store) matchesQuery(n *Note, q string) bool {
 	if strings.Contains(strings.ToLower(n.Title), q) ||
-		strings.Contains(strings.ToLower(n.Category), q) ||
 		slices.ContainsFunc(n.Tags, func(t string) bool { return strings.Contains(t, q) }) {
 		return true
 	}
+	for _, cid := range n.Categories {
+		if strings.Contains(strings.ToLower(s.catName(cid)), q) {
+			return true
+		}
+	}
 	content, err := s.getBlob(n.Hash)
 	if err != nil {
 		return false
@@ -671,41 +991,6 @@ func (s *Store) Tags() ([]TagCount, error) {
 	return out, nil
 }
 
-// CatCount é uma categoria agregada com número de notas. "" = sem categoria.
-type CatCount struct {
-	Category string `json:"category"`
-	Count    int    `json:"count"`
-}
-
-// Categories devolve as categorias em uso.
-func (s *Store) Categories() ([]CatCount, error) {
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-	counts := map[string]int{}
-	ids, err := s.noteIDs()
-	if err != nil {
-		return nil, err
-	}
-	for _, id := range ids {
-		n, err := s.get(id)
-		if err != nil {
-			continue
-		}
-		counts[n.Category]++
-	}
-	out := make([]CatCount, 0, len(counts))
-	for c, k := range counts {
-		out = append(out, CatCount{Category: c, Count: k})
-	}
-	sort.Slice(out, func(i, j int) bool {
-		if (out[i].Category == "") != (out[j].Category == "") {
-			return out[j].Category == "" // sem categoria por último
-		}
-		return out[i].Category < out[j].Category
-	})
-	return out, nil
-}
-
 func fallback(v, def string) string {
 	v = strings.TrimSpace(v)
 	if v == "" {
diff --git a/internal/store/store_test.go b/internal/store/store_test.go
index a331383..03f9197 100644
--- a/internal/store/store_test.go
+++ b/internal/store/store_test.go
@@ -1,6 +1,7 @@
 package store
 
 import (
+	"encoding/json"
 	"errors"
 	"os"
 	"path/filepath"
@@ -17,10 +18,19 @@ func newTestStore(t *testing.T) *Store {
 	return s
 }
 
+func mustCat(t *testing.T, s *Store, name, parent string) string {
+	t.Helper()
+	c, err := s.CreateCategory(name, parent)
+	if err != nil {
+		t.Fatalf("CreateCategory(%q): %v", name, err)
+	}
+	return c.ID
+}
+
 func TestCreateExtractsTagsAndIgnoresHeadings(t *testing.T) {
 	s := newTestStore(t)
 	content := "# Título do post\n\nUso #Linux e #devops.\n#linux repetida, #Hardware\n"
-	n, err := s.Create("Boas vindas", FormatMD, "infra", content, "lg", "")
+	n, err := s.Create("Boas vindas", FormatMD, nil, content, "lg", "")
 	if err != nil {
 		t.Fatalf("Create: %v", err)
 	}
@@ -32,12 +42,6 @@ func TestCreateExtractsTagsAndIgnoresHeadings(t *testing.T) {
 			t.Errorf("tag %q ausente em %v", tag, n.Tags)
 		}
 	}
-	// cabeçalho "# Título" não deve virar tag ("Título" nem entraria, e "título" tem acento)
-	for _, tag := range n.Tags {
-		if strings.Contains(tag, "t") && strings.HasPrefix(tag, "tí") {
-			t.Errorf("cabeçalho vazou como tag: %v", n.Tags)
-		}
-	}
 	if n.Hash == "" || n.Bytes != len(content) {
 		t.Errorf("hash/bytes errados: %q %d", n.Hash, n.Bytes)
 	}
@@ -54,7 +58,8 @@ func contains(xs []string, x string) bool {
 
 func TestUpdateCreatesRevisionOnlyOnContentChange(t *testing.T) {
 	s := newTestStore(t)
-	n, err := s.Create("nota", FormatTxt, "", "v1", "lg", "")
+	dev := mustCat(t, s, "dev", "")
+	n, err := s.Create("nota", FormatTxt, []string{dev}, "v1", "lg", "")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -63,16 +68,21 @@ func TestUpdateCreatesRevisionOnlyOnContentChange(t *testing.T) {
 		t.Fatalf("história inicial: %v %v", len(h1), err)
 	}
 
-	// Só metadados: nenhuma revisão nova.
-	if _, err := s.Update(n.ID, "renomeada", FormatTxt, "pasta", "v1", "lg", ""); err != nil {
+	// Só metadados: nenhuma revisão nova (troca de categoria/título).
+	house := mustCat(t, s, "casa", "")
+	if _, err := s.Update(n.ID, "renomeada", FormatTxt, []string{dev, house}, "v1", "lg", ""); err != nil {
 		t.Fatal(err)
 	}
 	if h, _ := s.History(n.ID); len(h) != 1 {
 		t.Fatalf("conteúdo inalterado não deveria criar revisão; história: %+v", h)
 	}
+	got, _ := s.Get(n.ID)
+	if len(got.Categories) != 2 {
+		t.Errorf("múltiplas categorias não persistidas: %+v", got.Categories)
+	}
 
 	// Conteúdo novo: segunda revisão com parent correto.
-	n2, err := s.Update(n.ID, "renomeada", FormatTxt, "pasta", "v2", "lg", "ajuste final")
+	n2, err := s.Update(n.ID, "renomeada", FormatTxt, []string{dev}, "v2", "lg", "ajuste final")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -94,8 +104,8 @@ func TestUpdateCreatesRevisionOnlyOnContentChange(t *testing.T) {
 
 func TestRestoreAppendsRevisionWithOldContent(t *testing.T) {
 	s := newTestStore(t)
-	n, _ := s.Create("r", FormatMD, "", "primeiro", "", "")
-	if _, err := s.Update(n.ID, "r", FormatMD, "", "segundo", "", ""); err != nil {
+	n, _ := s.Create("r", FormatMD, nil, "primeiro", "", "")
+	if _, err := s.Update(n.ID, "r", FormatMD, nil, "segundo", "", ""); err != nil {
 		t.Fatal(err)
 	}
 	first, err := s.History(n.ID)
@@ -117,36 +127,164 @@ func TestRestoreAppendsRevisionWithOldContent(t *testing.T) {
 	if len(h) != 3 || !strings.HasPrefix(h[2].Message, "Restauração da versão") {
 		t.Fatalf("história pós-resturo: %+v", h)
 	}
-	// Restaurar a versão já atual devolve ErrUnchanged.
 	if _, err := s.Restore(n.ID, first[0].Hash, "lg"); !errors.Is(err, ErrUnchanged) {
 		t.Errorf("esperava ErrUnchanged, obtive %v", err)
 	}
-	// Hash desconhecido devolve ErrRevision.
 	if _, err := s.Restore(n.ID, strings.Repeat("f", 64), "lg"); !errors.Is(err, ErrRevision) {
 		t.Errorf("esperava ErrRevision, obtive %v", err)
 	}
 }
 
+func TestCategoryTreeOperations(t *testing.T) {
+	s := newTestStore(t)
+	devops := mustCat(t, s, "devops", "")
+	k8s := mustCat(t, s, "kubernetes", devops)
+	pessoal := mustCat(t, s, "pessoal", "")
+
+	// nomes duplicados entre irmãos são recusados (case-insensitive)
+	if _, err := s.CreateCategory("DevOps", ""); !errors.Is(err, ErrInvalid) {
+		t.Errorf("duplicata de raiz deveria falhar: %v", err)
+	}
+	// mas o mesmo nome em pais diferentes é ok
+	mustCat(t, s, "notes", k8s)
+
+	n1, _ := s.Create("deploy", FormatMD, []string{k8s}, "conteúdo", "", "")
+	n2, _ := s.Create("compras", FormatTxt, []string{pessoal}, "oi", "", "")
+	n3, _ := s.Create("shell", FormatTxt, []string{devops, pessoal}, "duas categorias", "", "")
+
+	// filtro recursivo pela raiz devops: só n1 (k8s) e n3 (devops direto)
+	rec, err := s.List(Filter{Category: devops, Recursive: true})
+	if err != nil || len(rec) != 2 {
+		t.Fatalf("filtro recursivo: %d notas %v", len(rec), err)
+	}
+	// não-recursivo: só n3
+	nonrec, _ := s.List(Filter{Category: devops})
+	if len(nonrec) != 1 || nonrec[0].ID != n3.ID {
+		t.Errorf("filtro não-recursivo: %+v", nonrec)
+	}
+	// múltiplas categorias: n3 aparece nos dois filtros
+	if r, _ := s.List(Filter{Category: pessoal}); len(r) != 2 {
+		t.Errorf("filtro pessoal (n2+n3): %+v", r)
+	}
+	// none
+	if r, _ := s.List(Filter{Category: "none"}); len(r) != 0 {
+		t.Errorf("todas têm categoria: %+v", r)
+	}
+	n4, _ := s.Create("livre", FormatTxt, nil, "x", "", "")
+	if r, _ := s.List(Filter{Category: "none"}); len(r) != 1 || r[0].ID != n4.ID {
+		t.Errorf("filtro none: %+v", r)
+	}
+
+	// mover k8s para pessoal (sem ciclo)
+	if _, err := s.UpdateCategory(k8s, "", ptr(pessoal)); err != nil {
+		t.Fatalf("move: %v", err)
+	}
+	if r, _ := s.List(Filter{Category: devops, Recursive: true}); len(r) != 1 {
+		t.Errorf("após mover k8s, devops recursivo deveria ter só n3: %+v", r)
+	}
+	// ciclo: mover devops para dentro de si mesmo
+	if _, err := s.UpdateCategory(devops, "", ptr(devops)); !errors.Is(err, ErrInvalid) {
+		t.Errorf("ciclo direto deveria falhar: %v", err)
+	}
+	// ciclo via descendente: mover pessoal para k8s (k8s é filho de pessoal)
+	if _, err := s.UpdateCategory(pessoal, "", ptr(k8s)); !errors.Is(err, ErrInvalid) {
+		t.Errorf("ciclo via descendente deveria falhar: %v", err)
+	}
+	// renomear
+	upd, err := s.UpdateCategory(devops, "infra", nil)
+	if err != nil || upd.Name != "infra" {
+		t.Fatalf("rename: %+v %v", upd, err)
+	}
+
+	// excluir categoria-pai remove subtree e limpa vínculos das notas
+	if err := s.DeleteCategory(pessoal); err != nil {
+		t.Fatalf("delete: %v", err)
+	}
+	got2, _ := s.Get(n2.ID)
+	if len(got2.Categories) != 0 {
+		t.Errorf("n2 deveria perder a categoria excluída: %+v", got2.Categories)
+	}
+	got3, _ := s.Get(n3.ID)
+	if len(got3.Categories) != 1 || got3.Categories[0] != upd.ID {
+		t.Errorf("n3 deveria manter só infra: %+v", got3.Categories)
+	}
+	cats, _ := s.Categories()
+	for _, c := range cats {
+		if c.ID == pessoal || c.ID == k8s {
+			t.Errorf("subtree não removida: %+v", cats)
+		}
+	}
+
+	// categoria inexistente em nota → ErrInvalid
+	if _, err := s.Update(n1.ID, "deploy", FormatMD, []string{"naoexiste1"}, "x", "", ""); !errors.Is(err, ErrInvalid) {
+		t.Errorf("categoria fantasma: %v", err)
+	}
+	// busca por nome de categoria: só n3 ainda é "infra" (n1 ficou órfã com a exclusão)
+	r, _ := s.List(Filter{Query: "infra"})
+	if len(r) != 1 || r[0].ID != n3.ID {
+		t.Errorf("busca por nome de categoria: %+v", ids(r))
+	}
+}
+
+func ptr(s string) *string { return &s }
+
+func TestLegacyCategoryMigration(t *testing.T) {
+	dir := t.TempDir()
+	noteDir := filepath.Join(dir, "notes", "abcd12345678")
+	if err := os.MkdirAll(noteDir, 0o750); err != nil {
+		t.Fatal(err)
+	}
+	legacy := map[string]any{
+		"id": "abcd12345678", "title": "velha", "format": "txt",
+		"category": "hardware", "tags": []string{}, "hash": strings.Repeat("0", 64),
+		"bytes": 0, "created_at": "2024-01-01T00:00:00Z", "updated_at": "2024-01-01T00:00:00Z",
+	}
+	data, _ := json.Marshal(legacy)
+	if err := os.WriteFile(filepath.Join(noteDir, "meta.json"), data, 0o640); err != nil {
+		t.Fatal(err)
+	}
+
+	s2, err := New(dir)
+	if err != nil {
+		t.Fatalf("New pós-legado: %v", err)
+	}
+	n, err := s2.Get("abcd12345678")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(n.Categories) != 1 {
+		t.Fatalf("migração não criou categoria: %+v", n)
+	}
+	cats, _ := s2.Categories()
+	if len(cats) != 1 || cats[0].Name != "hardware" || cats[0].Parent != "" || cats[0].NoteCount != 1 {
+		t.Errorf("categoria legada errada: %+v", cats)
+	}
+	if r, _ := s2.List(Filter{Category: cats[0].ID}); len(r) != 1 {
+		t.Errorf("nota não filtrável pela categoria migrada")
+	}
+}
+
 func TestListFiltersAndSorts(t *testing.T) {
 	s := newTestStore(t)
-	a, _ := s.Create("Alpha linux", FormatMD, "dev", "conteúdo #linux", "", "")
-	s.Update(a.ID, "Alpha linux", FormatMD, "dev", "conteúdo #linux editado", "", "")
-	b, _ := s.Create("Beta", FormatTxt, "casa", "compras", "", "")
-	c, _ := s.Create("Gamma docker", FormatHTML, "dev", "<p>#devops #linux</p>", "", "")
+	dev := mustCat(t, s, "dev", "")
+	a, _ := s.Create("Alpha linux", FormatMD, []string{dev}, "conteúdo #linux", "", "")
+	s.Update(a.ID, "Alpha linux", FormatMD, []string{dev}, "conteúdo #linux editado", "", "")
+	b, _ := s.Create("Beta", FormatTxt, nil, "compras", "", "")
+	c, _ := s.Create("Gamma docker", FormatHTML, []string{dev}, "<p>#devops #linux</p>", "", "")
 
 	all, err := s.List(Filter{})
 	if err != nil || len(all) != 3 {
 		t.Fatalf("list tudo: %d notas, %v", len(all), err)
 	}
-	if all[0].ID != c.ID { // mais recente primeiro (gamma criada por último)
+	if all[0].ID != c.ID { // mais recente primeiro
 		t.Errorf("ordenação por UpdatedAt errada: %v", ids(all))
 	}
-	byCat, _ := s.List(Filter{Category: "dev"})
+	byCat, _ := s.List(Filter{Category: dev})
 	if len(byCat) != 2 {
 		t.Errorf("categoria dev: %+v", ids(byCat))
 	}
 	byTag, _ := s.List(Filter{Tag: "#linux"})
-	if len(byTag) != 2 { // alpha (md) e gamma (html) contêm #linux
+	if len(byTag) != 2 { // alpha e gamma contêm #linux
 		t.Errorf("tag linux: %+v", ids(byTag))
 	}
 	byQ, _ := s.List(Filter{Query: "compras"})
@@ -157,10 +295,6 @@ func TestListFiltersAndSorts(t *testing.T) {
 	if len(tags) != 2 || tags[0].Tag != "linux" || tags[0].Count != 2 {
 		t.Errorf("agregação de tags: %+v", tags)
 	}
-	cats, _ := s.Categories()
-	if len(cats) != 2 || cats[0].Category != "casa" || cats[1].Category != "dev" {
-		t.Errorf("agregação de categorias: %+v", cats)
-	}
 }
 
 func ids(ns []*Note) []string {
@@ -173,7 +307,7 @@ func ids(ns []*Note) []string {
 
 func TestDeleteGCsOrphanBlobs(t *testing.T) {
 	s := newTestStore(t)
-	n, _ := s.Create("gc", FormatTxt, "", "conteúdo único para o blob", "", "")
+	n, _ := s.Create("gc", FormatTxt, nil, "conteúdo único para o blob", "", "")
 	blob := filepath.Join(s.dir, "blobs", n.Hash[:2], n.Hash)
 	if _, err := os.Stat(blob); err != nil {
 		t.Fatalf("blob deveria existir: %v", err)
@@ -194,8 +328,8 @@ func TestDeleteGCsOrphanBlobs(t *testing.T) {
 
 func TestSharedBlobSurvivesDeleteOfOneNote(t *testing.T) {
 	s := newTestStore(t)
-	a, _ := s.Create("a", FormatTxt, "", "mesmo", "", "")
-	b, _ := s.Create("b", FormatTxt, "", "mesmo", "", "") // mesmo hash
+	a, _ := s.Create("a", FormatTxt, nil, "mesmo", "", "")
+	b, _ := s.Create("b", FormatTxt, nil, "mesmo", "", "") // mesmo hash
 	if a.Hash != b.Hash {
 		t.Fatal("blobs deveriam ser deduplicados por conteúdo")
 	}
@@ -210,20 +344,20 @@ func TestSharedBlobSurvivesDeleteOfOneNote(t *testing.T) {
 
 func TestInvalidFormatAndOversizeContent(t *testing.T) {
 	s := newTestStore(t)
-	if _, err := s.Create("x", "rtf", "", "", "", ""); !errors.Is(err, ErrInvalid) {
+	if _, err := s.Create("x", "rtf", nil, "", "", ""); !errors.Is(err, ErrInvalid) {
 		t.Errorf("formato inválido: %v", err)
 	}
-	if _, err := s.Update("naoexiste1", "x", FormatTxt, "", "a", "", ""); !errors.Is(err, ErrNotFound) {
+	if _, err := s.Update("naoexiste1", "x", FormatTxt, nil, "a", "", ""); !errors.Is(err, ErrNotFound) {
 		t.Errorf("update em nota ausente: %v", err)
 	}
-	if _, err := s.Create("x", FormatTxt, "", strings.Repeat("a", MaxContentBytes+1), "", ""); !errors.Is(err, ErrTooLarge) {
+	if _, err := s.Create("x", FormatTxt, nil, strings.Repeat("a", MaxContentBytes+1), "", ""); !errors.Is(err, ErrTooLarge) {
 		t.Errorf("conteúdo gigante: %v", err)
 	}
 }
 
 func TestFilenameAndRevisionContent(t *testing.T) {
 	s := newTestStore(t)
-	n, _ := s.Create("minha/nota: ruim", FormatMD, "", "oi #t", "", "")
+	n, _ := s.Create("minha/nota: ruim", FormatMD, nil, "oi #t", "", "")
 	if got := n.Filename(); got != "minhanota ruim.md" {
 		t.Errorf("filename: %q", got)
 	}
diff --git a/web/css/app.css b/web/css/app.css
index 4b82b1a..58e1d61 100644
--- a/web/css/app.css
+++ b/web/css/app.css
@@ -62,7 +62,7 @@ body {
 .muted { color: var(--muted); font-size: 12px; }
 code { font-family: var(--mono); font-size: 0.92em; }
 
-#app { display: flex; flex-direction: column; height: 100vh; }
+#app { display: flex; flex-direction: column; height: 100vh; height: 100dvh; }
 
 /* ------------------------------------------------------------------ menus */
 #menubar {
@@ -209,7 +209,7 @@ body.sidebar-off #sidebar { display: none; }
   color: var(--muted);
   margin-bottom: 6px;
 }
-#sidebar input[type="search"], #sidebar select {
+#sidebar input[type="search"] {
   width: 100%;
   font: inherit;
   font-size: 13px;
@@ -270,16 +270,7 @@ body.sidebar-off #sidebar { display: none; }
   background: var(--panel-2);
   color: var(--fg);
 }
-#note-title:focus, .meta-cat:focus { outline: 2px solid var(--accent); outline-offset: -2px; }
-.meta-cat {
-  flex: 0 0 220px;
-  font-size: 13px;
-  border: 1px solid var(--border);
-  border-radius: 3px;
-  padding: 4px 8px;
-  background: var(--panel);
-  color: var(--fg);
-}
+#note-title:focus { outline: 2px solid var(--accent); outline-offset: -2px; }
 
 #editor-host { flex: 1 1 auto; display: flex; min-height: 0; position: relative; }
 
@@ -545,10 +536,212 @@ body.no-gutter #gutter { display: none; }
   box-shadow: 0 6px 18px rgba(0,0,0,.3);
 }
 
-/* responsivo simples -----------------------------------------------------*/
-@media (max-width: 940px) {
-  #sidebar { position: absolute; left: 0; top: 68px; bottom: 26px; z-index: 30; box-shadow: 4px 0 14px rgba(0,0,0,.12); }
-  #versions-panel { position: absolute; right: 0; top: 68px; bottom: 26px; z-index: 30; box-shadow: -4px 0 14px rgba(0,0,0,.12); }
+/* ------------------------------------------------------------- abas */
+#tabbar {
+  display: flex;
+  align-items: stretch;
+  background: var(--panel-2);
+  border-bottom: 1px solid var(--border);
+  flex: none;
+  min-height: 32px;
+}
+#tabs { display: flex; overflow-x: auto; scrollbar-width: none; flex: 1 1 auto; }
+#tabs::-webkit-scrollbar { display: none; }
+.tab {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  border: 0;
+  border-right: 1px solid var(--border-soft);
+  background: var(--panel-2);
+  font: inherit;
+  font-size: 12.5px;
+  color: var(--muted);
+  padding: 6px 8px 6px 12px;
+  cursor: pointer;
+  white-space: nowrap;
+  max-width: 240px;
+}
+.tab.active {
+  background: var(--panel);
+  color: var(--fg);
+  font-weight: 600;
+  box-shadow: inset 0 2px 0 var(--accent);
+}
+.tab.dirty .tab-label::after { content: ' ●'; color: var(--warn); }
+.tab-label { overflow: hidden; text-overflow: ellipsis; }
+.tab-close {
+  flex: none;
+  width: 16px;
+  height: 16px;
+  line-height: 15px;
+  text-align: center;
+  border-radius: 3px;
+  font-size: 10px;
+}
+.tab-close:hover { background: var(--danger); color: #fff; }
+.tab-new { margin: 3px 4px; }
+
+/* ------------------------------------------------- árvore de categorias */
+#cat-tree { max-height: 240px; overflow-y: auto; }
+.tree-row {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  padding: 4px 8px;
+  border-radius: 3px;
+  cursor: pointer;
+  font-size: 13px;
+  color: var(--fg);
+}
+.tree-row:hover { background: #e9e6e2; }
+.tree-row.active { background: #cfe2fa; box-shadow: inset 3px 0 0 var(--accent); }
+.tree-caret {
+  border: 0;
+  background: none;
+  width: 14px;
+  padding: 0;
+  color: var(--muted);
+  cursor: pointer;
+  font-size: 10px;
+}
+.tree-icon { flex: none; }
+.tree-name { flex: 1 1 auto; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.tree-count {
+  font-size: 10px;
+  color: var(--muted);
+  background: var(--panel);
+  border: 1px solid var(--border-soft);
+  border-radius: 8px;
+  padding: 0 5px;
+}
+.tree-menu {
+  border: 0;
+  background: none;
+  color: var(--muted);
+  cursor: pointer;
+  padding: 0 4px;
+  border-radius: 3px;
+  visibility: hidden;
+}
+.tree-row:hover .tree-menu, .tree-row.active .tree-menu { visibility: visible; }
+.tree-menu:hover { background: #dcd7d2; color: var(--fg); }
+
+/* ------------------------------------------------- popover de categorias */
+#note-meta { position: relative; }
+#btn-cats {
+  flex: none;
+  max-width: 240px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.cat-picker {
+  position: absolute;
+  top: 100%;
+  right: 8px;
+  z-index: 45;
+  width: min(300px, 90vw);
+  max-height: 300px;
+  overflow-y: auto;
+  background: var(--panel);
+  border: 1px solid var(--border);
+  border-radius: 0 0 5px 5px;
+  box-shadow: 0 10px 26px rgba(0, 0, 0, .25);
+  padding: 6px;
+}
+.picker-row {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  padding: 5px 6px;
+  border-radius: 3px;
+  font-size: 13px;
+  cursor: pointer;
+}
+.picker-row:hover { background: var(--panel-2); }
+.picker-empty { padding: 8px; font-size: 12px; }
+
+/* ------------------------------------------------- menu de contexto */
+.ctx-menu {
+  position: fixed;
+  z-index: 70;
+  min-width: 180px;
+  margin: 0;
+  padding: 4px 0;
+  list-style: none;
+  background: var(--panel);
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  box-shadow: 0 8px 22px rgba(0, 0, 0, .25);
+}
+.ctx-menu li { padding: 7px 14px; font-size: 13px; cursor: pointer; }
+.ctx-menu li:hover { background: var(--accent); color: #fff; }
+.ctx-danger { color: var(--danger); }
+.ctx-danger:hover { color: #fff; }
+
+/* ------------------------------------------------- backdrop */
+#backdrop { position: fixed; inset: 0; z-index: 55; background: rgba(0, 0, 0, .4); }
+
+.btn, .menu-btn, .tab, .tag-chip, .tree-row, .seg { touch-action: manipulation; }
+
+/* ------------------------------------------------- responsivo (celular) */
+@media (max-width: 760px) {
+  #menubar { padding: 0 2px; overflow-x: auto; scrollbar-width: none; }
+  #menubar::-webkit-scrollbar { display: none; }
+  .menu-btn { padding: 0 9px; }
+  .menu-dropdown li { padding: 9px 14px; }
+
+  #toolbar { overflow-x: auto; scrollbar-width: none; padding: 0 6px; }
+  #toolbar::-webkit-scrollbar { display: none; }
+  .tb-label, .tb-caption { display: none; }
+  .btn-icon { padding: 6px 9px; min-height: 32px; }
+  .segmented .seg { padding: 7px 12px; }
+
+  /* sidebar vira gaveta */
+  #sidebar {
+    position: fixed;
+    top: 0;
+    left: 0;
+    bottom: 0;
+    width: min(320px, 86vw);
+    z-index: 60;
+    transform: translateX(-105%);
+    transition: transform .18s ease;
+    box-shadow: 6px 0 20px rgba(0, 0, 0, .25);
+    padding-top: env(safe-area-inset-top);
+  }
+  body.sidebar-off #sidebar { display: flex; } /* F9 é atalho de desktop */
+  body.sidebar-open #sidebar { transform: none; }
+
+  /* painel de versões ocupa a tela toda */
+  #versions-panel {
+    position: fixed;
+    inset: 0;
+    width: auto;
+    z-index: 60;
+    box-shadow: none;
+    padding-top: env(safe-area-inset-top);
+  }
+
+  #statusbar {
+    height: 32px;
+    padding-bottom: env(safe-area-inset-bottom);
+    font-size: 11.5px;
+  }
+  #st-stats, #st-format { display: none; }
+  .st-item { padding: 0 8px; }
+
+  #note-meta { flex-wrap: wrap; }
+  #note-title { flex: 1 1 100%; }
+
+  .tab { padding: 9px 10px; }
+
+  /* 16px evita zoom automático do iOS ao focar o textarea */
+  #editor, #hl, .ln { font-size: max(var(--editor-size), 16px); }
+}
+@media (min-width: 761px) {
+  body.sidebar-open #sidebar { display: flex; } /* classe mobile não vaza no desktop */
 }
 
 /* ---------------------------------------------------- temas / esquemas */
@@ -702,3 +895,10 @@ html[data-theme="solar-escuro"] #revisions-list li:hover { background: #0c4450;
   color: var(--fg);
 }
 .dialog .num { width: 74px; flex: none; }
+
+/* diálogos no celular (depois das regras base de .dialog) */
+@media (max-width: 760px) {
+  .dialog .row { font-size: 15px; }
+  .dialog input { font-size: 16px; }
+  .tree-menu { visibility: visible; } /* toque não tem hover */
+}
diff --git a/web/index.html b/web/index.html
index 7a98f47..640a986 100644
--- a/web/index.html
+++ b/web/index.html
@@ -2,7 +2,7 @@
 <html lang="pt-BR">
 <head>
 <meta charset="utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
 <meta name="color-scheme" content="light">
 <title>Notas — editor estilo Mousepad</title>
 <link rel="icon" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'><rect width='16' height='16' rx='2' fill='%233584e4'/><path d='M3 4h10M3 7h10M3 10h7' stroke='white' stroke-width='1.5' stroke-linecap='round'/></svg>">
@@ -78,6 +78,13 @@
   </div>
 </div>
 
+<!-- Menu de contexto das categorias (Nova subpasta / Renomear / Excluir) -->
+<ul id="ctx-menu" class="ctx-menu hidden">
+  <li data-ctx="sub">Nova subpasta…</li>
+  <li data-ctx="rename">Renomear…</li>
+  <li data-ctx="delete" class="ctx-danger">Excluir…</li>
+</ul>
+
 <div id="app">
 
   <!-- Barra de menus (estilo Mousepad) -->
@@ -93,6 +100,7 @@
         <li data-action="save">Salvar<span class="accel">Ctrl+S</span></li>
         <li data-action="export">Baixar arquivo (.txt/.md/.html)…</li>
         <li class="menu-sep"></li>
+        <li data-action="close-tab">Fechar aba<span class="accel">Alt+W</span></li>
         <li data-action="delete-note">Excluir esta nota…</li>
       </ul>
     </div>
@@ -177,11 +185,11 @@
         <input id="search-input" type="search" placeholder="Buscar notas…" autocomplete="off">
       </div>
       <div class="side-section">
-        <label class="side-label" for="category-select">Categoria</label>
-        <select id="category-select">
-          <option value="*">Todas as categorias</option>
-          <option value="">Sem categoria</option>
-        </select>
+        <div class="side-listhead">
+          <span class="side-label">Categorias</span>
+          <button type="button" class="btn btn-small" id="btn-new-cat" title="Nova categoria raiz">+ pasta</button>
+        </div>
+        <div id="cat-tree"></div>
       </div>
       <div class="side-section">
         <span class="side-label">Tags</span>
@@ -197,9 +205,15 @@
     </aside>
 
     <section id="editor-pane">
+      <!-- Abas de arquivos abertos -->
+      <div id="tabbar" role="tablist">
+        <div id="tabs"></div>
+        <button type="button" class="btn btn-icon tab-new" id="btn-tab-new" title="Nova aba (Ctrl+N)">✚</button>
+      </div>
       <div id="note-meta">
         <input id="note-title" type="text" placeholder="Título da nota" maxlength="200" autocomplete="off">
-        <input id="note-category" type="text" placeholder="categoria (opcional)" maxlength="100" autocomplete="off" class="meta-cat">
+        <button type="button" class="btn" id="btn-cats" title="Atribuir categorias">🗀 Sem categoria</button>
+        <div id="cat-picker" class="cat-picker hidden"></div>
       </div>
       <div id="editor-host">
         <div id="editor-wrap">
@@ -249,6 +263,8 @@
   <div id="toast" class="hidden"></div>
 </div>
 
+<div id="backdrop" class="hidden"></div>
+
 <script src="/js/app.js"></script>
 </body>
 </html>
diff --git a/web/js/app.js b/web/js/app.js
index cf0e5cf..06df633 100644
--- a/web/js/app.js
+++ b/web/js/app.js
@@ -12,9 +12,11 @@
     modeToggle: $('#mode-toggle'),
     btnNew: $('#btn-new'), btnSave: $('#btn-save'), btnExport: $('#btn-export'),
     btnVersions: $('#btn-versions'), btnSidebar: $('#btn-sidebar'), btnCloseVersions: $('#btn-close-versions'),
-    searchInput: $('#search-input'), categorySelect: $('#category-select'), tagCloud: $('#tag-cloud'),
+    searchInput: $('#search-input'), tagCloud: $('#tag-cloud'),
+    catTree: $('#cat-tree'), btnNewCat: $('#btn-new-cat'),
     notesList: $('#notes-list'), notesCount: $('#notes-count'),
-    noteTitle: $('#note-title'), noteCategory: $('#note-category'),
+    tabs: $('#tabs'), btnTabNew: $('#btn-tab-new'),
+    noteTitle: $('#note-title'), btnCats: $('#btn-cats'), catPicker: $('#cat-picker'),
     editor: $('#editor'), editorWrap: $('#editor-wrap'), gutter: $('#gutter'),
     gutterInner: $('#gutter-inner'), hl: $('#hl'), colMarker: $('#col-marker'),
     preview: $('#preview'), previewFrame: $('#preview-frame'),
@@ -23,21 +25,44 @@
     btnRestore: $('#btn-restore'), revMessage: $('#rev-message'), authorInput: $('#author-input'),
     stFile: $('#st-file'), stFormat: $('#st-format'), stPos: $('#st-pos'),
     stStats: $('#st-stats'), stSaved: $('#st-saved'),
-    toast: $('#toast'),
+    toast: $('#toast'), backdrop: $('#backdrop'), ctxMenu: $('#ctx-menu'),
   };
 
   const EXT = { txt: '.txt', md: '.md', html: '.html' };
+  const TABS_KEY = 'notas_tabs';
+  const EXPAND_KEY = 'notas_expanded';
+  const DRAFT_MAX = 200 * 1024;
 
   const state = {
-    note: null,       // metadados da nota aberta (null = rascunho não salvo)
-    content: '',
-    dirty: false,
-    mode: 'edit',     // 'edit' | 'preview'
-    filter: { category: '*', tag: '', q: '' },
+    tabs: [],        // abas abertas (nota ou rascunho)
+    activeKey: null,
+    filter: { cat: '', tag: '', q: '' }, // cat: '' | 'none' | id
     notes: [],
+    cats: [],        // lista plana de CategoryView {id,name,parent,note_count,has_child}
+    expanded: new Set(JSON.parse(localStorage.getItem(EXPAND_KEY) || '[]')),
     selectedRev: null,
-    lastSaved: null,
+    ctxCat: null,
   };
+  let tabSeq = 0;
+
+  const activeTab = () => state.tabs.find((t) => t.key === state.activeKey) || null;
+
+  function newTab(init) {
+    return Object.assign({
+      key: 't' + (++tabSeq),
+      id: null, note: null,
+      title: '', format: 'md', categories: [], tags: [],
+      content: '', dirty: false, hash: '', lastSaved: null,
+    }, init);
+  }
+
+  function tabFromNote(data) {
+    return newTab({
+      id: data.id, note: data, title: data.title, format: data.format,
+      categories: data.categories || [], tags: data.tags || [],
+      content: data.content, hash: data.hash, lastSaved: data.updated_at,
+    });
+  }
 
   /* ------------------------------------------------------------ util */
 
@@ -81,6 +106,9 @@
     return s.replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]));
   }
 
+  const isMobile = () => window.matchMedia('(max-width: 760px)').matches;
+  const catName = (id) => { const c = state.cats.find((x) => x.id === id); return c ? c.name : '?'; };
+
   const currentFormat = () => E.formatSelect.value;
   const currentTitle = () => {
     const t = E.noteTitle.value.trim();
@@ -89,13 +117,14 @@
     return first || 'Sem título';
   };
 
-  function confirmDiscard() {
-    if (!state.dirty) return Promise.resolve(true);
-    return modal({
-      title: 'Descartar alterações?',
-      bodyHTML: 'As alterações não salvas desta nota serão perdidas.',
-      withCancel: true, okLabel: 'Descartar',
-    });
+  function confirmModal(title, bodyHTML, okLabel) {
+    return modal({ title, bodyHTML, withCancel: true, okLabel });
+  }
+
+  function confirmDiscardTab(tab) {
+    if (!tab || !tab.dirty) return Promise.resolve(true);
+    return confirmModal('Descartar alterações?',
+      `As alterações não salvas de <b>${esc(tab.title || 'Sem título')}</b> serão perdidas.`, 'Descartar');
   }
 
   function modal({ title, bodyHTML, okLabel = 'OK', withCancel = false }) {
@@ -148,12 +177,144 @@
     }
   });
 
+  /* -------------------------------------------------------------- abas */
+
+  function addTab(tab, activate = true) {
+    state.tabs.push(tab);
+    if (activate) activateTab(tab.key);
+    else renderTabs();
+  }
+
+  function activateTab(key) {
+    const tab = state.tabs.find((t) => t.key === key);
+    if (!tab) return;
+    state.activeKey = key;
+    state.selectedRev = null;
+    fillEditor();
+    renderTabs();
+    renderNotesList();
+    persistTabs();
+    if (!E.versionsPanel.classList.contains('hidden')) loadRevisions().catch(() => {});
+  }
+
+  async function openNoteTab(id) {
+    const existing = state.tabs.find((t) => t.id === id);
+    if (existing) { activateTab(existing.key); closeDrawer(); return; }
+    let data;
+    try {
+      data = await api('GET', '/api/notes/' + id);
+    } catch (err) {
+      toast('Abrir nota: ' + err.message);
+      return;
+    }
+    addTab(tabFromNote(data));
+    closeDrawer();
+  }
+
+  async function newDraftTab() {
+    addTab(newTab());
+    E.editor.focus();
+    closeDrawer();
+  }
+
+  async function closeTab(key) {
+    const idx = state.tabs.findIndex((t) => t.key === key);
+    if (idx < 0) return;
+    if (!(await confirmDiscardTab(state.tabs[idx]))) return;
+    state.tabs.splice(idx, 1);
+    if (!state.tabs.length) { addTab(newTab()); return; }
+    if (state.activeKey === key) {
+      const next = state.tabs[Math.min(idx, state.tabs.length - 1)];
+      activateTab(next.key);
+    } else {
+      renderTabs();
+    }
+    persistTabs();
+  }
+
+  function cycleTab(dir) {
+    if (state.tabs.length < 2) return;
+    const i = state.tabs.findIndex((t) => t.key === state.activeKey);
+    const next = state.tabs[(i + dir + state.tabs.length) % state.tabs.length];
+    activateTab(next.key);
+  }
+
+  function renderTabs() {
+    E.tabs.textContent = '';
+    for (const t of state.tabs) {
+      const el = document.createElement('button');
+      el.type = 'button';
+      el.className = 'tab' + (t.key === state.activeKey ? ' active' : '') + (t.dirty ? ' dirty' : '');
+      el.dataset.key = t.key;
+      el.title = (t.title || 'Sem título') + EXT[t.format] + (t.dirty ? ' — não salvo' : '');
+      const label = document.createElement('span');
+      label.className = 'tab-label';
+      label.textContent = (t.title || 'Sem título') + EXT[t.format];
+      const close = document.createElement('span');
+      close.className = 'tab-close';
+      close.textContent = '✕';
+      el.appendChild(label);
+      el.appendChild(close);
+      el.addEventListener('click', (e) => {
+        if (e.target === close) { e.stopPropagation(); closeTab(t.key); }
+        else activateTab(t.key);
+      });
+      el.addEventListener('auxclick', (e) => { if (e.button === 1) closeTab(t.key); });
+      E.tabs.appendChild(el);
+    }
+  }
+
+  let persistTimer = 0;
+  function persistTabs() {
+    clearTimeout(persistTimer);
+    persistTimer = setTimeout(() => {
+      try {
+        const open = state.tabs.map((t) => {
+          if (t.id) return { id: t.id };
+          const content = t.content.length > DRAFT_MAX ? t.content.slice(0, DRAFT_MAX) : t.content;
+          return { draft: { title: t.title, format: t.format, categories: t.categories, content } };
+        });
+        const active = state.tabs.findIndex((t) => t.key === state.activeKey);
+        localStorage.setItem(TABS_KEY, JSON.stringify({ open, active }));
+      } catch { /* quota cheia: ignora */ }
+    }, 400);
+  }
+
+  async function restoreTabs() {
+    let saved = null;
+    try { saved = JSON.parse(localStorage.getItem(TABS_KEY) || 'null'); } catch { /* ignore */ }
+    const opened = [];
+    if (saved && Array.isArray(saved.open)) {
+      for (const item of saved.open) {
+        if (item.id) {
+          try { opened.push(tabFromNote(await api('GET', '/api/notes/' + item.id))); } catch { /* nota excluída */ }
+        } else if (item.draft) {
+          const d = item.draft;
+          opened.push(newTab({
+            title: d.title || '', format: d.format || 'md',
+            categories: Array.isArray(d.categories) ? d.categories : [],
+            content: d.content || '', dirty: !!(d.content || d.title),
+          }));
+        }
+      }
+    }
+    if (!opened.length) {
+      if (state.notes.length) {
+        try { opened.push(tabFromNote(await api('GET', '/api/notes/' + state.notes[0].id))); } catch { /* ignore */ }
+      }
+      if (!opened.length) opened.push(newTab());
+    }
+    state.tabs = opened;
+    const want = saved && Number.isInteger(saved.active) ? Math.min(saved.active, opened.length - 1) : 0;
+    activateTab(opened[want].key);
+  }
+
   /* ------------------------------------------------------------ dados */
 
   async function loadNotes() {
     const f = state.filter;
     const q = new URLSearchParams();
-    if (f.category !== '*') q.set('category', f.category);
+    if (f.cat) q.set('category', f.cat);
     if (f.tag) q.set('tag', f.tag);
     if (f.q) q.set('q', f.q);
     const suffix = q.toString() ? '?' + q.toString() : '';
@@ -163,49 +324,45 @@
 
   async function loadAggregates() {
     const [tags, cats] = await Promise.all([api('GET', '/api/tags'), api('GET', '/api/categories')]);
-    // tag cloud
+    state.cats = cats;
+    renderTagCloud(tags);
+    renderCatTree();
+    renderCatPicker();
+    updateCatButton();
+  }
+
+  function renderTagCloud(tags) {
     if (!tags.length) {
       E.tagCloud.innerHTML = '<span class="muted">nenhuma tag ainda</span>';
-    } else {
-      E.tagCloud.textContent = '';
-      for (const t of tags) {
-        const b = document.createElement('button');
-        b.type = 'button';
-        b.className = 'tag-chip' + (state.filter.tag === t.tag ? ' active' : '');
-        b.dataset.tag = t.tag;
-        b.textContent = '#' + t.tag;
-        const n = document.createElement('span');
-        n.className = 'tag-n';
-        n.textContent = String(t.count);
-        b.appendChild(n);
-        b.addEventListener('click', () => {
-          state.filter.tag = state.filter.tag === t.tag ? '' : t.tag;
-          loadAggregates().catch(() => {});
-          loadNotes().catch(() => {});
-        });
-        E.tagCloud.appendChild(b);
-      }
+      return;
+    }
+    E.tagCloud.textContent = '';
+    for (const t of tags) {
+      const b = document.createElement('button');
+      b.type = 'button';
+      b.className = 'tag-chip' + (state.filter.tag === t.tag ? ' active' : '');
+      b.dataset.tag = t.tag;
+      b.textContent = '#' + t.tag;
+      const n = document.createElement('span');
+      n.className = 'tag-n';
+      n.textContent = String(t.count);
+      b.appendChild(n);
+      b.addEventListener('click', () => {
+        state.filter.tag = state.filter.tag === t.tag ? '' : t.tag;
+        loadAggregates().catch(() => {});
+        loadNotes().catch(() => {});
+      });
+      E.tagCloud.appendChild(b);
     }
-    // categorias no seletor
-    const want = state.filter.category;
-    E.categorySelect.textContent = '';
-    const mk = (value, label) => {
-      const o = document.createElement('option');
-      o.value = value; o.textContent = label;
-      E.categorySelect.appendChild(o);
-    };
-    mk('*', 'Todas as categorias');
-    mk('', 'Sem categoria');
-    for (const c of cats) if (c.category) mk(c.category, c.category + ' (' + c.count + ')');
-    E.categorySelect.value = [...E.categorySelect.options].some((o) => o.value === want) ? want : '*';
   }
 
   function renderNotesList() {
     E.notesList.textContent = '';
     E.notesCount.textContent = String(state.notes.length);
+    const openId = activeTab() && activeTab().id;
     for (const n of state.notes) {
       const li = document.createElement('li');
-      li.className = n.id === (state.note && state.note.id) ? 'active' : '';
+      li.className = n.id === openId ? 'active' : '';
       const title = document.createElement('div');
       title.className = 'n-title';
       title.textContent = n.title || 'Sem título';
@@ -216,12 +373,12 @@
       const sub = document.createElement('div');
       sub.className = 'n-sub';
       const bits = [relTime(n.updated_at)];
-      if (n.category) bits.push(n.category);
+      if (n.categories && n.categories.length) bits.push(n.categories.map(catName).join(' · '));
       if (n.tags && n.tags.length) bits.push(n.tags.map((t) => '#' + t).join(' '));
       sub.textContent = bits.join(' · ');
       li.appendChild(title);
       li.appendChild(sub);
-      li.addEventListener('click', () => openNote(n.id));
+      li.addEventListener('click', () => openNoteTab(n.id));
       E.notesList.appendChild(li);
     }
     if (!state.notes.length) {
@@ -232,98 +389,431 @@
     }
   }
 
-  async function openNote(id) {
-    if (!(await confirmDiscard())) return;
-    const data = await api('GET', '/api/notes/' + id);
-    state.note = data;
-    state.content = data.content;
-    state.dirty = false;
-    state.lastSaved = data.updated_at;
-    fillEditor();
-    if (!E.versionsPanel.classList.contains('hidden')) loadRevisions().catch(() => {});
-    renderNotesList();
-    updateStatus();
+  /* ------------------------------------------------- árvore de categorias */
+
+  function childrenOf(parent) {
+    return state.cats
+      .filter((c) => c.parent === parent)
+      .sort((a, b) => a.name.localeCompare(b.name, 'pt-BR'));
   }
 
+  function treeRow(cat, depth) {
+    const row = document.createElement('div');
+    row.className = 'tree-row' + (state.filter.cat === cat.id ? ' active' : '');
+    row.style.paddingLeft = (8 + depth * 16) + 'px';
+
+    const caret = document.createElement('button');
+    caret.type = 'button';
+    caret.className = 'tree-caret';
+    if (cat.has_child) {
+      caret.textContent = state.expanded.has(cat.id) ? '▾' : '▸';
+      caret.addEventListener('click', (e) => {
+        e.stopPropagation();
+        if (state.expanded.has(cat.id)) state.expanded.delete(cat.id);
+        else state.expanded.add(cat.id);
+        localStorage.setItem(EXPAND_KEY, JSON.stringify([...state.expanded]));
+        renderCatTree();
+      });
+    } else caret.textContent = '·';
+    row.appendChild(caret);
+
+    const icon = document.createElement('span');
+    icon.className = 'tree-icon';
+    icon.textContent = cat.has_child && state.expanded.has(cat.id) ? '📂' : '📁';
+    row.appendChild(icon);
+
+    const name = document.createElement('span');
+    name.className = 'tree-name';
+    name.textContent = cat.name;
+    row.appendChild(name);
+
+    const count = document.createElement('span');
+    count.className = 'tree-count';
+    count.textContent = String(cat.note_count);
+    row.appendChild(count);
+
+    const menu = document.createElement('button');
+    menu.type = 'button';
+    menu.className = 'tree-menu';
+    menu.textContent = '⋯';
+    menu.title = 'Ações da categoria';
+    menu.addEventListener('click', (e) => {
+      e.stopPropagation();
+      openCatMenu(cat.id, menu.getBoundingClientRect());
+    });
+    row.appendChild(menu);
+
+    row.addEventListener('click', () => {
+      state.filter.cat = state.filter.cat === cat.id ? '' : cat.id;
+      if (cat.has_child) {
+        state.expanded.add(cat.id);
+        localStorage.setItem(EXPAND_KEY, JSON.stringify([...state.expanded]));
+      }
+      renderCatTree();
+      loadNotes().catch(() => {});
+    });
+    return row;
+  }
+
+  function renderCatTree() {
+    E.catTree.textContent = '';
+    const special = (value, label, icon) => {
+      const row = document.createElement('div');
+      row.className = 'tree-row tree-special' + (state.filter.cat === value ? ' active' : '');
+      row.style.paddingLeft = '8px';
+      const ic = document.createElement('span');
+      ic.className = 'tree-icon';
+      ic.textContent = icon;
+      const nm = document.createElement('span');
+      nm.className = 'tree-name';
+      nm.textContent = label;
+      row.appendChild(ic);
+      row.appendChild(nm);
+      row.addEventListener('click', () => {
+        state.filter.cat = value;
+        renderCatTree();
+        loadNotes().catch(() => {});
+      });
+      E.catTree.appendChild(row);
+    };
+    special('', 'Todas as notas', '🗂');
+    special('none', 'Sem categoria', '🗄');
+    const walk = (parent, depth) => {
+      for (const c of childrenOf(parent)) {
+        E.catTree.appendChild(treeRow(c, depth));
+        if (c.has_child && state.expanded.has(c.id)) walk(c.id, depth + 1);
+      }
+    };
+    walk('', 0);
+    if (!state.cats.length) {
+      const hint = document.createElement('span');
+      hint.className = 'muted';
+      hint.textContent = 'nenhuma categoria — use “+ pasta”';
+      E.catTree.appendChild(hint);
+    }
+  }
+
+  E.btnNewCat.addEventListener('click', async () => {
+    const name = window.prompt('Nome da nova categoria raiz:');
+    if (!name || !name.trim()) return;
+    try {
+      await api('POST', '/api/categories', { name: name.trim(), parent: '' });
+      await Promise.all([loadAggregates(), loadNotes()]);
+      toast('Categoria criada.');
+    } catch (err) {
+      toast('Criar categoria: ' + err.message);
+    }
+  });
+
+  /* --------------------------------------------- menu de contexto pasta */
+
+  function openCatMenu(id, rect) {
+    state.ctxCat = id;
+    E.ctxMenu.classList.remove('hidden');
+    const mw = E.ctxMenu.offsetWidth || 180;
+    const mh = E.ctxMenu.offsetHeight || 100;
+    let x = rect.left;
+    let y = rect.bottom + 2;
+    if (x + mw > window.innerWidth) x = window.innerWidth - mw - 6;
+    if (y + mh > window.innerHeight) y = rect.top - mh - 2;
+    E.ctxMenu.style.left = x + 'px';
+    E.ctxMenu.style.top = y + 'px';
+  }
+  function closeCatMenu() {
+    E.ctxMenu.classList.add('hidden');
+    state.ctxCat = null;
+  }
+
+  E.ctxMenu.querySelectorAll('[data-ctx]').forEach((li) =>
+    li.addEventListener('click', async () => {
+      const id = state.ctxCat;
+      closeCatMenu();
+      if (!id) return;
+      const cat = state.cats.find((c) => c.id === id);
+      if (!cat) return;
+      try {
+        if (li.dataset.ctx === 'sub') {
+          const name = window.prompt(`Nova subpasta dentro de “${cat.name}”:`);
+          if (!name || !name.trim()) return;
+          await api('POST', '/api/categories', { name: name.trim(), parent: id });
+          state.expanded.add(id);
+          localStorage.setItem(EXPAND_KEY, JSON.stringify([...state.expanded]));
+        } else if (li.dataset.ctx === 'rename') {
+          const name = window.prompt('Renomear categoria:', cat.name);
+          if (!name || !name.trim() || name.trim() === cat.name) return;
+          await api('PUT', '/api/categories/' + id, { name: name.trim() });
+        } else if (li.dataset.ctx === 'delete') {
+          const ok = await confirmModal('Excluir categoria?',
+            `<b>${esc(cat.name)}</b> e suas subpastas serão removidas. As notas continuam existindo, apenas sem essas categorias.`, 'Excluir');
+          if (!ok) return;
+          await api('DELETE', '/api/categories/' + id);
+          if (state.filter.cat === id) state.filter.cat = '';
+        }
+        await Promise.all([loadAggregates(), loadNotes()]);
+        // categorias excluídas não podem permanecer nas abas abertas
+        const valid = new Set(state.cats.map((c) => c.id));
+        for (const t of state.tabs) {
+          const kept = t.categories.filter((x) => valid.has(x));
+          if (kept.length !== t.categories.length) t.categories = kept;
+        }
+        updateCatButton();
+      } catch (err) {
+        toast('Categoria: ' + err.message);
+      }
+    }));
+
+  document.addEventListener('click', (e) => {
+    if (!E.ctxMenu.classList.contains('hidden') && !E.ctxMenu.contains(e.target)) closeCatMenu();
+  });
+
+  /* ------------------------------------------------ seletor de categorias */
+
+  function updateCatButton() {
+    const t = activeTab();
+    const n = t ? t.categories.length : 0;
+    E.btnCats.textContent = n === 0 ? '🗀 Sem categoria'
+      : n === 1 ? '🗀 ' + catName(t.categories[0])
+      : `🗀 ${catName(t.categories[0])} +${n - 1}`;
+  }
+
+  function renderCatPicker() {
+    if (E.catPicker.classList.contains('hidden')) return;
+    E.catPicker.textContent = '';
+    if (!state.cats.length) {
+      const s = document.createElement('div');
+      s.className = 'picker-empty muted';
+      s.textContent = 'Nenhuma categoria. Crie pela barra lateral.';
+      E.catPicker.appendChild(s);
+      return;
+    }
+    const t = activeTab();
+    const walk = (parent, depth) => {
+      for (const c of childrenOf(parent)) {
+        const label = document.createElement('label');
+        label.className = 'picker-row';
+        label.style.paddingLeft = (8 + depth * 16) + 'px';
+        const cb = document.createElement('input');
+        cb.type = 'checkbox';
+        cb.checked = !!t && t.categories.includes(c.id);
+        cb.addEventListener('change', () => {
+          const tab = activeTab();
+          if (!tab) return;
+          if (cb.checked) {
+            if (!tab.categories.includes(c.id)) tab.categories.push(c.id);
+          } else {
+            tab.categories = tab.categories.filter((x) => x !== c.id);
+          }
+          tab.dirty = true;
+          updateCatButton();
+          markTabDirty();
+        });
+        const ic = document.createElement('span');
+        ic.textContent = '📁';
+        const nm = document.createElement('span');
+        nm.textContent = c.name;
+        label.appendChild(cb);
+        label.appendChild(ic);
+        label.appendChild(nm);
+        E.catPicker.appendChild(label);
+        if (c.has_child) walk(c.id, depth + 1);
+      }
+    };
+    walk('', 0);
+  }
+
+  E.btnCats.addEventListener('click', (e) => {
+    e.stopPropagation();
+    const open = E.catPicker.classList.toggle('hidden');
+    if (!open) renderCatPicker();
+  });
+  document.addEventListener('click', (e) => {
+    if (!E.catPicker.classList.contains('hidden') && !E.catPicker.contains(e.target) && e.target !== E.btnCats) {
+      E.catPicker.classList.add('hidden');
+    }
+  });
+
+  /* ------------------------------------------------------- editor <-> abas */
+
   function fillEditor() {
-    const n = state.note;
-    E.noteTitle.value = n ? (n.title || '') : '';
-    E.noteCategory.value = n ? (n.category || '') : '';
-    E.formatSelect.value = n ? n.format : 'md';
-    E.editor.value = state.content;
+    const t = activeTab();
+    E.noteTitle.value = t ? t.title : '';
+    E.formatSelect.value = t ? t.format : 'md';
+    E.editor.value = t ? t.content : '';
+    updateCatButton();
     updateToolbar();
     updateStatus();
     renderEditorVisual();
     refreshPreviewIfOpen();
   }
 
-  async function newDraft(force = false) {
-    if (!force && !(await confirmDiscard())) return;
-    state.note = null;
-    state.content = '';
-    state.dirty = false;
-    state.lastSaved = null;
-    state.selectedRev = null;
-    E.revisionsList.textContent = '';
-    E.versionDetail.classList.add('hidden');
-    fillEditor();
-    E.editor.focus();
-    renderNotesList();
-  }
-
-  async function save() {
-    const body = {
-      title: currentTitle(),
-      format: currentFormat(),
-      category: E.noteCategory.value.trim(),
-      content: E.editor.value,
-      author: E.authorInput.value.trim(),
-      message: E.revMessage.value.trim(),
-    };
-    let data;
-    try {
-      if (state.note) data = await api('PUT', '/api/notes/' + state.note.id, body);
-      else data = await api('POST', '/api/notes', body);
-    } catch (err) {
-      toast('Falha ao salvar: ' + err.message);
-      return;
-    }
-    state.note = data;
-    state.content = data.content;
-    state.dirty = false;
-    state.lastSaved = new Date().toISOString();
-    E.revMessage.value = '';
-    renderNotesList();
-    loadNotes().catch(() => {});
-    loadAggregates().catch(() => {});
-    if (!E.versionsPanel.classList.contains('hidden')) loadRevisions().catch(() => {});
+  function markTabDirty() {
+    const t = activeTab();
+    if (t && !t.dirty) t.dirty = true;
+    renderTabs();
     updateStatus();
-    toast('Salvo — revisão ' + data.hash.slice(0, 8));
   }
 
-  async function deleteNote() {
-    if (!state.note) { toast('Nenhuma nota aberta.'); return; }
-    const ok = await modal({
-      title: 'Excluir nota?',
-      bodyHTML: `A nota <b>${esc(state.note.title || 'Sem título')}</b> e todo o seu histórico serão apagados.`,
-      withCancel: true, okLabel: 'Excluir',
-    });
-    if (!ok) return;
-    try {
-      await api('DELETE', '/api/notes/' + state.note.id);
-      toast('Nota excluída.');
-      await newDraft(true);
-      loadNotes().catch(() => {});
-      loadAggregates().catch(() => {});
-    } catch (err) {
-      toast('Falha ao excluir: ' + err.message);
+  function markDirty() {
+    const t = activeTab();
+    if (t) t.dirty = true;
+    updateStatus();
+    persistTabs();
+  }
+
+  E.editor.addEventListener('input', () => {
+    const t = activeTab();
+    if (t) t.content = E.editor.value;
+    markDirty();
+    updateStatus();
+    scheduleRender();
+  });
+  ['keyup', 'mouseup', 'select', 'click'].forEach((ev) =>
+    E.editor.addEventListener(ev, updateStatus));
+  E.noteTitle.addEventListener('input', () => {
+    const t = activeTab();
+    if (t) t.title = E.noteTitle.value;
+    markDirty();
+    renderTabs();
+    updateStatus();
+  });
+  E.formatSelect.addEventListener('change', () => {
+    const t = activeTab();
+    if (t) t.format = currentFormat();
+    markDirty();
+    updateToolbar();
+    updateStatus();
+    renderTabs();
+    scheduleRender();
+    refreshPreviewIfOpen();
+  });
+
+  // Tab insere 4 espaços em vez de sair do textarea.
+  E.editor.addEventListener('keydown', (e) => {
+    if (e.key === 'Tab') {
+      e.preventDefault();
+      insertText('    ');
+    }
+  });
+
+  function insertText(text) {
+    const ta = E.editor;
+    ta.focus();
+    if (!document.execCommand || !document.execCommand('insertText', false, text)) {
+      const s = ta.selectionStart, en = ta.selectionEnd;
+      ta.setRangeText(text, s, en, 'end');
+    }
+    const t = activeTab();
+    if (t) t.content = ta.value;
+    markDirty();
+    updateStatus();
+  }
+
+  function selectedRange() {
+    const ta = E.editor;
+    return { s: ta.selectionStart, e: ta.selectionEnd, sel: ta.value.slice(ta.selectionStart, ta.selectionEnd) };
+  }
+
+  // Substitui a seleção (ou `range` explícito, se dado) por `text`.
+  function replaceSelection(text, selStart, selEnd, range) {
+    const ta = E.editor;
+    ta.focus();
+    if (range) ta.setSelectionRange(range.s, range.e);
+    const { s, e } = selectedRange();
+    if (document.execCommand) {
+      document.execCommand('insertText', false, text);
+    } else {
+      ta.setRangeText(text, s, e, 'preserve');
+    }
+    if (selStart !== undefined) ta.setSelectionRange(selStart, selEnd);
+    const t = activeTab();
+    if (t) t.content = ta.value;
+    markDirty();
+    updateStatus();
+  }
+
+  function wrapSel(before, after, placeholder) {
+    const { s, e, sel } = selectedRange();
+    const text = sel || placeholder || 'texto';
+    replaceSelection(before + text + after, s + before.length, s + before.length + text.length);
+  }
+
+  function expandToLines() {
+    const ta = E.editor;
+    const v = ta.value;
+    const s = v.lastIndexOf('\n', Math.max(ta.selectionStart - 1, 0)) + 1;
+    let e = v.indexOf('\n', ta.selectionEnd);
+    if (e === -1) e = v.length;
+    return { s, e, block: v.slice(s, e) };
+  }
+
+  function eachLine(prefixFn) {
+    const { s, e, block } = expandToLines();
+    const lines = block.split('\n');
+    const out = lines.map(prefixFn).join('\n');
+    replaceSelection(out, s, s + out.length, { s, e });
+  }
+
+  function applyFmt(kind) {
+    const fmt = currentFormat();
+    if (fmt === 'txt') { toast('Em texto puro não há formatação — mude o formato para Markdown ou HTML.'); return; }
+    const md = fmt === 'md';
+    switch (kind) {
+      case 'bold':   md ? wrapSel('**', '**', 'negrito') : wrapSel('<b>', '</b>', 'negrito'); break;
+      case 'italic': md ? wrapSel('*', '*', 'itálico') : wrapSel('<i>', '</i>', 'itálico'); break;
+      case 'strike': md ? wrapSel('~~', '~~', 'tachado') : wrapSel('<s>', '</s>', 'tachado'); break;
+      case 'code':   md ? wrapSel('`', '`', 'código') : wrapSel('<code>', '</code>', 'código'); break;
+      case 'block':
+        md ? wrapSel('\n```\n', '\n```\n', 'código em bloco')
+           : wrapSel('\n<pre><code>', '</code></pre>\n', 'código em bloco');
+        break;
+      case 'link': {
+        const { sel } = selectedRange();
+        const url = window.prompt('Endereço do link (URL):', 'https://');
+        if (!url) return;
+        md ? wrapSel('[', `](${url})`, sel || 'link')
+           : replaceSelection(`<a href="${url}">${sel || 'link'}</a>`);
+        break;
+      }
+      case 'quote':
+        md ? eachLine((l) => togglePrefix(l, '> '))
+           : wrapSel('<blockquote>', '</blockquote>', 'citação');
+        break;
+      case 'h1': md ? eachLine((l) => toggleHeading(l, '# '))  : eachLine((l) => wrapLine(l, '<h1>', '</h1>')); break;
+      case 'h2': md ? eachLine((l) => toggleHeading(l, '## ')) : eachLine((l) => wrapLine(l, '<h2>', '</h2>')); break;
+      case 'list-ul':
+        md ? eachLine((l) => togglePrefix(l, '- '))
+           : (() => { const { sel } = selectedRange(); const items = (sel || 'item').split('\n');
+               replaceSelection('<ul>\n' + items.map((i) => '  <li>' + i + '</li>').join('\n') + '\n</ul>'); })();
+        break;
+      case 'list-ol':
+        md ? eachLine((l, i) => `${i + 1}. ${l.replace(/^(\d+\.|- )\s*/, '')}`)
+           : (() => { const { sel } = selectedRange(); const items = (sel || 'item').split('\n');
+               replaceSelection('<ol>\n' + items.map((i) => '  <li>' + i + '</li>').join('\n') + '\n</ol>'); })();
+        break;
     }
   }
 
-  function exportNote() {
-    if (!state.note) { toast('Salve a nota antes de baixar.'); return; }
-    if (state.dirty) toast('Atenção: o arquivo baixado é a última versão salva.');
-    window.location.assign('/api/notes/' + state.note.id + '/raw');
+  function togglePrefix(line, prefix) {
+    return line.startsWith(prefix) ? line.slice(prefix.length) : prefix + line;
+  }
+  function toggleHeading(line, prefix) {
+    if (line.startsWith(prefix)) return line.slice(prefix.length);
+    return prefix + line.replace(/^#{1,6}\s*/, '');
+  }
+  function wrapLine(line, before, after) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith(before) && trimmed.endsWith(after)) {
+      return line.replace(before, '').replace(new RegExp(after + '$'), '');
+    }
+    return before + (trimmed || 'título') + after;
+  }
+
+  document.querySelectorAll('#fmt-tools .fmt').forEach((btn) => {
+    btn.addEventListener('click', () => applyFmt(btn.dataset.fmt));
+  });
+
+  function updateToolbar() {
+    E.fmtTools.classList.toggle('disabled', currentFormat() === 'txt');
   }
 
   /* ------------------------------------------------------- preferências */
@@ -553,7 +1043,7 @@
   }
 
   function updateMarker() {
-    const show = prefs.colmark && !prefs.wrap && state.mode === 'edit';
+    const show = prefs.colmark && !prefs.wrap && modeState.mode === 'edit';
     if (!show) { E.colMarker.classList.add('hidden'); return; }
     const ta = E.editor;
     const padX = parseFloat(getComputedStyle(ta).paddingLeft) || 16;
@@ -632,161 +1122,12 @@
     applyPrefs();
   });
 
-  /* ------------------------------------------------------------ editor */
-
-  function markDirty() {
-    if (!state.dirty) {
-      state.dirty = true;
-      updateStatus();
-    }
-  }
-
-  E.editor.addEventListener('input', () => {
-    state.content = E.editor.value;
-    markDirty();
-    updateStatus();
-    scheduleRender();
-  });
-  ['keyup', 'mouseup', 'select', 'click'].forEach((ev) =>
-    E.editor.addEventListener(ev, updateStatus));
-  E.noteTitle.addEventListener('input', () => { markDirty(); updateStatus(); });
-  E.noteCategory.addEventListener('input', markDirty);
-  E.formatSelect.addEventListener('change', () => {
-    markDirty(); updateToolbar(); updateStatus(); scheduleRender(); refreshPreviewIfOpen();
-  });
-
-  // Tab insere 4 espaços em vez de sair do textarea.
-  E.editor.addEventListener('keydown', (e) => {
-    if (e.key === 'Tab') {
-      e.preventDefault();
-      insertText('    ');
-    }
-  });
-
-  function insertText(text) {
-    const ta = E.editor;
-    ta.focus();
-    if (!document.execCommand || !document.execCommand('insertText', false, text)) {
-      // fallback sem integração com undo nativo
-      const s = ta.selectionStart, en = ta.selectionEnd;
-      ta.setRangeText(text, s, en, 'end');
-    }
-    state.content = ta.value;
-    markDirty();
-    updateStatus();
-  }
-
-  function selectedRange() {
-    const ta = E.editor;
-    return { s: ta.selectionStart, e: ta.selectionEnd, sel: ta.value.slice(ta.selectionStart, ta.selectionEnd) };
-  }
-
-  // Substitui a seleção (ou `range` explícito, se dado) por `text`.
-  function replaceSelection(text, selStart, selEnd, range) {
-    const ta = E.editor;
-    ta.focus();
-    if (range) ta.setSelectionRange(range.s, range.e);
-    const { s, e } = selectedRange();
-    if (document.execCommand) {
-      document.execCommand('insertText', false, text);
-    } else {
-      ta.setRangeText(text, s, e, 'preserve');
-    }
-    if (selStart !== undefined) ta.setSelectionRange(selStart, selEnd);
-    state.content = ta.value;
-    markDirty();
-    updateStatus();
-  }
-
-  function wrapSel(before, after, placeholder) {
-    const { s, e, sel } = selectedRange();
-    const text = sel || placeholder || 'texto';
-    replaceSelection(before + text + after, s + before.length, s + before.length + text.length);
-  }
-
-  function expandToLines() {
-    const ta = E.editor;
-    const v = ta.value;
-    const s = v.lastIndexOf('\n', Math.max(ta.selectionStart - 1, 0)) + 1;
-    let e = v.indexOf('\n', ta.selectionEnd);
-    if (e === -1) e = v.length;
-    return { s, e, block: v.slice(s, e) };
-  }
-
-  function eachLine(prefixFn) {
-    const { s, e, block } = expandToLines();
-    const lines = block.split('\n');
-    const out = lines.map(prefixFn).join('\n');
-    replaceSelection(out, s, s + out.length, { s, e });
-  }
-
-  function applyFmt(kind) {
-    const fmt = currentFormat();
-    if (fmt === 'txt') { toast('Em texto puro não há formatação — mude o formato para Markdown ou HTML.'); return; }
-    const md = fmt === 'md';
-    switch (kind) {
-      case 'bold':   md ? wrapSel('**', '**', 'negrito') : wrapSel('<b>', '</b>', 'negrito'); break;
-      case 'italic': md ? wrapSel('*', '*', 'itálico') : wrapSel('<i>', '</i>', 'itálico'); break;
-      case 'strike': md ? wrapSel('~~', '~~', 'tachado') : wrapSel('<s>', '</s>', 'tachado'); break;
-      case 'code':   md ? wrapSel('`', '`', 'código') : wrapSel('<code>', '</code>', 'código'); break;
-      case 'block':
-        md ? wrapSel('\n```\n', '\n```\n', 'código em bloco')
-           : wrapSel('\n<pre><code>', '</code></pre>\n', 'código em bloco');
-        break;
-      case 'link': {
-        const { sel } = selectedRange();
-        const url = window.prompt('Endereço do link (URL):', 'https://');
-        if (!url) return;
-        md ? wrapSel('[', `](${url})`, sel || 'link')
-           : replaceSelection(`<a href="${url}">${sel || 'link'}</a>`);
-        break;
-      }
-      case 'quote':
-        md ? eachLine((l) => togglePrefix(l, '> '))
-           : wrapSel('<blockquote>', '</blockquote>', 'citação');
-        break;
-      case 'h1': md ? eachLine((l) => toggleHeading(l, '# '))  : eachLine((l) => wrapLine(l, '<h1>', '</h1>')); break;
-      case 'h2': md ? eachLine((l) => toggleHeading(l, '## ')) : eachLine((l) => wrapLine(l, '<h2>', '</h2>')); break;
-      case 'list-ul':
-        md ? eachLine((l) => togglePrefix(l, '- '))
-           : (() => { const { sel } = selectedRange(); const items = (sel || 'item').split('\n');
-               replaceSelection('<ul>\n' + items.map((i) => '  <li>' + i + '</li>').join('\n') + '\n</ul>'); })();
-        break;
-      case 'list-ol':
-        md ? eachLine((l, i) => `${i + 1}. ${l.replace(/^(\d+\.|- )\s*/, '')}`)
-           : (() => { const { sel } = selectedRange(); const items = (sel || 'item').split('\n');
-               replaceSelection('<ol>\n' + items.map((i) => '  <li>' + i + '</li>').join('\n') + '\n</ol>'); })();
-        break;
-    }
-  }
-
-  function togglePrefix(line, prefix) {
-    return line.startsWith(prefix) ? line.slice(prefix.length) : prefix + line;
-  }
-  function toggleHeading(line, prefix) {
-    if (line.startsWith(prefix)) return line.slice(prefix.length);
-    return prefix + line.replace(/^#{1,6}\s*/, '');
-  }
-  function wrapLine(line, before, after) {
-    const trimmed = line.trim();
-    if (trimmed.startsWith(before) && trimmed.endsWith(after)) {
-      return line.replace(before, '').replace(new RegExp(after + '$'), '');
-    }
-    return before + (trimmed || 'título') + after;
-  }
-
-  document.querySelectorAll('#fmt-tools .fmt').forEach((btn) => {
-    btn.addEventListener('click', () => applyFmt(btn.dataset.fmt));
-  });
-
-  function updateToolbar() {
-    E.fmtTools.classList.toggle('disabled', currentFormat() === 'txt');
-  }
-
   /* ------------------------------------------------------------ modos */
 
+  const modeState = { mode: 'edit' };
+
   function setMode(mode) {
-    state.mode = mode;
+    modeState.mode = mode;
     E.modeToggle.querySelectorAll('.seg').forEach((b) =>
       b.classList.toggle('active', b.dataset.mode === mode));
     const editing = mode === 'edit';
@@ -803,9 +1144,9 @@
   }
 
   function refreshPreviewIfOpen() {
-    if (state.mode !== 'preview') return;
-    const fmt = currentFormat();
+    if (modeState.mode !== 'preview') return;
     E.editorWrap.classList.add('hidden');
+    const fmt = currentFormat();
     if (fmt === 'html') {
       E.preview.classList.add('hidden');
       E.previewFrame.classList.remove('hidden');
@@ -822,7 +1163,7 @@
     E.preview.classList.add('md');
     E.preview.textContent = '…renderizando';
     api('POST', '/api/render', { content: E.editor.value, format: 'md' })
-      .then((r) => { if (state.mode === 'preview') E.preview.innerHTML = r.html; })
+      .then((r) => { if (modeState.mode === 'preview') E.preview.innerHTML = r.html; })
       .catch((err) => { E.preview.textContent = 'erro ao renderizar: ' + err.message; });
   }
 
@@ -834,18 +1175,23 @@
   function toggleVersionsPanel(open) {
     const show = open ?? E.versionsPanel.classList.contains('hidden');
     E.versionsPanel.classList.toggle('hidden', !show);
+    if (isMobile()) {
+      if (show) setBackdrop(true);
+      else if (!document.body.classList.contains('sidebar-open')) setBackdrop(false);
+    }
     if (show) loadRevisions().catch((err) => toast('Histórico: ' + err.message));
   }
 
   let revReq = 0;
   async function loadRevisions() {
     const req = ++revReq;
-    if (!state.note) {
+    const t = activeTab();
+    if (!t || !t.id) {
       E.revisionsList.textContent = '';
       E.versionDetail.classList.add('hidden');
       return;
     }
-    const revs = await api('GET', '/api/notes/' + state.note.id + '/revisions');
+    const revs = await api('GET', '/api/notes/' + t.id + '/revisions');
     if (req !== revReq) return; // resposta obsoleta: uma carga mais nova assumiu
     E.revisionsList.textContent = '';
     for (const r of revs) {
@@ -866,7 +1212,7 @@
       msg.textContent = r.message;
       const when = document.createElement('div');
       when.className = 'rev-when';
-      when.textContent = r.when.slice(0, 16).replace('T', ' ') + ' UTC · ' + (r.bytes) + ' B';
+      when.textContent = r.when.slice(0, 16).replace('T', ' ') + ' UTC · ' + r.bytes + ' B';
       li.appendChild(top); li.appendChild(msg); li.appendChild(when);
       li.addEventListener('click', () => showRevisionDiff(r));
       E.revisionsList.appendChild(li);
@@ -874,16 +1220,18 @@
   }
 
   async function showRevisionDiff(rev) {
+    const t = activeTab();
+    if (!t) return;
     state.selectedRev = rev.hash;
     E.revisionsList.querySelectorAll('li').forEach((li) =>
       li.classList.toggle('active', li.dataset.hash === rev.hash));
     try {
-      const dv = await api('GET', `/api/notes/${state.note.id}/revisions/${rev.hash}/diff`);
+      const dv = await api('GET', `/api/notes/${t.id}/revisions/${rev.hash}/diff`);
       E.versionDetail.classList.remove('hidden');
       E.versionInfo.textContent =
         `${dv.from} → ${dv.to} · ${dv.author} · +${dv.added}/-${dv.removed}`;
       renderDiff(dv.diff || '(sem alterações)');
-      E.btnRestore.disabled = state.note && rev.hash === state.note.hash;
+      E.btnRestore.disabled = rev.hash === t.hash;
     } catch (err) {
       toast('Diff: ' + err.message);
     }
@@ -903,21 +1251,16 @@
   }
 
   E.btnRestore.addEventListener('click', async () => {
-    if (!state.note || !state.selectedRev) return;
-    const ok = await modal({
-      title: 'Restaurar versão?',
-      bodyHTML: `O conteúdo da nota será substituído pelo da revisão <code>${esc(state.selectedRev.slice(0, 8))}</code>. O estado atual continuará no histórico.`,
-      withCancel: true, okLabel: 'Restaurar',
-    });
+    const t = activeTab();
+    if (!t || !t.id || !state.selectedRev) return;
+    const ok = await confirmModal('Restaurar versão?',
+      `O conteúdo da nota será substituído pelo da revisão <code>${esc(state.selectedRev.slice(0, 8))}</code>. O estado atual continuará no histórico.`, 'Restaurar');
     if (!ok) return;
     try {
       const data = await api('POST',
-        `/api/notes/${state.note.id}/revisions/${state.selectedRev}/restore`,
+        `/api/notes/${t.id}/revisions/${state.selectedRev}/restore`,
         { author: E.authorInput.value.trim() });
-      state.note = data;
-      state.content = data.content;
-      state.dirty = false;
-      fillEditor();
+      applyNoteToTab(t, data);
       await Promise.all([loadNotes(), loadRevisions(), loadAggregates()]);
       toast('Revisão restaurada com sucesso.');
     } catch (err) {
@@ -927,6 +1270,78 @@
 
   E.btnCloseVersions.addEventListener('click', () => toggleVersionsPanel(false));
 
+  function applyNoteToTab(tab, data) {
+    tab.id = data.id;
+    tab.note = data;
+    tab.title = data.title;
+    tab.format = data.format;
+    tab.categories = data.categories || [];
+    tab.tags = data.tags || [];
+    tab.content = data.content;
+    tab.hash = data.hash;
+    tab.dirty = false;
+    tab.lastSaved = new Date().toISOString();
+    fillEditor();
+    renderTabs();
+    persistTabs();
+  }
+
+  /* ------------------------------------------------------------ salvar */
+
+  async function save() {
+    const t = activeTab();
+    if (!t) return;
+    const body = {
+      title: currentTitle(),
+      format: currentFormat(),
+      categories: t.categories,
+      content: E.editor.value,
+      author: E.authorInput.value.trim(),
+      message: E.revMessage.value.trim(),
+    };
+    let data;
+    try {
+      if (t.id) data = await api('PUT', '/api/notes/' + t.id, body);
+      else data = await api('POST', '/api/notes', body);
+    } catch (err) {
+      toast('Falha ao salvar: ' + err.message);
+      return;
+    }
+    applyNoteToTab(t, data);
+    E.revMessage.value = '';
+    loadNotes().catch(() => {});
+    loadAggregates().catch(() => {});
+    if (!E.versionsPanel.classList.contains('hidden')) loadRevisions().catch(() => {});
+    toast('Salvo — revisão ' + data.hash.slice(0, 8));
+  }
+
+  async function deleteNote() {
+    const t = activeTab();
+    if (!t || !t.id) { toast('Nenhuma nota aberta.'); return; }
+    const ok = await confirmModal('Excluir nota?',
+      `A nota <b>${esc(t.title || 'Sem título')}</b> e todo o seu histórico serão apagados.`, 'Excluir');
+    if (!ok) return;
+    try {
+      await api('DELETE', '/api/notes/' + t.id);
+      toast('Nota excluída.');
+      const idx = state.tabs.indexOf(t);
+      state.tabs.splice(idx, 1);
+      if (!state.tabs.length) addTab(newTab());
+      else activateTab(state.tabs[Math.min(idx, state.tabs.length - 1)].key);
+      loadNotes().catch(() => {});
+      loadAggregates().catch(() => {});
+    } catch (err) {
+      toast('Falha ao excluir: ' + err.message);
+    }
+  }
+
+  function exportNote() {
+    const t = activeTab();
+    if (!t || !t.id) { toast('Salve a nota antes de baixar.'); return; }
+    if (t.dirty) toast('Atenção: o arquivo baixado é a última versão salva.');
+    window.location.assign('/api/notes/' + t.id + '/raw');
+  }
+
   /* ------------------------------------------------------------ menus */
 
   document.querySelectorAll('.menu .menu-btn').forEach((btn) => {
@@ -941,15 +1356,42 @@
   document.addEventListener('click', () =>
     document.querySelectorAll('.menu.open').forEach((m) => m.classList.remove('open')));
 
+  function toggleSidebar() {
+    if (isMobile()) {
+      const open = document.body.classList.toggle('sidebar-open');
+      setBackdrop(open);
+    } else {
+      document.body.classList.toggle('sidebar-off');
+    }
+  }
+  function closeDrawer() {
+    if (isMobile()) {
+      document.body.classList.remove('sidebar-open');
+      if (!E.versionsPanel.classList.contains('hidden')) return; // backdrop continua p/ versões
+      setBackdrop(false);
+    }
+  }
+  function setBackdrop(on) {
+    E.backdrop.classList.toggle('hidden', !on);
+  }
+  E.backdrop.addEventListener('click', () => {
+    document.body.classList.remove('sidebar-open');
+    E.versionsPanel.classList.add('hidden');
+    E.catPicker.classList.add('hidden');
+    closeCatMenu();
+    setBackdrop(false);
+  });
+
   const ACTIONS = {
-    'new-note': () => newDraft(),
+    'new-note': () => newDraftTab(),
     'save': () => save(),
     'export': exportNote,
+    'close-tab': () => closeTab(state.activeKey),
     'delete-note': deleteNote,
-    'undo': () => { E.editor.focus(); document.execCommand('undo'); state.content = E.editor.value; markDirty(); updateStatus(); },
-    'redo': () => { E.editor.focus(); document.execCommand('redo'); state.content = E.editor.value; markDirty(); updateStatus(); },
+    'undo': () => { E.editor.focus(); document.execCommand('undo'); const t = activeTab(); if (t) t.content = E.editor.value; markDirty(); scheduleRender(); updateStatus(); },
+    'redo': () => { E.editor.focus(); document.execCommand('redo'); const t = activeTab(); if (t) t.content = E.editor.value; markDirty(); scheduleRender(); updateStatus(); },
     'select-all': () => { E.editor.focus(); E.editor.setSelectionRange(0, E.editor.value.length); },
-    'toggle-sidebar': () => document.body.classList.toggle('sidebar-off'),
+    'toggle-sidebar': toggleSidebar,
     'toggle-gutter': () => { prefs.gutter = !prefs.gutter; persistPrefs(); applyPrefs(); },
     'toggle-wrap': () => { prefs.wrap = !prefs.wrap; persistPrefs(); applyPrefs(); },
     'prefs': openPrefs,
@@ -961,7 +1403,8 @@
       bodyHTML:
         `<p>Editor de notas minimalista inspirado no <b>Mousepad</b> (XFCE).</p>
          <p>Backend em <b>Go</b>, armazenamento em disco com revisões endereçadas por hash SHA-256 (estilo Git): cada salvamento de conteúdo gera um snapshot, com autor, data e diff.</p>
-         <p>Atalhos: <code>Ctrl+S</code> salvar · <code>Ctrl+N</code> nova · <code>Ctrl+E</code> editar · <code>Ctrl+R</code> preview · <code>Ctrl+H</code> histórico · <code>F9</code> barra lateral · <code>Ctrl+B/I/K</code> formatação.</p>`,
+         <p>Categorias viram uma <b>árvore de pastas</b> (barra lateral); notas podem ter <b>várias categorias</b> e abrir em <b>várias abas</b>.</p>
+         <p>Atalhos: <code>Ctrl+S</code> salvar · <code>Ctrl+N</code> nova aba · <code>Alt+W</code> fechar aba · <code>Alt+←/→</code> trocar aba · <code>Ctrl+E</code> editar · <code>Ctrl+R</code> preview · <code>Ctrl+H</code> histórico · <code>F9</code> barra lateral · <code>Ctrl+B/I/K</code> formatação · <code>Ctrl+,</code> preferências.</p>`,
     }),
     'logout': async () => {
       await fetch('/api/logout', { method: 'POST' }).catch(() => {});
@@ -974,21 +1417,29 @@
       ACTIONS[li.dataset.action]();
     }));
 
-  E.btnNew.addEventListener('click', () => newDraft());
+  E.btnNew.addEventListener('click', () => newDraftTab());
+  E.btnTabNew.addEventListener('click', () => newDraftTab());
   E.btnSave.addEventListener('click', () => save());
   E.btnExport.addEventListener('click', exportNote);
   E.btnVersions.addEventListener('click', () => toggleVersionsPanel());
-  E.btnSidebar.addEventListener('click', ACTIONS['toggle-sidebar']);
+  E.btnSidebar.addEventListener('click', toggleSidebar);
 
   /* ------------------------------------------------------------ teclado */
 
   document.addEventListener('keydown', (e) => {
     const mod = e.ctrlKey || e.metaKey;
-    if (e.key === 'F9') { e.preventDefault(); document.body.classList.toggle('sidebar-off'); return; }
+    if (e.key === 'F9') { e.preventDefault(); toggleSidebar(); return; }
+    if (e.altKey && !e.ctrlKey && !e.metaKey) {
+      if (e.key === 'w' || e.key === 'W') { e.preventDefault(); closeTab(state.activeKey); return; }
+      if (e.key === 'ArrowRight') { e.preventDefault(); cycleTab(1); return; }
+      if (e.key === 'ArrowLeft') { e.preventDefault(); cycleTab(-1); return; }
+      const n = parseInt(e.key, 10);
+      if (n >= 1 && n <= 9 && state.tabs[n - 1]) { e.preventDefault(); activateTab(state.tabs[n - 1].key); return; }
+    }
     if (!mod) return;
     switch (e.key.toLowerCase()) {
       case 's': e.preventDefault(); save(); break;
-      case 'n': e.preventDefault(); newDraft(); break;
+      case 'n': e.preventDefault(); newDraftTab(); break;
       case 'e': e.preventDefault(); setMode('edit'); break;
       case 'r': e.preventDefault(); setMode('preview'); break;
       case 'h': e.preventDefault(); toggleVersionsPanel(); break;
@@ -1000,7 +1451,10 @@
   });
 
   window.addEventListener('beforeunload', (e) => {
-    if (state.dirty) { e.preventDefault(); e.returnValue = ''; }
+    if (state.tabs.some((t) => t.dirty)) {
+      e.preventDefault();
+      e.returnValue = '';
+    }
   });
 
   /* ------------------------------------------------------------ status */
@@ -1017,17 +1471,18 @@
 
     const fmt = currentFormat();
     E.stFormat.textContent = EXT[fmt];
-    if (state.note) {
-      E.stFile.textContent = (E.noteTitle.value.trim() || state.note.title || 'Sem título') + EXT[fmt];
+    const t = activeTab();
+    if (t && t.id) {
+      E.stFile.textContent = (E.noteTitle.value.trim() || t.title || 'Sem título') + EXT[fmt];
     } else {
       E.stFile.textContent = E.noteTitle.value.trim() ? E.noteTitle.value.trim() + EXT[fmt] + ' (nova)' : 'rascunho sem salvar';
     }
 
-    if (state.dirty) {
+    if (t && t.dirty) {
       E.stSaved.textContent = '● não salvo';
       E.stSaved.className = 'st-item dirty';
     } else {
-      E.stSaved.textContent = state.lastSaved ? 'salvo ' + relTime(state.lastSaved) : '—';
+      E.stSaved.textContent = t && t.lastSaved ? 'salvo ' + relTime(t.lastSaved) : '—';
       E.stSaved.className = 'st-item ok';
     }
   }
@@ -1042,10 +1497,6 @@
       loadNotes().catch(() => {});
     }, 250);
   });
-  E.categorySelect.addEventListener('change', () => {
-    state.filter.category = E.categorySelect.value;
-    loadNotes().catch(() => {});
-  });
 
   /* ------------------------------------------------------------ autor */
 
@@ -1058,8 +1509,7 @@
   async function boot() {
     applyPrefs();
     await Promise.all([loadNotes(), loadAggregates()]);
-    if (state.notes.length) await openNote(state.notes[0].id);
-    else await newDraft(true);
+    await restoreTabs();
     updateStatus();
   }