chore: move business tooling out of the public library; tidy filestore naming

Keep the public tree project-generic. Business/one-off tools, deployment
and business docs move to the private oo-workspace repo.

Moved to oo-workspace:
- cmd/ooscan, cmd/pdfamount, cmd/kontoblatt, cmd/kontolink
- internal/xlspipe (cutover-portugal workbook) -> oow workbook build
  (drops the --template/--title flags from oo docs put-xlsx)
- deploy/docker-compose.rclone-webdav.yml + docs/rclone-webdav.md
- docs/crm-associations.md

Removed GitHub-era leftovers:
- .github/workflows/release-please.yml, release-please-config.json,
  .release-please-manifest.json (tags are created on Gitea per SemVer)

Naming: the FileStore subsystem is now filestore_*.go (was file_*.go) to
match files_*.go (project Documents). Docs/AGENTS/README updated.

filestore_es_text_test.go

@@ -0,0 +1,275 @@
+package onlyoffice
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"os"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestESTextSearchRequestShape(t *testing.T) {
+	got := esTextSearchRequest(SearchQuery{
+		Text:       "S1021",
+		FolderID:   "634",
+		Extensions: []string{".PDF", "pdf"},
+		Limit:      5,
+	})
+	if got.Size != 5 {
+		t.Errorf("size = %d, want 5", got.Size)
+	}
+	mm := got.Query.Bool.Must[0].MultiMatch
+	if mm == nil || !reflect.DeepEqual(mm.Fields, []string{"title^2", "content"}) {
+		t.Fatalf("multi_match = %+v, want title^2 + content", mm)
+	}
+	if _, ok := got.Highlight.Fields["content"]; !ok {
+		t.Error("content highlight missing")
+	}
+	if _, ok := got.Highlight.Fields["title"]; !ok {
+		t.Error("title highlight missing")
+	}
+	var folder, exts int
+	for _, f := range got.Query.Bool.Filter {
+		switch {
+		case f.Term != nil && f.Term["folder"] != nil:
+			folder++
+			if f.Term["folder"] != "634" {
+				t.Errorf("folder term = %+v", f.Term)
+			}
+		case f.Terms != nil:
+			exts++
+			if !reflect.DeepEqual(f.Terms["ext"], []string{"pdf"}) {
+				t.Errorf("ext terms = %+v, want deduped pdf", f.Terms)
+			}
+		}
+	}
+	if folder != 1 || exts != 1 {
+		t.Errorf("filters folder=%d exts=%d, want 1 each", folder, exts)
+	}
+}
+
+func TestESTextBulkBody(t *testing.T) {
+	body := esTextBulkBody([]TextDoc{
+		{ID: "3578", Title: "S1021.pdf", FolderID: "634", Ext: "pdf", Content: "Begleitzettel <S1021> & mehr"},
+		{ID: "3579", Title: "S1023.pdf", Ext: "pdf", Content: "x"},
+	})
+	lines := strings.Split(strings.TrimRight(string(body), "\n"), "\n")
+	if len(lines) != 4 {
+		t.Fatalf("bulk body has %d lines, want 4:\n%s", len(lines), body)
+	}
+	if !strings.Contains(lines[0], `"index"`) || !strings.Contains(lines[0], `"_id":"3578"`) {
+		t.Errorf("action line = %q", lines[0])
+	}
+	if !strings.Contains(lines[1], `"content":"Begleitzettel <S1021> & mehr"`) {
+		t.Errorf("source line should keep HTML unescaped, got %q", lines[1])
+	}
+	if !strings.Contains(lines[2], `"_id":"3579"`) {
+		t.Errorf("second action line = %q", lines[2])
+	}
+}
+
+func TestParseESTextResponse(t *testing.T) {
+	raw := []byte(`{
+	  "hits": {
+	    "total": {"value": 1, "relation": "eq"},
+	    "hits": [
+	      {
+	        "_id": "3578",
+	        "_score": 3.21,
+	        "_source": {"id": "3578", "title": "2026-07-28-S1021-acme-rechnung.pdf", "folder": "634", "ext": "pdf"},
+	        "highlight": {"content": ["Begleitzettel … <em>S1021</em> …"]}
+	      }
+	    ]
+	  }
+	}`)
+	hits, err := parseESTextResponse(raw)
+	if err != nil {
+		t.Fatalf("parseESTextResponse: %v", err)
+	}
+	if len(hits) != 1 {
+		t.Fatalf("hits = %d, want 1", len(hits))
+	}
+	h := hits[0]
+	if h.ID != "3578" || h.Title != "2026-07-28-S1021-acme-rechnung.pdf" || h.Kind != File {
+		t.Errorf("entry = %+v", h.Entry)
+	}
+	if h.ParentID != "634" || !reflect.DeepEqual(h.Path, []string{"634"}) {
+		t.Errorf("path = %v parent = %q", h.Path, h.ParentID)
+	}
+	if h.Provider != "es-text" {
+		t.Errorf("provider = %q", h.Provider)
+	}
+	if h.Highlight != "Begleitzettel … S1021 …" {
+		t.Errorf("highlight = %q, want tags stripped", h.Highlight)
+	}
+}
+
+func TestNewESTextIndexDefaults(t *testing.T) {
+	if _, err := NewESTextIndex(ESTextConfig{}); err == nil {
+		t.Error("empty URL: want error")
+	}
+	x, err := NewESTextIndex(ESTextConfig{URL: "http://es:9200/"})
+	if err != nil {
+		t.Fatalf("NewESTextIndex: %v", err)
+	}
+	if x.Index() != defaultESTextIndex {
+		t.Errorf("index = %q, want %q", x.Index(), defaultESTextIndex)
+	}
+	if x.cfg.URL != "http://es:9200" {
+		t.Errorf("url = %q, want trimmed", x.cfg.URL)
+	}
+	if x.Name() != "es-text" {
+		t.Errorf("Name() = %q", x.Name())
+	}
+}
+
+func TestESTextConfigFromEnvIndexDefault(t *testing.T) {
+	t.Setenv("ONLYOFFICE_ES_URL", "http://es:9200/")
+	t.Setenv("ONLYOFFICE_ES_TEXT_INDEX", "")
+	cfg := ESTextConfigFromEnv()
+	if cfg.Index != defaultESTextIndex {
+		t.Errorf("index = %q, want %q", cfg.Index, defaultESTextIndex)
+	}
+}
+
+func TestTextIndexerIndexEntries(t *testing.T) {
+	store := &textFakeStore{
+		files: map[string][]byte{"1": []byte("PDFBYTES")},
+	}
+	idx := &textFakeIndex{}
+	ix := NewTextIndexer(store, idx)
+	ix.Extractor = textFakeExtractor{prefix: "TEXT "}
+
+	res, err := ix.IndexEntries(context.Background(), []Entry{
+		{ID: "1", Title: "Rechnung.PDF", ParentID: "649", Kind: File},
+		{ID: "2", Title: "Tabelle.xlsx", ParentID: "649", Kind: File},
+		{ID: "3", Title: "Unterordner", Kind: Folder},
+	}, IndexOptions{})
+	if err != nil {
+		t.Fatalf("IndexEntries: %v", err)
+	}
+	if res.Scanned != 3 || res.Indexed != 1 || res.Skipped != 2 || res.Failed != 0 {
+		t.Errorf("result = %+v, want scanned=3 indexed=1 skipped=2 failed=0", res)
+	}
+	if len(idx.docs) != 1 {
+		t.Fatalf("indexed docs = %d, want 1", len(idx.docs))
+	}
+	got := idx.docs[0]
+	want := TextDoc{ID: "1", Title: "Rechnung.PDF", FolderID: "649", Ext: "pdf", Content: "TEXT PDFBYTES"}
+	if !reflect.DeepEqual(got, want) {
+		t.Errorf("doc = %+v, want %+v", got, want)
+	}
+}
+
+func TestTextIndexerRecordsExtractionFailure(t *testing.T) {
+	store := &textFakeStore{files: map[string][]byte{"1": []byte("x")}}
+	idx := &textFakeIndex{}
+	ix := NewTextIndexer(store, idx)
+	ix.Extractor = textFailingExtractor{}
+
+	res, err := ix.IndexEntries(context.Background(), []Entry{{ID: "1", Title: "a.pdf", Kind: File}}, IndexOptions{})
+	if err != nil {
+		t.Fatalf("IndexEntries: %v", err)
+	}
+	if res.Indexed != 0 || res.Failed != 1 || len(res.Errors) != 1 {
+		t.Errorf("result = %+v, want one failure recorded", res)
+	}
+}
+
+func TestTextIndexerPlanFolder(t *testing.T) {
+	store := &textFakeStore{dirs: map[string][]Entry{
+		"root": {
+			{ID: "10", Title: "a.pdf", Kind: File},
+			{ID: "11", Title: "sub", Kind: Folder},
+		},
+		"11": {
+			{ID: "12", Title: "b.PDF", Kind: File},
+			{ID: "13", Title: "c.xlsx", Kind: File},
+		},
+	}}
+	ix := NewTextIndexer(store, &textFakeIndex{})
+
+	flat, err := ix.PlanFolder(context.Background(), "root", IndexOptions{})
+	if err != nil {
+		t.Fatalf("PlanFolder: %v", err)
+	}
+	if len(flat) != 1 || flat[0].ID != "10" {
+		t.Errorf("flat plan = %+v, want only a.pdf", flat)
+	}
+	deep, err := ix.PlanFolder(context.Background(), "root", IndexOptions{Recursive: true, Limit: 10})
+	if err != nil {
+		t.Fatalf("PlanFolder recursive: %v", err)
+	}
+	if len(deep) != 2 {
+		t.Errorf("recursive plan = %d entries, want 2", len(deep))
+	}
+}
+
+// --- fakes -----------------------------------------------------------------
+
+type textFakeStore struct {
+	dirs  map[string][]Entry
+	files map[string][]byte
+	stat  map[string]Entry
+}
+
+func (f *textFakeStore) Name() string { return "fake" }
+
+func (f *textFakeStore) List(_ context.Context, parentID string) ([]Entry, error) {
+	return f.dirs[parentID], nil
+}
+
+func (f *textFakeStore) Stat(_ context.Context, id string) (Entry, error) {
+	if e, ok := f.stat[id]; ok {
+		return e, nil
+	}
+	return Entry{}, fmt.Errorf("not found: %s", id)
+}
+
+func (f *textFakeStore) Download(_ context.Context, id string, w io.Writer) (int64, error) {
+	b, ok := f.files[id]
+	if !ok {
+		return 0, fmt.Errorf("no bytes for %s", id)
+	}
+	n, err := w.Write(b)
+	return int64(n), err
+}
+
+func (f *textFakeStore) CreateFolder(context.Context, string, string) (Entry, error) {
+	return Entry{}, nil
+}
+func (f *textFakeStore) Upload(context.Context, string, string, io.Reader) (Entry, error) {
+	return Entry{}, nil
+}
+func (f *textFakeStore) Move(context.Context, []string, string) error { return nil }
+func (f *textFakeStore) Copy(context.Context, []string, string) error { return nil }
+func (f *textFakeStore) Rename(context.Context, string, string) error { return nil }
+func (f *textFakeStore) Delete(context.Context, []string) error       { return nil }
+
+type textFakeIndex struct{ docs []TextDoc }
+
+func (f *textFakeIndex) Put(_ context.Context, docs []TextDoc) error {
+	f.docs = append(f.docs, docs...)
+	return nil
+}
+func (f *textFakeIndex) Delete(context.Context, []string) error                   { return nil }
+func (f *textFakeIndex) Search(context.Context, SearchQuery) ([]SearchHit, error) { return nil, nil }
+func (f *textFakeIndex) Name() string                                             { return "fake" }
+
+type textFakeExtractor struct{ prefix string }
+
+func (f textFakeExtractor) Extract(path, _, _ string, _ int) (string, error) {
+	b, err := os.ReadFile(path)
+	if err != nil {
+		return "", err
+	}
+	return f.prefix + string(b), nil
+}
+
+type textFailingExtractor struct{}
+
+func (textFailingExtractor) Extract(string, string, string, int) (string, error) {
+	return "", fmt.Errorf("boom")
+}