fix: bind mounts from DOCKER_PATH + real storage reads from disk

docker-compose.yml:
- Switch from named volumes back to bind mounts driven by DOCKER_PATH in .env
- DOCKER_PATH/config → /config, DOCKER_PATH/data → /data
- Works with both Windows paths (C:\...) and Linux paths (/opt/...)

server.go:
- Wire in storage.Store so documents query reads real .adoc files from disk
- handleDocuments: calls store.List("") and store.Read(slug) for actual content
- extractTitle: parses first "= Title" line from AsciiDoc, falls back to slug
- handleSetup: also initialises store after writing config so docs appear immediately
- Single document query (document(slug:...)) reads and returns full content

.env.example:
- Clarify DOCKER_PATH usage with Windows and Linux examples
- Show resulting directory layout on host

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

backend/internal/graph/server.go

@@ -1,6 +1,7 @@
 package graph
 
 import (
+	"bufio"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -12,6 +13,7 @@ import (
 	"time"
 
 	"github.com/brasse-b/archivum/internal/config"
+	"github.com/brasse-b/archivum/internal/storage"
 )
 
 // Server holds runtime state that can change after the setup wizard completes.
@@ -19,11 +21,21 @@ type Server struct {
 	mu         sync.RWMutex
 	cfg        *config.Config
 	configPath string
+	store      *storage.Store
 }
 
 func NewServer(cfg *config.Config, configPath string) http.Handler {
 	s := &Server{cfg: cfg, configPath: configPath}
 
+	if cfg != nil {
+		if store, err := storage.New(cfg.StoragePath); err != nil {
+			log.Printf("[storage] failed to open storage at %s: %v", cfg.StoragePath, err)
+		} else {
+			s.store = store
+			log.Printf("[storage] opened at %s", cfg.StoragePath)
+		}
+	}
+
 	mux := http.NewServeMux()
 	mux.HandleFunc("/graphql", s.handleGraphQL)
 	mux.HandleFunc("/health", s.handleHealth)
@@ -71,6 +83,7 @@ func (s *Server) handleGraphQL(w http.ResponseWriter, r *http.Request) {
 
 	s.mu.RLock()
 	cfg := s.cfg
+	store := s.store
 	s.mu.RUnlock()
 
 	// ── Mutations available before setup ─────────────────────────────────────
@@ -79,8 +92,8 @@ func (s *Server) handleGraphQL(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	// ── System status ─────────────────────────────────────────────────────────
-	if strings.Contains(req.Query, "systemStatus") {
+	// ── System status (always available) ─────────────────────────────────────
+	if strings.Contains(req.Query, "systemStatus") && !strings.Contains(req.Query, "documents") {
 		if cfg == nil {
 			log.Printf("[graphql] systemStatus → REQUIRE_SETUP")
 			writeJSON(w, `{"data":{"systemStatus":"REQUIRE_SETUP"}}`)
@@ -105,15 +118,84 @@ func (s *Server) handleGraphQL(w http.ResponseWriter, r *http.Request) {
 	case strings.Contains(req.Query, "login"):
 		writeJSON(w, `{"data":{"login":"stub-token"}}`)
 
-	case strings.Contains(req.Query, "documents"):
-		writeJSON(w, `{"data":{"documents":[]}}`)
+	case strings.Contains(req.Query, "documents") || strings.Contains(req.Query, "document"):
+		s.handleDocuments(w, req, store)
 
 	default:
 		writeJSON(w, `{"data":{"systemStatus":"OK"}}`)
 	}
 }
 
-// handleSetup parses the setup input, writes config.json, and activates the config.
+// handleDocuments reads document list (or a single doc) from the real Store.
+func (s *Server) handleDocuments(w http.ResponseWriter, req gqlRequest, store *storage.Store) {
+	if store == nil {
+		writeGQLError(w, "storage not initialised")
+		return
+	}
+
+	// Single document query
+	if strings.Contains(req.Query, "document(") || strings.Contains(req.Query, "document(slug") {
+		slug, _ := req.Variables["s"].(string)
+		if slug == "" {
+			writeGQLError(w, "slug is required")
+			return
+		}
+		content, err := store.Read(slug)
+		if err != nil {
+			log.Printf("[storage] read %q: %v", slug, err)
+			writeGQLError(w, fmt.Sprintf("document not found: %s", slug))
+			return
+		}
+		title := extractTitle(content, slug)
+		resp := map[string]interface{}{
+			"data": map[string]interface{}{
+				"document": map[string]interface{}{
+					"slug":    slug,
+					"content": content,
+					"meta": map[string]string{
+						"slug":      slug,
+						"title":     title,
+						"updatedAt": "",
+					},
+				},
+			},
+		}
+		writeJSONObj(w, resp)
+		return
+	}
+
+	// Document list
+	slugs, err := store.List("")
+	if err != nil {
+		log.Printf("[storage] list: %v", err)
+		writeGQLError(w, fmt.Sprintf("failed to list documents: %v", err))
+		return
+	}
+
+	log.Printf("[storage] listed %d documents", len(slugs))
+
+	docs := make([]map[string]string, 0, len(slugs))
+	for _, slug := range slugs {
+		content, err := store.Read(slug)
+		title := slug
+		if err == nil {
+			title = extractTitle(content, slug)
+		}
+		docs = append(docs, map[string]string{
+			"slug":      slug,
+			"title":     title,
+			"updatedAt": "",
+		})
+	}
+
+	writeJSONObj(w, map[string]interface{}{
+		"data": map[string]interface{}{
+			"documents": docs,
+		},
+	})
+}
+
+// handleSetup parses the setup input, writes config.json, and activates config + storage.
 func (s *Server) handleSetup(w http.ResponseWriter, req gqlRequest) {
 	input, ok := req.Variables["i"].(map[string]interface{})
 	if !ok {
@@ -137,7 +219,6 @@ func (s *Server) handleSetup(w http.ResponseWriter, req gqlRequest) {
 		ListenAddr:  ":4000",
 	}
 
-	// Optional LDAP
 	if ldapRaw, ok := input["ldap"].(map[string]interface{}); ok && ldapRaw != nil {
 		port := 389
 		if p, ok := ldapRaw["port"].(float64); ok {
@@ -152,7 +233,6 @@ func (s *Server) handleSetup(w http.ResponseWriter, req gqlRequest) {
 		}
 	}
 
-	// Ensure the config directory exists before writing.
 	if err := os.MkdirAll(dirOf(s.configPath), 0755); err != nil {
 		log.Printf("[setup] mkdir failed: %v", err)
 		writeGQLError(w, fmt.Sprintf("could not create config directory: %v", err))
@@ -167,9 +247,17 @@ func (s *Server) handleSetup(w http.ResponseWriter, req gqlRequest) {
 
 	log.Printf("[setup] config written to %s", s.configPath)
 
-	// Activate new config in memory so subsequent requests see OK immediately.
+	store, err := storage.New(storagePath)
+	if err != nil {
+		log.Printf("[setup] failed to open storage at %s: %v", storagePath, err)
+		// Non-fatal — storage can be retried, but config is saved.
+	} else {
+		log.Printf("[setup] storage opened at %s", storagePath)
+	}
+
 	s.mu.Lock()
 	s.cfg = cfg
+	s.store = store
 	s.mu.Unlock()
 
 	log.Printf("[setup] complete — storage: %s", storagePath)
@@ -181,6 +269,7 @@ func (s *Server) handleHealth(w http.ResponseWriter, r *http.Request) {
 	ready := s.cfg != nil
 	s.mu.RUnlock()
 
+	w.Header().Set("Content-Type", "application/json")
 	if ready {
 		w.WriteHeader(http.StatusOK)
 		_, _ = w.Write([]byte(`{"status":"ok"}`))
@@ -197,18 +286,15 @@ func spaHandler(dir string) http.Handler {
 	fileServer := http.FileServer(fsys)
 
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		// Always try to open the exact path first.
 		f, err := fsys.Open(r.URL.Path)
 		if err == nil {
 			fi, statErr := f.Stat()
 			f.Close()
-			// Serve directories as SPA root (e.g. GET /)
 			if statErr == nil && !fi.IsDir() {
 				fileServer.ServeHTTP(w, r)
 				return
 			}
 		}
-		// Path doesn't exist or is a directory → serve the SPA shell.
 		http.ServeFile(w, r, dir+"/index.html")
 	})
 }
@@ -230,7 +316,6 @@ func requestLogger(next http.Handler) http.Handler {
 		sw := &statusWriter{ResponseWriter: w, status: 200}
 		start := time.Now()
 		next.ServeHTTP(sw, r)
-		// Skip noisy health-check logs unless they fail.
 		if r.URL.Path == "/health" && sw.status == 200 {
 			return
 		}
@@ -240,10 +325,30 @@ func requestLogger(next http.Handler) http.Handler {
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
+// extractTitle reads the first AsciiDoc heading line (= Title) from content.
+// Falls back to the slug if no heading is found.
+func extractTitle(content, slug string) string {
+	scanner := bufio.NewScanner(strings.NewReader(content))
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if strings.HasPrefix(line, "= ") {
+			return strings.TrimPrefix(line, "= ")
+		}
+	}
+	// Use the last path segment of the slug as a readable fallback.
+	parts := strings.Split(slug, "/")
+	return parts[len(parts)-1]
+}
+
 func writeJSON(w http.ResponseWriter, body string) {
 	_, _ = w.Write([]byte(body))
 }
 
+func writeJSONObj(w http.ResponseWriter, v interface{}) {
+	b, _ := json.Marshal(v)
+	_, _ = w.Write(b)
+}
+
 func writeGQLError(w http.ResponseWriter, msg string) {
 	body, _ := json.Marshal(map[string]interface{}{
 		"errors": []map[string]string{{"message": msg}},
@@ -259,7 +364,6 @@ func gqlOpName(query string) string {
 	case strings.HasPrefix(q, "query"):
 		return "query " + firstWord(strings.TrimSpace(q[len("query"):]))
 	case strings.HasPrefix(q, "{"):
-		// Shorthand query: extract first field name from { field ... }
 		inner := strings.TrimSpace(q[1:])
 		return "query {" + firstWord(inner) + "...}"
 	default: