refactor: integra reconcile no boot, dedup categoria/pasta, CI, Go 1.24

- Boot chama ReconcileBlobs com log de órfãos (era código morto)
- treeNode/validTreeName/siblingDup/moveCreatesCycle compartilhados
  entre Create/Update Category/Folder (mesma regra, um só lugar)
- mapStoreErrorFor com mensagens 404 por recurso (nota/arquivo/pasta/categoria)
- revisionHash helper + teste GET /revisions/{hash} (200 + 404)
- ReconcileBlobs com lock curto (coleta sob RLock, I/O fora do lock)
- AddFile com LimitReader no stream (cap antes de gravar, não depois)
- DeleteFile/DeleteFolder transacionais com rollback em memória
- attachmentKind único no frontend (syntax/html/preview)
- CI: gofmt, vet, test -race, node --check; go.mod 1.24 = Dockerfile
- README: notas operacionais (memória, proxy, boot, SSE, 413/400)

internal/api/server.go

@@ -194,7 +194,6 @@ func (s *Server) handleLogin(w http.ResponseWriter, r *http.Request) {
 	}
 	var req loginRequest
 	if err := decodeJSON(w, r, &req, 1<<16); err != nil {
-		writeError(w, http.StatusBadRequest, "corpo JSON inválido")
 		return
 	}
 	if subtle.ConstantTimeCompare([]byte(strings.TrimSpace(req.Token)), []byte(s.token)) != 1 {
@@ -239,11 +238,19 @@ func (s *Server) handleMe(w http.ResponseWriter, r *http.Request) {
 // JSON helpers
 // ---------------------------------------------------------------------------
 
+// decodeJSON lê e valida o corpo JSON com limite. Corpos acima do limite viram
+// 413 (http.MaxBytesError); JSON inválido vira 400. Em erro a resposta já foi
+// escrita — o chamador deve apenas retornar.
 func decodeJSON(w http.ResponseWriter, r *http.Request, v any, maxBytes int64) error {
-	defer r.Body.Close()
 	dec := json.NewDecoder(http.MaxBytesReader(w, r.Body, maxBytes))
 	dec.DisallowUnknownFields()
 	if err := dec.Decode(v); err != nil {
+		var maxErr *http.MaxBytesError
+		if errors.As(err, &maxErr) {
+			writeError(w, http.StatusRequestEntityTooLarge, "corpo da requisição excede o limite")
+			return err
+		}
+		writeError(w, http.StatusBadRequest, "corpo JSON inválido")
 		return err
 	}
 	return nil
@@ -260,11 +267,26 @@ func writeError(w http.ResponseWriter, code int, msg string) {
 	writeJSON(w, code, map[string]string{"error": msg})
 }
 
-// mapStoreError converte erros da store para códigos HTTP.
+// mapStoreError converte erros da store para códigos HTTP. resource identifica
+// o alvo ("nota", "revisão", "arquivo", "pasta", "categoria") para mensagens
+// 404 precisas em vez do genérico "nota não encontrada".
 func mapStoreError(w http.ResponseWriter, err error) {
+	mapStoreErrorFor(w, err, "nota")
+}
+
+func mapStoreErrorFor(w http.ResponseWriter, err error, resource string) {
+	notFound := map[string]string{
+		"nota":      "nota não encontrada",
+		"arquivo":   "arquivo não encontrado",
+		"pasta":     "pasta não encontrada",
+		"categoria": "categoria não encontrada",
+	}[resource]
+	if notFound == "" {
+		notFound = "recurso não encontrado"
+	}
 	switch {
 	case errors.Is(err, store.ErrNotFound):
-		writeError(w, http.StatusNotFound, "nota não encontrada")
+		writeError(w, http.StatusNotFound, notFound)
 	case errors.Is(err, store.ErrRevision):
 		writeError(w, http.StatusNotFound, "revisão não encontrada")
 	case errors.Is(err, store.ErrInvalid):