feat(office): mail preview, infinite scroll, pane resize, and scrollbars

Polish the office TUI with proportional pane layout, drag resize, live
filtering, HTML mail preview, paginated mail lists, overflow scrollbars,
flattened navigation, and project save/status fixes; add UpdateProjectStatus.

Co-authored-by: Cursor <cursoragent@cursor.com>

.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.5.0"
+  ".": "0.6.0"
 }

CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to this project are documented here. The format is based on
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project
 adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.6.0](https://github.com/eSlider/go-onlyoffice/compare/v0.5.0...v0.6.0) (2026-06-24)
+
+
+### Features
+
+* **office:** table detail panes and Alt+1/2/3 layout toggles ([934af21](https://github.com/eSlider/go-onlyoffice/commit/934af21bc93a54df9f40aacb4d89468b00d7562e))
+
+
+### Documentation
+
+* CHANGELOG for office v0.5.1 release ([2985070](https://github.com/eSlider/go-onlyoffice/commit/29850701f8c9ab0c6d6427f63eaa189a1c558140))
+
 ## [0.5.0](https://github.com/eSlider/go-onlyoffice/compare/v0.4.0...v0.5.0) (2026-06-24)
 
 
@@ -40,56 +52,44 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.7.0] — 2026-06-24
+
 ### Added — `office` TUI
 
-- **`cmd/office`** — Bubble Tea terminal UI mirroring OnlyOffice Workspace:
-  three-pane layout (module tree, multi-select list, markdown preview).
-  Install: `go install github.com/eslider/go-onlyoffice/cmd/office@latest`.
-- **`cmd/internal/bootstrap`** — shared env loading and client auth for `oo`
-  and `office`.
-- Integration tests under `cmd/office/fetch/` and `cmd/office/preview/`
-  (`-tags=integration`) hit the live OnlyOffice API — no fixture maps or
-  httptest vendor mocks. Unit tests remain for pure UI/formatting helpers only.
+- **Pane layout** — default **10% / 60% / 30%** split (nav / list / detail); drag vertical borders to resize; **Alt+1/2/3** still toggles panes.
+- **Filter mode** (`f`) — live filter on nav + list; right pane is the search query; **Esc** clears.
+- **Mail preview** — HTML bodies rendered colorized in the terminal (glamour); read-only scrollable document pane.
+- **Mail infinite scroll** — loads the next page automatically when the cursor nears the end of the list.
+- **Scrollbars** — vertical scrollbar on nav, list body, and detail preview when content exceeds the viewport.
+- **Calendar** — unified calendars + events leaf with **Type** column and date range (−7d … +30d).
+- **Tasks** — humanized status labels and relative deadlines in the list.
+- **Projects** — open/closed row colors; status toggle in the detail form; **Save** sends `responsibleId` and status via `UpdateProjectStatus`.
+
+### Changed — `office` TUI
+
+- Flattened navigation: **Projects**, **Tasks**, **By project**, **Calendar**, **CRM**, **Mail**, **Users** (removed Browse; Calendar no longer splits Calendars/Events).
+- Middle pane truncates overflowing cells with `…`; full text on the cursor or Space-selected row.
+- Detail form tab order: Title → Description → Status → Save → Delete.
+- **j/k** scrolls mail/file preview and read-only detail forms; mouse wheel scrolls detail when hovering the content area.
 
 ### Added — library
 
-- **CRM dedupe & cleanup** — `crm_normalize.go`, `crm_dedupe_plan.go`, `crm_dedupe.go`:
-  merge duplicate companies/persons/deals by normalized name; remove duplicate
-  contact-info rows and opportunity members (including same `displayName` with
-  different ids); fix malformed deal titles (` @ Company` → `Company`).
-  `MergeContacts`, `UpdateOpportunityTitle`, `ListAllContacts`,
-  `ListAllOpportunities`, `DeleteContactInfo`, `RemoveOpportunityMember`,
-  `IsOpportunityMember`, `HasContactInfo`, `CleanupCRM`.
-- Slogan-aware grouping: `StripSloganSuffix`, `CompanyGroupingKey` merge names
-  like `Affirm` and `Affirm — Fraud Engineering` (companies, deals, members).
-- **Workspace mail** — [`mails.go`](mails.go): `ListMailAccounts`, `ListMailFolders`,
-  `ListMailMessages`, `GetMailMessage`, `RemoveMailMessages` against OnlyOffice
-  Mail addon (`/api/2.0/mail/*`).
-- [`crm_integration_test.go`](crm_integration_test.go) — live merge, rename,
-  dedupe smoke tests.
+- `UpdateProjectStatus` — `PUT /api/2.0/project/{id}/status` for open/closed lifecycle.
 
-### Added — CLI
+## [0.5.1] — 2026-06-24
 
-- `oo mails accounts|folders|list|get|delete` — OnlyOffice Workspace mail (same `ONLYOFFICE_*` creds).
-- `oo companies dedupe|dedupe-persons`, `oo persons dedupe`, `oo contacts dedupe-info`,
-  `oo opportunities dedupe|dedupe-members|fix-titles`, `oo crm cleanup`.
+### Added — `office` TUI
 
-### Added — CI/CD
+- **Alt+1 / Alt+2 / Alt+3** — show/hide left (nav), middle (table), and right (detail) panes.
+- Visible panes share **100% terminal width** evenly; pane content fills its column.
+- Tab focus skips hidden panes.
 
-- GitHub Actions: `test.yml` (vet, unit tests, `oo` build), `release-please.yml`
-  (semver from conventional commits), `release.yml` (GoReleaser binaries for `oo`).
+### Changed — `office` TUI
 
-### Changed — CLI
-
-- README: expanded **oo CLI use cases** (CRM cleanup, applications sync, mail, contacts).
-- `oo applications sync` — empty position uses company-only deal title; skips
-  duplicate opportunity members; paginated find-or-create lookups.
-- `oo` now loads OnlyOffice credentials only from `.env` in the current
-  working directory.
-- Produktor.io shorthand env names are accepted by the CLI dotenv loader:
-  `OO_URL` → `ONLYOFFICE_URL`, `OO_USER` → `ONLYOFFICE_USER`, and
-  `OO_PASS` → `ONLYOFFICE_PASS`. Canonical `ONLYOFFICE_*` values still win
-  when already set in the process environment.
+- Split detail pane: form/document top (~72%), CRUD action bar bottom.
+- Middle pane: multi-column table with sort, selection, and full-width columns.
+- Project list columns: ID, Title, Tasks (open/closed), Documents, Users.
+- Row selection auto-loads detail; files show document preview, entities show forms.
 
 ## [0.6.0] - 2026-04-24
 

cmd/office/fetch/calendar.go

@@ -0,0 +1,53 @@
+package fetch
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/eslider/go-onlyoffice/cmd/office/model"
+)
+
+// CalendarItemFields maps calendar API rows to list items.
+var CalendarItemFields = FieldMap{IDKey: "objectId", TitleKey: "title"}
+
+// CalendarItemsFromRows converts API calendar/event rows into list items.
+func CalendarItemsFromRows(rows []map[string]any) []model.Item {
+	out := make([]model.Item, 0, len(rows))
+	for _, row := range rows {
+		kind, typeLabel := model.ClassifyCalendarRow(row)
+		title := str(row, "title")
+		if title == "" {
+			title = str(row, "name")
+		}
+		if title == "" {
+			title = "(untitled)"
+		}
+		raw := make(map[string]any, len(row)+1)
+		for k, v := range row {
+			raw[k] = v
+		}
+		raw["type"] = typeLabel
+		out = append(out, model.Item{
+			ID:    idStr(row, "objectId"),
+			Title: title,
+			Kind:  kind,
+			Raw:   raw,
+		})
+	}
+	return out
+}
+
+// ListCalendar returns calendars and events for the upcoming date window.
+func (l *Loader) ListCalendar(ctx context.Context) ([]model.Item, error) {
+	if l == nil || l.Client == nil {
+		return nil, fmt.Errorf("fetch: client is nil")
+	}
+	start := time.Now().AddDate(0, 0, -7).Format("2006-01-02")
+	end := time.Now().AddDate(0, 0, 30).Format("2006-01-02")
+	rows, err := l.Client.ListCalendars(ctx, start, end)
+	if err != nil {
+		return nil, err
+	}
+	return CalendarItemsFromRows(rows), nil
+}

cmd/office/fetch/fetch_integration_test.go

@@ -39,8 +39,7 @@ func TestIntegrationListAllSubjects(t *testing.T) {
 	cases := []model.ListSpec{
 		{Subject: model.SubjectProjects},
 		{Subject: model.SubjectTasks},
-		{Subject: model.SubjectCalendars},
-		{Subject: model.SubjectEvents},
+		{Subject: model.SubjectCalendar},
 		{Subject: model.SubjectContacts},
 		{Subject: model.SubjectPersons},
 		{Subject: model.SubjectCompanies},

cmd/office/fetch/list.go

@@ -6,12 +6,14 @@ import (
 	"os"
 	"path/filepath"
 	"strconv"
-	"time"
 
 	onlyoffice "github.com/eslider/go-onlyoffice"
 	"github.com/eslider/go-onlyoffice/cmd/office/model"
 )
 
+// MailListPageSize is how many messages each infinite-scroll fetch loads.
+const MailListPageSize = 25
+
 // Loader fetches list items for a menu subject using the OnlyOffice client.
 type Loader struct {
 	Client *onlyoffice.Client
@@ -30,10 +32,12 @@ func (l *Loader) List(ctx context.Context, spec model.ListSpec) ([]model.Item, e
 			return l.listTasksForProject(ctx, spec.ProjectID)
 		}
 		return l.listTasks(ctx)
+	case model.SubjectCalendar:
+		return l.ListCalendar(ctx)
 	case model.SubjectCalendars:
-		return l.listCalendars(ctx)
+		return l.ListCalendar(ctx)
 	case model.SubjectEvents:
-		return l.listEvents(ctx)
+		return l.ListCalendar(ctx)
 	case model.SubjectContacts:
 		return l.listContacts(ctx, nil)
 	case model.SubjectPersons:
@@ -49,15 +53,15 @@ func (l *Loader) List(ctx context.Context, spec model.ListSpec) ([]model.Item, e
 	case model.SubjectCRMTasks:
 		return l.listCRMTasks(ctx)
 	case model.SubjectMailInbox:
-		return l.listMail(ctx, onlyoffice.MailFolderInbox)
+		return l.listMail(ctx, onlyoffice.MailFolderInbox, 0)
 	case model.SubjectMailSent:
-		return l.listMail(ctx, onlyoffice.MailFolderSent)
+		return l.listMail(ctx, onlyoffice.MailFolderSent, 0)
 	case model.SubjectMailDrafts:
-		return l.listMail(ctx, onlyoffice.MailFolderDrafts)
+		return l.listMail(ctx, onlyoffice.MailFolderDrafts, 0)
 	case model.SubjectMailTrash:
-		return l.listMail(ctx, onlyoffice.MailFolderTrash)
+		return l.listMail(ctx, onlyoffice.MailFolderTrash, 0)
 	case model.SubjectMailSpam:
-		return l.listMail(ctx, onlyoffice.MailFolderSpam)
+		return l.listMail(ctx, onlyoffice.MailFolderSpam, 0)
 	case model.SubjectUsers:
 		return l.listUsers(ctx)
 	case model.SubjectProjectFiles:
@@ -244,13 +248,27 @@ func (l *Loader) listProjects(ctx context.Context) ([]model.Item, error) {
 		if p.Title != nil {
 			title = *p.Title
 		}
-		status := ""
+		raw := map[string]any{
+			"id":    id,
+			"title": title,
+		}
+		if p.TaskCount != nil {
+			raw["taskCount"] = *p.TaskCount
+		}
+		if p.TaskCountTotal != nil {
+			raw["taskCountTotal"] = *p.TaskCountTotal
+		}
+		if p.DocumentsCount != nil {
+			raw["documentsCount"] = *p.DocumentsCount
+		}
+		if p.ParticipantCount != nil {
+			raw["participantCount"] = *p.ParticipantCount
+		}
 		if p.Status != nil {
-			status = fmt.Sprint(*p.Status)
+			raw["status"] = *p.Status
 		}
 		items[i] = model.Item{
-			ID: id, Title: title, Subtitle: status, Kind: model.KindProject,
-			Raw: map[string]any{"id": id, "title": title, "status": status},
+			ID: id, Title: title, Kind: model.KindProject, Raw: raw,
 		}
 	}
 	return items, nil
@@ -264,24 +282,6 @@ func (l *Loader) listTasks(ctx context.Context) ([]model.Item, error) {
 	return ItemsFromMaps(rows, model.KindTask, TaskItemFields), nil
 }
 
-func (l *Loader) listCalendars(ctx context.Context) ([]model.Item, error) {
-	rows, err := l.Client.ListCalendars(ctx, "", "")
-	if err != nil {
-		return nil, err
-	}
-	return ItemsFromMaps(rows, model.KindCalendar, FieldMap{IDKey: "objectId", TitleKey: "title"}), nil
-}
-
-func (l *Loader) listEvents(ctx context.Context) ([]model.Item, error) {
-	start := time.Now().Format("2006-01-02")
-	end := time.Now().AddDate(0, 0, 7).Format("2006-01-02")
-	rows, err := l.Client.ListEvents(ctx, start, end)
-	if err != nil {
-		return nil, err
-	}
-	return ItemsFromMaps(rows, model.KindEvent, FieldMap{IDKey: "objectId", TitleKey: "title", SubtitleKey: "start"}), nil
-}
-
 func (l *Loader) listContacts(ctx context.Context, companyOnly *bool) ([]model.Item, error) {
 	rows, err := l.Client.ListAllContacts(ctx)
 	if err != nil {
@@ -324,14 +324,44 @@ func (l *Loader) listCRMTasks(ctx context.Context) ([]model.Item, error) {
 	return ItemsFromMaps(rows, model.KindCRMTask, TaskItemFields), nil
 }
 
-func (l *Loader) listMail(ctx context.Context, folder int) ([]model.Item, error) {
-	rows, err := l.Client.ListMailMessages(ctx, onlyoffice.MailMessagesFilter{Folder: folder, Count: 50})
+func (l *Loader) listMail(ctx context.Context, folder int, startIndex int) ([]model.Item, error) {
+	rows, err := l.Client.ListMailMessages(ctx, onlyoffice.MailMessagesFilter{
+		Folder:     folder,
+		Count:      MailListPageSize,
+		StartIndex: startIndex,
+	})
 	if err != nil {
 		return nil, err
 	}
 	return ItemsFromMaps(rows, model.KindMail, MailItemFields), nil
 }
 
+// ListMailMore loads the next page of messages for an active mail folder list.
+func (l *Loader) ListMailMore(ctx context.Context, spec model.ListSpec, startIndex int) ([]model.Item, error) {
+	folder, ok := mailFolderForSubject(spec.Subject)
+	if !ok {
+		return nil, fmt.Errorf("fetch: %q is not a mail folder", spec.Subject)
+	}
+	return l.listMail(ctx, folder, startIndex)
+}
+
+func mailFolderForSubject(subject model.Subject) (int, bool) {
+	switch subject {
+	case model.SubjectMailInbox:
+		return onlyoffice.MailFolderInbox, true
+	case model.SubjectMailSent:
+		return onlyoffice.MailFolderSent, true
+	case model.SubjectMailDrafts:
+		return onlyoffice.MailFolderDrafts, true
+	case model.SubjectMailTrash:
+		return onlyoffice.MailFolderTrash, true
+	case model.SubjectMailSpam:
+		return onlyoffice.MailFolderSpam, true
+	default:
+		return 0, false
+	}
+}
+
 func (l *Loader) listUsers(ctx context.Context) ([]model.Item, error) {
 	users, err := l.Client.GetUsers()
 	if err != nil {

cmd/office/fetch/map.go

@@ -14,7 +14,7 @@ type FieldMap struct {
 }
 
 // TaskItemFields is the default field map for project tasks.
-var TaskItemFields = FieldMap{IDKey: "id", TitleKey: "title", SubtitleKey: "status"}
+var TaskItemFields = FieldMap{IDKey: "id", TitleKey: "title"}
 
 // ProjectItemFields is the default field map for projects.
 var ProjectItemFields = FieldMap{IDKey: "id", TitleKey: "title", SubtitleKey: "status"}

cmd/office/fetch/preview.go

@@ -0,0 +1,43 @@
+package fetch
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+
+	onlyoffice "github.com/eslider/go-onlyoffice"
+	"github.com/eslider/go-onlyoffice/cmd/office/model"
+	"github.com/eslider/go-onlyoffice/cmd/office/preview"
+)
+
+// PreviewMarkdown loads item data and returns markdown for the preview pane.
+func (l *Loader) PreviewMarkdown(ctx context.Context, item model.Item) (string, error) {
+	if l == nil || l.Client == nil {
+		return "", fmt.Errorf("fetch: client is nil")
+	}
+	if item.Kind == model.KindFile {
+		return l.filePreviewMarkdown(ctx, item)
+	}
+	raw, err := l.Detail(ctx, item)
+	if err != nil {
+		return "", err
+	}
+	return preview.EntityMarkdown(string(item.Kind), raw), nil
+}
+
+func (l *Loader) filePreviewMarkdown(ctx context.Context, item model.Item) (string, error) {
+	if item.ID == "" {
+		return "", fmt.Errorf("file id missing")
+	}
+	name := item.Title
+	if meta, err := l.Client.GetFile(ctx, item.ID); err == nil && meta != nil {
+		if t := onlyoffice.FileEntryTitle(meta); t != "" {
+			name = t
+		}
+	}
+	var buf bytes.Buffer
+	if _, err := l.Client.DownloadFile(ctx, item.ID, &buf); err != nil {
+		return "", err
+	}
+	return preview.FileBytesToMarkdown(name, buf.Bytes())
+}

cmd/office/fetch/save.go

@@ -0,0 +1,64 @@
+package fetch
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	onlyoffice "github.com/eslider/go-onlyoffice"
+	"github.com/eslider/go-onlyoffice/cmd/office/model"
+)
+
+// SaveItem persists editable form fields for supported entity kinds.
+func (l *Loader) SaveItem(ctx context.Context, item model.Item, fields model.FormFields) error {
+	if l == nil || l.Client == nil {
+		return fmt.Errorf("fetch: client is nil")
+	}
+	switch item.Kind {
+	case model.KindTask:
+		return l.UpdateTask(ctx, item.ID, fields.Primary, fields.Secondary)
+	case model.KindProject:
+		return l.saveProject(ctx, item.ID, fields)
+	default:
+		return fmt.Errorf("save not supported for %s", item.Kind)
+	}
+}
+
+func (l *Loader) saveProject(ctx context.Context, projectID string, fields model.FormFields) error {
+	id, err := strconv.Atoi(projectID)
+	if err != nil {
+		return err
+	}
+	if fields.ResponsibleID == "" {
+		raw, derr := l.Detail(ctx, model.Item{ID: projectID, Kind: model.KindProject})
+		if derr == nil {
+			fields.ResponsibleID = model.ResponsibleIDFromRaw(raw)
+		}
+	}
+	req := onlyoffice.ProjectUpdateRequest{
+		ID:          id,
+		Title:       fields.Primary,
+		Description: fields.Secondary,
+	}
+	if fields.ResponsibleID != "" {
+		req.ResponsibleID = fields.ResponsibleID
+	}
+	if _, err := l.Client.UpdateProject(req); err != nil {
+		return err
+	}
+	if fields.HasStatus {
+		if _, err := l.Client.UpdateProjectStatus(id, string(fields.Status)); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// DetailForm loads form field values for the detail pane.
+func (l *Loader) DetailForm(ctx context.Context, item model.Item) (model.FormFields, error) {
+	raw, err := l.Detail(ctx, item)
+	if err != nil {
+		return model.FormFields{}, err
+	}
+	return model.FormFieldsFromRaw(item.Kind, raw), nil
+}

cmd/office/fetch/save_integration_test.go

@@ -0,0 +1,52 @@
+//go:build integration
+
+package fetch_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/eslider/go-onlyoffice/cmd/office/model"
+)
+
+func TestIntegrationSaveProject(t *testing.T) {
+	loader, ctx := liveLoader(t)
+	items, err := loader.List(ctx, model.ListSpec{Subject: model.SubjectProjects})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(items) == 0 {
+		t.Skip("no projects")
+	}
+	item := items[0]
+	fields, err := loader.DetailForm(ctx, item)
+	if err != nil {
+		t.Fatalf("DetailForm: %v", err)
+	}
+	if fields.ResponsibleID == "" {
+		t.Skip("project has no responsible id on this instance")
+	}
+	marker := " office-save-test " + time.Now().UTC().Format(time.RFC3339)
+	fields.Primary = fields.Primary + marker
+	if err := loader.SaveItem(ctx, item, fields); err != nil {
+		t.Fatalf("SaveItem: %v", err)
+	}
+	after, err := loader.DetailForm(ctx, item)
+	if err != nil {
+		t.Fatalf("DetailForm after save: %v", err)
+	}
+	if after.Primary != fields.Primary {
+		t.Fatalf("title not saved: got %q want %q", after.Primary, fields.Primary)
+	}
+	fields.Primary = stringsTrimSuffixMarker(after.Primary, marker)
+	if err := loader.SaveItem(ctx, item, fields); err != nil {
+		t.Logf("cleanup save: %v", err)
+	}
+}
+
+func stringsTrimSuffixMarker(s, marker string) string {
+	if len(s) >= len(marker) && s[len(s)-len(marker):] == marker {
+		return s[:len(s)-len(marker)]
+	}
+	return s
+}

cmd/office/fetch/task.go

@@ -0,0 +1,36 @@
+package fetch
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	onlyoffice "github.com/eslider/go-onlyoffice"
+	"github.com/eslider/go-onlyoffice/cmd/office/model"
+)
+
+// UpdateTask saves title and description for a project task.
+func (l *Loader) UpdateTask(ctx context.Context, taskID, title, description string) error {
+	if l == nil || l.Client == nil {
+		return fmt.Errorf("fetch: client is nil")
+	}
+	id, err := strconv.Atoi(taskID)
+	if err != nil {
+		return fmt.Errorf("task id %q: %w", taskID, err)
+	}
+	_, err = l.Client.UpdateProjectTask(onlyoffice.ProjectTaskUpdateRequest{
+		ID:          id,
+		Title:       title,
+		Description: description,
+	})
+	return err
+}
+
+// TaskFields loads title and description for a project task item.
+func (l *Loader) TaskFields(ctx context.Context, item model.Item) (title, description string, err error) {
+	fields, err := l.DetailForm(ctx, item)
+	if err != nil {
+		return "", "", err
+	}
+	return fields.Primary, fields.Secondary, nil
+}

cmd/office/fetch/task_integration_test.go

@@ -0,0 +1,68 @@
+//go:build integration
+
+package fetch_test
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/eslider/go-onlyoffice/cmd/office/model"
+)
+
+func TestIntegrationUpdateTaskTitleDescription(t *testing.T) {
+	loader, ctx := liveLoader(t)
+	items, err := loader.List(ctx, model.ListSpec{Subject: model.SubjectTasks})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(items) == 0 {
+		t.Skip("no tasks")
+	}
+	item := items[0]
+	title, desc, err := loader.TaskFields(ctx, item)
+	if err != nil {
+		t.Fatal(err)
+	}
+	restoreTitle, restoreDesc := title, desc
+	t.Cleanup(func() {
+		_ = loader.UpdateTask(context.Background(), item.ID, restoreTitle, restoreDesc)
+	})
+	newTitle := title + " (office TUI test)"
+	newDesc := desc + "\n\n_edited by office integration test_"
+	if err := loader.UpdateTask(ctx, item.ID, newTitle, newDesc); err != nil {
+		t.Fatal(err)
+	}
+	gotTitle, gotDesc, err := loader.TaskFields(ctx, item)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if gotTitle != newTitle {
+		t.Fatalf("title: got %q want %q", gotTitle, newTitle)
+	}
+	if gotDesc != newDesc {
+		t.Fatalf("description mismatch")
+	}
+}
+
+func TestIntegrationTaskFieldsFromLiveAPI(t *testing.T) {
+	if os.Getenv("ONLYOFFICE_URL") == "" && os.Getenv("ONLYOFFICE_HOST") == "" {
+		t.Skip("ONLYOFFICE_URL not set")
+	}
+	loader, ctx := liveLoader(t)
+	items, err := loader.List(ctx, model.ListSpec{Subject: model.SubjectTasks})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(items) == 0 {
+		t.Skip("no tasks")
+	}
+	title, desc, err := loader.TaskFields(ctx, items[0])
+	if err != nil {
+		t.Fatal(err)
+	}
+	if title == "" {
+		t.Fatal("empty title")
+	}
+	_ = desc
+}

cmd/office/main.go

@@ -26,7 +26,7 @@ func main() {
 	}
 
 	m := ui.NewModel(client)
-	p := tea.NewProgram(m, tea.WithAltScreen())
+	p := tea.NewProgram(m, tea.WithAltScreen(), tea.WithMouseCellMotion())
 	if _, err := p.Run(); err != nil {
 		fmt.Fprintln(os.Stderr, err)
 		os.Exit(1)

cmd/office/model/actions.go

@@ -5,6 +5,7 @@ type ActionID string
 
 const (
 	ActionView     ActionID = "view"
+	ActionSave     ActionID = "save"
 	ActionDelete   ActionID = "delete"
 	ActionRefresh  ActionID = "refresh"
 	ActionDownload ActionID = "download"
@@ -17,48 +18,47 @@ type ItemAction struct {
 	Danger bool
 }
 
-// ActionsFor returns available operations for an item kind.
+// ActionsFor returns available operations for an item kind (detail pane action bar).
 func ActionsFor(kind Kind) []ItemAction {
 	switch kind {
 	case KindProject:
 		return []ItemAction{
-			{ID: ActionView, Label: "View details"},
-			{ID: ActionDelete, Label: "Delete project", Danger: true},
+			{ID: ActionSave, Label: "Save"},
+			{ID: ActionDelete, Label: "Delete", Danger: true},
 		}
-	case KindTask, KindCRMTask:
+	case KindTask:
 		return []ItemAction{
-			{ID: ActionView, Label: "View details"},
+			{ID: ActionSave, Label: "Save"},
 			{ID: ActionDelete, Label: "Delete task", Danger: true},
 		}
+	case KindCRMTask:
+		return []ItemAction{
+			{ID: ActionDelete, Label: "Delete", Danger: true},
+		}
 	case KindContact:
 		return []ItemAction{
-			{ID: ActionView, Label: "View details"},
 			{ID: ActionDelete, Label: "Delete contact", Danger: true},
 		}
 	case KindOpportunity:
 		return []ItemAction{
-			{ID: ActionView, Label: "View details"},
 			{ID: ActionDelete, Label: "Delete deal", Danger: true},
 		}
 	case KindCase:
 		return []ItemAction{
-			{ID: ActionView, Label: "View details"},
 			{ID: ActionDelete, Label: "Delete case", Danger: true},
 		}
 	case KindMail:
 		return []ItemAction{
-			{ID: ActionView, Label: "Read message"},
 			{ID: ActionDelete, Label: "Delete message", Danger: true},
 		}
 	case KindFile:
 		return []ItemAction{
-			{ID: ActionView, Label: "Preview file"},
 			{ID: ActionDownload, Label: "Download"},
 			{ID: ActionDelete, Label: "Delete file", Danger: true},
 		}
 	case KindEvent, KindCalendar, KindUser:
-		return []ItemAction{{ID: ActionView, Label: "View details"}}
+		return nil
 	default:
-		return []ItemAction{{ID: ActionView, Label: "View details"}}
+		return nil
 	}
 }

cmd/office/model/calendar_display.go

@@ -0,0 +1,40 @@
+package model
+
+import "fmt"
+
+// ClassifyCalendarRow decides whether an API row is a calendar or an event.
+func ClassifyCalendarRow(raw map[string]any) (Kind, string) {
+	if raw == nil {
+		return KindCalendar, "Calendar"
+	}
+	if strRaw(raw, "start") != "" || strRaw(raw, "end") != "" {
+		return KindEvent, "Event"
+	}
+	if strRaw(raw, "eventType") != "" {
+		return KindEvent, "Event"
+	}
+	return KindCalendar, "Calendar"
+}
+
+// CalendarTypeLabel returns the type column text for a calendar list row.
+func CalendarTypeLabel(it Item) string {
+	if it.Raw != nil {
+		if t := strRaw(it.Raw, "type"); t != "" {
+			return t
+		}
+	}
+	_, label := ClassifyCalendarRow(it.Raw)
+	return label
+}
+
+// FormatCalendarDateTime formats start/end timestamps for the calendar table.
+func FormatCalendarDateTime(v any) string {
+	t, ok := parseDeadlineTime(v)
+	if !ok {
+		if s := fmt.Sprint(v); s != "" && s != "<nil>" {
+			return s
+		}
+		return ""
+	}
+	return t.Format("Jan 2 15:04")
+}

cmd/office/model/calendar_display_test.go

@@ -0,0 +1,37 @@
+package model
+
+import "testing"
+
+func TestClassifyCalendarRow(t *testing.T) {
+	kind, label := ClassifyCalendarRow(map[string]any{
+		"title": "Standup",
+		"start": "2026-06-24T10:00:00Z",
+	})
+	if kind != KindEvent || label != "Event" {
+		t.Fatalf("got kind=%s label=%q", kind, label)
+	}
+	kind, label = ClassifyCalendarRow(map[string]any{"title": "Work"})
+	if kind != KindCalendar || label != "Calendar" {
+		t.Fatalf("got kind=%s label=%q", kind, label)
+	}
+}
+
+func TestBuildCalendarColumnsIncludesType(t *testing.T) {
+	items := []Item{{
+		ID: "1", Title: "Meet", Kind: KindEvent,
+		Raw: map[string]any{"type": "Event", "start": "2026-06-24T10:00:00Z"},
+	}}
+	cols := BuildColumns(SubjectCalendar, items)
+	found := false
+	for _, c := range cols {
+		if c.Key == "type" {
+			found = true
+		}
+		if c.Key == "subtitle" {
+			t.Fatal("subtitle column should not appear")
+		}
+	}
+	if !found {
+		t.Fatal("expected type column")
+	}
+}

cmd/office/model/columns.go

@@ -0,0 +1,367 @@
+package model
+
+import (
+	"fmt"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+// TableColumn is one column in the center data table.
+type TableColumn struct {
+	Key   string
+	Title string
+	Width int
+}
+
+var subjectExtraKeys = map[Subject][]string{
+	SubjectTasks:         {"status", "deadline", "responsible"},
+	SubjectCalendars:     {"description"},
+	SubjectEvents:        {"start", "end"},
+	SubjectContacts:      {"primaryEmail", "displayName"},
+	SubjectPersons:       {"primaryEmail", "displayName"},
+	SubjectCompanies:     {"primaryEmail", "displayName"},
+	SubjectOpportunities: {"stage", "bidValue", "bidCurrency"},
+	SubjectCases:         {"status"},
+	SubjectCRMTasks:      {"status", "deadline"},
+	SubjectMailInbox:     {"from", "date"},
+	SubjectMailSent:      {"to", "date"},
+	SubjectMailDrafts:    {"to", "date"},
+	SubjectMailTrash:     {"from", "date"},
+	SubjectMailSpam:      {"from", "date"},
+	SubjectUsers:         {"email", "displayName"},
+}
+
+// BuildColumns derives table columns from the list subject and item payloads.
+func BuildColumns(subject Subject, items []Item) []TableColumn {
+	if subject == SubjectProjects {
+		return buildProjectColumns(items)
+	}
+	if subject == SubjectTasks {
+		return buildTaskColumns(items)
+	}
+	if subject == SubjectCalendar {
+		return buildCalendarColumns(items)
+	}
+	cols := []TableColumn{
+		{Key: "_sel", Title: "✓", Width: 3},
+		{Key: "id", Title: "ID", Width: 10},
+		{Key: "title", Title: "Title", Width: 28},
+	}
+	if hasSubtitle(items) {
+		cols = append(cols, TableColumn{Key: "subtitle", Title: "Subtitle", Width: 22})
+	}
+
+	seen := map[string]bool{"_sel": true, "id": true, "title": true, "subtitle": true}
+	for _, key := range subjectExtraKeys[subject] {
+		if seen[key] || !columnHasData(items, key) {
+			continue
+		}
+		seen[key] = true
+		cols = append(cols, TableColumn{Key: key, Title: titleLabel(key), Width: defaultWidth(key)})
+	}
+
+	discovered := discoverRawKeys(items, seen, 8)
+	for _, key := range discovered {
+		cols = append(cols, TableColumn{Key: key, Title: titleLabel(key), Width: defaultWidth(key)})
+	}
+
+	sizeColumns(cols, items)
+	return cols
+}
+
+func buildCalendarColumns(items []Item) []TableColumn {
+	cols := []TableColumn{
+		{Key: "_sel", Title: "✓", Width: 3},
+		{Key: "id", Title: "ID", Width: 10},
+		{Key: "type", Title: "Type", Width: 10},
+		{Key: "title", Title: "Title", Width: 28},
+	}
+	for _, key := range []string{"start", "end"} {
+		if columnHasData(items, key) {
+			cols = append(cols, TableColumn{Key: key, Title: titleLabel(key), Width: defaultWidth(key)})
+		}
+	}
+	sizeColumns(cols, items)
+	return cols
+}
+
+func buildTaskColumns(items []Item) []TableColumn {
+	cols := []TableColumn{
+		{Key: "_sel", Title: "✓", Width: 3},
+		{Key: "id", Title: "ID", Width: 8},
+		{Key: "title", Title: "Title", Width: 28},
+		{Key: "status", Title: "Status", Width: 10},
+	}
+	for _, key := range []string{"deadline", "responsible"} {
+		if columnHasData(items, key) {
+			cols = append(cols, TableColumn{Key: key, Title: titleLabel(key), Width: defaultWidth(key)})
+		}
+	}
+	sizeColumns(cols, items)
+	return cols
+}
+
+func buildProjectColumns(items []Item) []TableColumn {
+	cols := []TableColumn{
+		{Key: "_sel", Title: "✓", Width: 3},
+		{Key: "id", Title: "ID", Width: 8},
+		{Key: "status", Title: "Status", Width: 8},
+		{Key: "title", Title: "Title", Width: 28},
+		{Key: "tasks", Title: "Tasks (open/closed)", Width: 18},
+		{Key: "documents", Title: "Documents", Width: 11},
+		{Key: "users", Title: "Users", Width: 8},
+	}
+	sizeColumns(cols, items)
+	return cols
+}
+
+// CellText returns the display string for one table cell.
+func CellText(it Item, key string) string {
+	switch key {
+	case "_sel":
+		if it.Selected {
+			return "●"
+		}
+		return "○"
+	case "id":
+		return it.ID
+	case "title":
+		return it.Title
+	case "type":
+		return CalendarTypeLabel(it)
+	case "start", "end":
+		if it.Raw == nil {
+			return ""
+		}
+		if formatted := FormatCalendarDateTime(it.Raw[key]); formatted != "" {
+			return formatted
+		}
+		return formatAny(it.Raw[key])
+	case "status":
+		switch it.Kind {
+		case KindProject:
+			return ProjectStatusLabel(it.Raw)
+		case KindTask, KindCRMTask:
+			if it.Raw == nil {
+				return ""
+			}
+			return TaskStatusLabel(it.Raw["status"])
+		default:
+			if it.Raw == nil {
+				return ""
+			}
+			return formatAny(it.Raw["status"])
+		}
+	case "deadline":
+		if it.Raw == nil {
+			return ""
+		}
+		if rel := FormatRelativeDeadline(it.Raw["deadline"]); rel != "" {
+			return rel
+		}
+		return formatAny(it.Raw["deadline"])
+	case "responsible":
+		if it.Kind == KindTask || it.Kind == KindCRMTask {
+			return TaskResponsibleLabel(it.Raw)
+		}
+		if it.Raw == nil {
+			return ""
+		}
+		return formatAny(it.Raw["responsible"])
+	case "subtitle":
+		return it.Subtitle
+	case "tasks":
+		return formatProjectTasks(it.Raw)
+	case "documents":
+		return intRaw(it.Raw, "documentsCount")
+	case "users":
+		return intRaw(it.Raw, "participantCount")
+	case "kind":
+		return string(it.Kind)
+	default:
+		if it.Raw == nil {
+			return ""
+		}
+		return formatAny(it.Raw[key])
+	}
+}
+
+func formatProjectTasks(raw map[string]any) string {
+	if raw == nil {
+		return "0/0"
+	}
+	open := intRawVal(raw, "taskCount")
+	total := intRawVal(raw, "taskCountTotal")
+	closed := total - open
+	if closed < 0 {
+		closed = 0
+	}
+	return fmt.Sprintf("%d/%d", open, closed)
+}
+
+func intRaw(raw map[string]any, key string) string {
+	if raw == nil {
+		return ""
+	}
+	v := intRawVal(raw, key)
+	if v == 0 {
+		if _, ok := raw[key]; !ok {
+			return ""
+		}
+	}
+	return fmt.Sprintf("%d", v)
+}
+
+func intRawVal(raw map[string]any, key string) int {
+	if raw == nil {
+		return 0
+	}
+	switch v := raw[key].(type) {
+	case int:
+		return v
+	case int64:
+		return int(v)
+	case float64:
+		return int(v)
+	case string:
+		n, _ := strconv.Atoi(v)
+		return n
+	default:
+		if raw[key] == nil {
+			return 0
+		}
+		n, _ := strconv.Atoi(fmt.Sprint(raw[key]))
+		return n
+	}
+}
+
+func hasSubtitle(items []Item) bool {
+	for _, it := range items {
+		if it.Subtitle != "" {
+			return true
+		}
+	}
+	return false
+}
+
+func columnHasData(items []Item, key string) bool {
+	for _, it := range items {
+		if CellText(it, key) != "" {
+			return true
+		}
+	}
+	return false
+}
+
+func discoverRawKeys(items []Item, seen map[string]bool, limit int) []string {
+	counts := map[string]int{}
+	for _, it := range items {
+		if it.Raw == nil {
+			continue
+		}
+		for k := range it.Raw {
+			if seen[k] || k == "id" || k == "title" {
+				continue
+			}
+			counts[k]++
+		}
+	}
+	type kv struct {
+		k string
+		n int
+	}
+	var ranked []kv
+	for k, n := range counts {
+		ranked = append(ranked, kv{k, n})
+	}
+	sort.Slice(ranked, func(i, j int) bool {
+		if ranked[i].n == ranked[j].n {
+			return ranked[i].k < ranked[j].k
+		}
+		return ranked[i].n > ranked[j].n
+	})
+	out := make([]string, 0, limit)
+	for _, r := range ranked {
+		if len(out) >= limit {
+			break
+		}
+		out = append(out, r.k)
+	}
+	return out
+}
+
+func titleLabel(key string) string {
+	if key == "" {
+		return ""
+	}
+	parts := strings.Split(key, "_")
+	for i, p := range parts {
+		if p == "" {
+			continue
+		}
+		parts[i] = strings.ToUpper(p[:1]) + p[1:]
+	}
+	return strings.Join(parts, " ")
+}
+
+func defaultWidth(key string) int {
+	switch key {
+	case "id", "status", "stage":
+		return 10
+	case "start", "end", "deadline", "date":
+		return 20
+	case "from", "to", "email", "primaryEmail":
+		return 22
+	case "description", "displayName":
+		return 24
+	default:
+		return 14
+	}
+}
+
+func sizeColumns(cols []TableColumn, items []Item) {
+	for i := range cols {
+		maxW := runeLen(cols[i].Title)
+		for _, it := range items {
+			n := runeLen(CellText(it, cols[i].Key))
+			if n > maxW {
+				maxW = n
+			}
+		}
+		maxW += 2
+		if maxW < 4 {
+			maxW = 4
+		}
+		if maxW > 36 {
+			maxW = 36
+		}
+		cols[i].Width = maxW
+	}
+}
+
+func runeLen(s string) int {
+	return len([]rune(s))
+}
+
+func formatAny(v any) string {
+	if v == nil {
+		return ""
+	}
+	switch x := v.(type) {
+	case string:
+		return x
+	case bool:
+		if x {
+			return "yes"
+		}
+		return "no"
+	case float64:
+		if x == float64(int64(x)) {
+			return fmt.Sprintf("%d", int64(x))
+		}
+		return fmt.Sprintf("%g", x)
+	default:
+		return fmt.Sprint(v)
+	}
+}

cmd/office/model/columns_test.go

@@ -0,0 +1,66 @@
+package model
+
+import "testing"
+
+func TestBuildProjectColumns(t *testing.T) {
+	items := []Item{{
+		ID: "1", Title: "Alpha", Kind: KindProject,
+		Raw: map[string]any{
+			"taskCount": 3, "taskCountTotal": 5,
+			"documentsCount": 2, "participantCount": 4,
+		},
+	}}
+	cols := BuildColumns(SubjectProjects, items)
+	want := []string{"_sel", "id", "status", "title", "tasks", "documents", "users"}
+	if len(cols) != len(want) {
+		t.Fatalf("got %d columns, want %d", len(cols), len(want))
+	}
+	for i, key := range want {
+		if cols[i].Key != key {
+			t.Fatalf("col[%d]=%q want %q", i, cols[i].Key, key)
+		}
+	}
+	for _, c := range cols {
+		if c.Key == "subtitle" {
+			t.Fatalf("unexpected column %q", c.Key)
+		}
+	}
+}
+
+func TestCellTextProjectStatus(t *testing.T) {
+	open := Item{Kind: KindProject, Raw: map[string]any{"status": 0}}
+	if got := CellText(open, "status"); got != "Open" {
+		t.Fatalf("got %q", got)
+	}
+	closed := Item{Kind: KindProject, Raw: map[string]any{"status": 2}}
+	if got := CellText(closed, "status"); got != "Closed" {
+		t.Fatalf("got %q", got)
+	}
+}
+
+func TestFormatProjectTasksOpenClosed(t *testing.T) {
+	raw := map[string]any{"taskCount": 3, "taskCountTotal": 8}
+	if got := formatProjectTasks(raw); got != "3/5" {
+		t.Fatalf("got %q want 3/5", got)
+	}
+}
+
+func TestCellTextProjectDocumentsUsers(t *testing.T) {
+	it := Item{Raw: map[string]any{"documentsCount": 7, "participantCount": 2}}
+	if got := CellText(it, "documents"); got != "7" {
+		t.Fatalf("documents: %q", got)
+	}
+	if got := CellText(it, "users"); got != "2" {
+		t.Fatalf("users: %q", got)
+	}
+}
+
+func TestBuildColumnsIncludesSelectionAndCoreFields(t *testing.T) {
+	items := []Item{
+		{ID: "1", Title: "Alpha", Kind: KindTask, Raw: map[string]any{"status": "Open"}},
+	}
+	cols := BuildColumns(SubjectTasks, items)
+	if cols[0].Key != "_sel" {
+		t.Fatalf("first column should be selection, got %q", cols[0].Key)
+	}
+}

cmd/office/model/filter.go

@@ -0,0 +1,34 @@
+package model
+
+import (
+	"strings"
+)
+
+// FilterItems returns items whose searchable text contains query (case-insensitive).
+func FilterItems(items []Item, query string) []Item {
+	q := strings.ToLower(strings.TrimSpace(query))
+	if q == "" {
+		out := make([]Item, len(items))
+		copy(out, items)
+		return out
+	}
+	out := make([]Item, 0, len(items))
+	for _, it := range items {
+		if strings.Contains(strings.ToLower(ItemSearchText(it)), q) {
+			out = append(out, it)
+		}
+	}
+	return out
+}
+
+// ItemSearchText joins item fields used for list filtering.
+func ItemSearchText(it Item) string {
+	var parts []string
+	parts = append(parts, it.ID, it.Title, it.Subtitle, string(it.Kind))
+	if it.Raw != nil {
+		for _, v := range it.Raw {
+			parts = append(parts, formatAny(v))
+		}
+	}
+	return strings.Join(parts, " ")
+}

cmd/office/model/filter_test.go

@@ -0,0 +1,26 @@
+package model_test
+
+import (
+	"testing"
+
+	"github.com/eslider/go-onlyoffice/cmd/office/model"
+)
+
+func TestFilterItemsByTitle(t *testing.T) {
+	items := []model.Item{
+		{ID: "1", Title: "Alpha task"},
+		{ID: "2", Title: "Beta task"},
+	}
+	got := model.FilterItems(items, "alpha")
+	if len(got) != 1 || got[0].ID != "1" {
+		t.Fatalf("got %#v", got)
+	}
+}
+
+func TestFilterItemsEmptyQueryReturnsAll(t *testing.T) {
+	items := []model.Item{{ID: "1", Title: "A"}, {ID: "2", Title: "B"}}
+	got := model.FilterItems(items, "  ")
+	if len(got) != 2 {
+		t.Fatalf("got len=%d want 2", len(got))
+	}
+}

cmd/office/model/formfields.go

@@ -0,0 +1,145 @@
+package model
+
+import "fmt"
+
+// FormFields holds editable/display fields loaded from API detail.
+type FormFields struct {
+	PrimaryLabel   string
+	SecondaryLabel string
+	Primary        string
+	Secondary      string
+	ReadOnly       bool
+	HasStatus      bool
+	Status         ProjectLifecycle
+	ResponsibleID  string
+}
+
+// KindHeading returns a short label for the detail pane header.
+func KindHeading(kind Kind, id string) string {
+	return fmt.Sprintf("%s %s", kindLabel(kind), id)
+}
+
+func kindLabel(kind Kind) string {
+	switch kind {
+	case KindProject:
+		return "Project"
+	case KindTask:
+		return "Task"
+	case KindCRMTask:
+		return "CRM task"
+	case KindContact:
+		return "Contact"
+	case KindOpportunity:
+		return "Deal"
+	case KindCase:
+		return "Case"
+	case KindMail:
+		return "Mail"
+	case KindEvent:
+		return "Event"
+	case KindCalendar:
+		return "Calendar"
+	case KindFile:
+		return "Document"
+	case KindUser:
+		return "User"
+	default:
+		return string(kind)
+	}
+}
+
+// FormFieldsFromRaw maps API detail JSON to form fields for the right pane.
+func FormFieldsFromRaw(kind Kind, raw map[string]any) FormFields {
+	switch kind {
+	case KindMail:
+		body := strRaw(raw, "body")
+		if body == "" {
+			body = strRaw(raw, "htmlBody")
+		}
+		return FormFields{
+			PrimaryLabel: "Subject", SecondaryLabel: "Body",
+			Primary: strRaw(raw, "subject"), Secondary: body,
+			ReadOnly: true,
+		}
+	case KindUser:
+		return FormFields{
+			PrimaryLabel: "Name", SecondaryLabel: "Email",
+			Primary: strRaw(raw, "displayName"), Secondary: strRaw(raw, "email"),
+			ReadOnly: true,
+		}
+	case KindContact:
+		name := strRaw(raw, "displayName")
+		if name == "" {
+			name = strRaw(raw, "title")
+		}
+		return FormFields{
+			PrimaryLabel: "Name", SecondaryLabel: "About",
+			Primary: name, Secondary: strRaw(raw, "about"),
+			ReadOnly: true,
+		}
+	case KindEvent, KindCalendar:
+		return FormFields{
+			PrimaryLabel: "Title", SecondaryLabel: "Description",
+			Primary: strRaw(raw, "title"), Secondary: strRaw(raw, "description"),
+			ReadOnly: true,
+		}
+	case KindProject:
+		title := strRaw(raw, "title")
+		if title == "" {
+			title = strRaw(raw, "name")
+		}
+		return FormFields{
+			PrimaryLabel:   "Title",
+			SecondaryLabel: "Description",
+			Primary:        title,
+			Secondary:      strRaw(raw, "description"),
+			ReadOnly:       false,
+			HasStatus:      true,
+			Status:         ProjectStatusFromAny(raw["status"]),
+			ResponsibleID:  ResponsibleIDFromRaw(raw),
+		}
+	default:
+		title := strRaw(raw, "title")
+		if title == "" {
+			title = strRaw(raw, "name")
+		}
+		if title == "" {
+			title = strRaw(raw, "subject")
+		}
+		return FormFields{
+			PrimaryLabel: "Title", SecondaryLabel: "Description",
+			Primary: title, Secondary: strRaw(raw, "description"),
+			ReadOnly: kind != KindTask && kind != KindProject,
+		}
+	}
+}
+
+func strRaw(m map[string]any, key string) string {
+	if m == nil {
+		return ""
+	}
+	if v, ok := m[key].(string); ok {
+		return v
+	}
+	if m[key] == nil {
+		return ""
+	}
+	return fmt.Sprint(m[key])
+}
+
+// ResponsibleIDFromRaw extracts the project responsible user id from API detail.
+func ResponsibleIDFromRaw(raw map[string]any) string {
+	if id := strRaw(raw, "responsibleId"); id != "" {
+		return id
+	}
+	resp, ok := raw["responsible"].(map[string]any)
+	if !ok {
+		return ""
+	}
+	return strRaw(resp, "id")
+}
+
+// IsDocumentKind is true when the right pane should show rendered preview content, not an editable form.
+func IsDocumentKind(kind Kind) bool {
+	return kind == KindFile || kind == KindMail
+}

cmd/office/model/formfields_test.go

@@ -0,0 +1,23 @@
+package model
+
+import "testing"
+
+func TestFormFieldsFromRawMail(t *testing.T) {
+	raw := map[string]any{"subject": "Hi", "body": "Hello"}
+	f := FormFieldsFromRaw(KindMail, raw)
+	if f.Primary != "Hi" || f.Secondary != "Hello" || !f.ReadOnly {
+		t.Fatalf("unexpected mail fields: %+v", f)
+	}
+}
+
+func TestIsDocumentKind(t *testing.T) {
+	if !IsDocumentKind(KindFile) {
+		t.Fatal("file should be document")
+	}
+	if !IsDocumentKind(KindMail) {
+		t.Fatal("mail should be document preview")
+	}
+	if IsDocumentKind(KindTask) {
+		t.Fatal("task should be form")
+	}
+}

cmd/office/model/item.go

@@ -39,8 +39,19 @@ const (
 	SubjectProjectFiles  Subject = "project_files"
 	SubjectTaskFiles     Subject = "task_files"
 	SubjectUsers         Subject = "users"
+	SubjectCalendar      Subject = "calendar"
 )
 
+// SubjectIsMail reports whether a list subject loads mailbox messages.
+func SubjectIsMail(s Subject) bool {
+	switch s {
+	case SubjectMailInbox, SubjectMailSent, SubjectMailDrafts, SubjectMailTrash, SubjectMailSpam:
+		return true
+	default:
+		return false
+	}
+}
+
 // FocusPane is which column has keyboard focus.
 type FocusPane int
 

cmd/office/model/item_mail_test.go

@@ -0,0 +1,12 @@
+package model
+
+import "testing"
+
+func TestSubjectIsMail(t *testing.T) {
+	if !SubjectIsMail(SubjectMailInbox) {
+		t.Fatal("inbox should be mail")
+	}
+	if SubjectIsMail(SubjectProjects) {
+		t.Fatal("projects should not be mail")
+	}
+}

cmd/office/model/nav.go

@@ -1,5 +1,7 @@
 package model
 
+import "strings"
+
 // ListSpec tells the fetch layer what to load when a nav leaf is active.
 type ListSpec struct {
 	Subject   Subject
@@ -24,6 +26,7 @@ type NavTree struct {
 	expanded map[string]bool
 	cursor   int
 	visible  []string
+	filter   string
 }
 
 // DefaultNavTree returns the OnlyOffice module tree (static skeleton).
@@ -42,15 +45,11 @@ func DefaultNavTree() *NavTree {
 		}
 	}
 
-	add("projects", "Projects", "", true, nil)
-	add("projects.browse", "Browse", "projects", true, nil)
-	add("projects.browse.all", "All projects", "projects.browse", false, &ListSpec{Subject: SubjectProjects})
-	add("projects.browse.tasks", "All tasks", "projects.browse", false, &ListSpec{Subject: SubjectTasks})
-	add("projects.dynamic", "By project", "projects", true, nil)
+	add("projects", "Projects", "", false, &ListSpec{Subject: SubjectProjects})
+	add("tasks", "Tasks", "", false, &ListSpec{Subject: SubjectTasks})
+	add("projects.dynamic", "By project", "", true, nil)
 
-	add("calendar", "Calendar", "", true, nil)
-	add("calendar.cals", "Calendars", "calendar", false, &ListSpec{Subject: SubjectCalendars})
-	add("calendar.events", "Events", "calendar", false, &ListSpec{Subject: SubjectEvents})
+	add("calendar", "Calendar", "", false, &ListSpec{Subject: SubjectCalendar})
 
 	add("crm", "CRM", "", true, nil)
 	add("crm.contacts", "Contacts", "crm", false, &ListSpec{Subject: SubjectContacts})
@@ -185,20 +184,66 @@ func (t *NavTree) Activate() (*ListSpec, bool) {
 	return nil, false
 }
 
+func (t *NavTree) SetFilter(query string) {
+	t.filter = strings.ToLower(strings.TrimSpace(query))
+	t.rebuildVisible()
+}
+
+func (t *NavTree) ClearFilter() {
+	t.filter = ""
+	t.rebuildVisible()
+}
+
+func (t *NavTree) FilterQuery() string { return t.filter }
+
+func (t *NavTree) nodeLabelMatches(id string) bool {
+	if t.filter == "" {
+		return true
+	}
+	n, ok := t.nodes[id]
+	if !ok {
+		return false
+	}
+	return strings.Contains(strings.ToLower(n.Label), t.filter)
+}
+
+func (t *NavTree) hasMatchingDescendant(id string) bool {
+	for _, child := range t.children[id] {
+		if t.nodeLabelMatches(child) || t.hasMatchingDescendant(child) {
+			return true
+		}
+	}
+	return false
+}
+
+func (t *NavTree) visibleUnderFilter(id string) bool {
+	if t.filter == "" {
+		return true
+	}
+	return t.nodeLabelMatches(id) || t.hasMatchingDescendant(id)
+}
+
 func (t *NavTree) rebuildVisible() {
 	t.visible = t.visible[:0]
-	var walk func(id string, depth int)
-	walk = func(id string, depth int) {
+	var walk func(id string)
+	walk = func(id string) {
+		if !t.visibleUnderFilter(id) {
+			return
+		}
 		t.visible = append(t.visible, id)
-		if !t.expanded[id] {
+		expanded := t.expanded[id]
+		if t.filter != "" && t.hasMatchingDescendant(id) {
+			expanded = true
+		}
+		if !expanded {
 			return
 		}
 		for _, child := range t.children[id] {
-			walk(child, depth+1)
+			walk(child)
 		}
 	}
 	for _, root := range t.roots {
-		walk(root, 0)
+		walk(root)
 	}
 	if t.cursor >= len(t.visible) {
 		t.cursor = len(t.visible) - 1

cmd/office/model/nav_test.go

@@ -9,7 +9,7 @@ import (
 func TestNavTreeHasExpectedRoots(t *testing.T) {
 	tree := model.DefaultNavTree()
 	roots := tree.RootLabels()
-	want := []string{"Projects", "Calendar", "CRM", "Mail", "Users"}
+	want := []string{"Projects", "Tasks", "By project", "Calendar", "CRM", "Mail", "Users"}
 	if len(roots) != len(want) {
 		t.Fatalf("roots=%v want %v", roots, want)
 	}
@@ -22,42 +22,79 @@ func TestNavTreeHasExpectedRoots(t *testing.T) {
 
 func TestNavExpandCollapse(t *testing.T) {
 	tree := model.DefaultNavTree()
-	if !tree.IsExpandable(0) {
-		t.Fatal("Projects should be expandable")
+	var crm int = -1
+	for i := 0; i < tree.VisibleCount(); i++ {
+		n, ok := tree.NodeAtVisible(i)
+		if ok && n.Label == "CRM" {
+			crm = i
+			break
 		}
-	tree.ToggleExpand(0)
-	if !tree.IsExpanded(0) {
-		t.Fatal("Projects should expand")
 	}
-	tree.ToggleExpand(0)
-	if tree.IsExpanded(0) {
-		t.Fatal("Projects should collapse")
+	if crm < 0 {
+		t.Fatal("CRM node not found")
+	}
+	if !tree.IsExpandable(crm) {
+		t.Fatal("CRM should be expandable")
+	}
+	tree.ToggleExpand(crm)
+	if !tree.IsExpanded(crm) {
+		t.Fatal("CRM should expand")
+	}
+	tree.ToggleExpand(crm)
+	if tree.IsExpanded(crm) {
+		t.Fatal("CRM should collapse")
 	}
 }
 
-func TestNavLeafReturnsListSpec(t *testing.T) {
+func TestNavCalendarLeafReturnsListSpec(t *testing.T) {
 	tree := model.DefaultNavTree()
-	tree.ToggleExpand(0) // Projects
-	tree.ToggleExpand(1) // Browse
-	// Find "All projects" leaf cursor
 	var found int = -1
 	for i := 0; i < tree.VisibleCount(); i++ {
 		n, ok := tree.NodeAtVisible(i)
-		if ok && n.List != nil && n.List.Subject == model.SubjectProjects {
+		if ok && n.Label == "Calendar" {
 			found = i
 			break
 		}
 	}
 	if found < 0 {
-		t.Fatal("all projects leaf not found")
+		t.Fatal("Calendar node not found")
 	}
 	tree.SetCursor(found)
 	spec, ok := tree.CurrentListSpec()
-	if !ok || spec.Subject != model.SubjectProjects {
+	if !ok || spec.Subject != model.SubjectCalendar {
 		t.Fatalf("spec=%v ok=%v", spec, ok)
 	}
 }
 
+func TestNavProjectsLeafReturnsListSpec(t *testing.T) {
+	tree := model.DefaultNavTree()
+	tree.SetCursor(0)
+	spec, ok := tree.CurrentListSpec()
+	if !ok || spec.Subject != model.SubjectProjects {
+		t.Fatalf("projects spec=%v ok=%v", spec, ok)
+	}
+}
+
+func TestNavTasksLeafReturnsListSpec(t *testing.T) {
+	tree := model.DefaultNavTree()
+	var found int = -1
+	for i := 0; i < tree.VisibleCount(); i++ {
+		n, ok := tree.NodeAtVisible(i)
+		if ok && n.Label == "Tasks" {
+			found = i
+			break
+		}
+	}
+	if found < 0 {
+		t.Fatal("Tasks node not found")
+	}
+	tree.SetCursor(found)
+	spec, ok := tree.CurrentListSpec()
+	if !ok || spec.Subject != model.SubjectTasks {
+		t.Fatalf("tasks spec=%v ok=%v", spec, ok)
+	}
+}
+
 func TestPrevFocusPane(t *testing.T) {
 	if got := model.PrevFocusPane(model.FocusList); got != model.FocusMenu {
 		t.Fatalf("got %v", got)
@@ -67,9 +104,44 @@ func TestPrevFocusPane(t *testing.T) {
 	}
 }
 
+func TestNavFilterByLabel(t *testing.T) {
+	tree := model.DefaultNavTree()
+	tree.SetFilter("inbox")
+	found := false
+	for i := 0; i < tree.VisibleCount(); i++ {
+		n, ok := tree.NodeAtVisible(i)
+		if ok && n.Label == "Inbox" {
+			found = true
+			break
+		}
+	}
+	if !found {
+		t.Fatal("Inbox should remain visible when filtering mail")
+	}
+	for i := 0; i < tree.VisibleCount(); i++ {
+		n, ok := tree.NodeAtVisible(i)
+		if ok && n.Label == "Calendar" {
+			t.Fatal("Calendar should be hidden when filtering inbox")
+		}
+	}
+}
+
+func TestNavClearFilterRestoresTree(t *testing.T) {
+	tree := model.DefaultNavTree()
+	before := tree.VisibleCount()
+	tree.SetFilter("zzz-no-match")
+	if tree.VisibleCount() >= before {
+		t.Fatalf("filter should shrink visible nodes")
+	}
+	tree.ClearFilter()
+	if tree.VisibleCount() != before {
+		t.Fatalf("clear filter should restore visible count")
+	}
+}
+
 func TestActionsForContact(t *testing.T) {
 	acts := model.ActionsFor(model.KindContact)
-	if len(acts) < 2 {
-		t.Fatalf("expected view+delete, got %d", len(acts))
+	if len(acts) != 1 || acts[0].ID != model.ActionDelete {
+		t.Fatalf("expected delete only, got %v", acts)
 	}
 }

cmd/office/model/project_status.go

@@ -0,0 +1,85 @@
+package model
+
+// ProjectLifecycle is the OnlyOffice project status string accepted by the API.
+type ProjectLifecycle string
+
+const (
+	ProjectLifecycleOpen   ProjectLifecycle = "open"
+	ProjectLifecyclePaused ProjectLifecycle = "paused"
+	ProjectLifecycleClosed ProjectLifecycle = "closed"
+)
+
+// ProjectStatusFromAny maps API status (int or string) to a lifecycle value.
+func ProjectStatusFromAny(v any) ProjectLifecycle {
+	switch x := v.(type) {
+	case string:
+		switch ProjectLifecycle(x) {
+		case ProjectLifecycleOpen, ProjectLifecyclePaused, ProjectLifecycleClosed:
+			return ProjectLifecycle(x)
+		}
+	case float64:
+		return projectStatusFromInt(int(x))
+	case int:
+		return projectStatusFromInt(x)
+	case int64:
+		return projectStatusFromInt(int(x))
+	}
+	return ProjectLifecycleOpen
+}
+
+func projectStatusFromInt(n int) ProjectLifecycle {
+	switch n {
+	case 1:
+		return ProjectLifecyclePaused
+	case 2:
+		return ProjectLifecycleClosed
+	default:
+		return ProjectLifecycleOpen
+	}
+}
+
+// ProjectStatusLabel returns a short UI label for list cells.
+func ProjectStatusLabel(raw map[string]any) string {
+	if raw == nil {
+		return "Open"
+	}
+	return ProjectStatusFromAny(raw["status"]).Label()
+}
+
+// ProjectIsOpen is true when the project is not closed.
+func ProjectIsOpen(raw map[string]any) bool {
+	if raw == nil {
+		return true
+	}
+	return ProjectStatusFromAny(raw["status"]) != ProjectLifecycleClosed
+}
+
+// Label returns a human-readable status name.
+func (s ProjectLifecycle) Label() string {
+	switch s {
+	case ProjectLifecycleClosed:
+		return "Closed"
+	case ProjectLifecyclePaused:
+		return "Paused"
+	default:
+		return "Open"
+	}
+}
+
+// ToggleOpenClosed flips between open and closed (paused maps to closed on toggle).
+func (s ProjectLifecycle) ToggleOpenClosed() ProjectLifecycle {
+	if s == ProjectLifecycleClosed {
+		return ProjectLifecycleOpen
+	}
+	return ProjectLifecycleClosed
+}
+
+// Next cycles open → closed → open for keyboard toggling.
+func (s ProjectLifecycle) Next() ProjectLifecycle {
+	return s.ToggleOpenClosed()
+}
+
+// Prev cycles closed → open → closed.
+func (s ProjectLifecycle) Prev() ProjectLifecycle {
+	return s.ToggleOpenClosed()
+}

cmd/office/model/project_status_test.go

@@ -0,0 +1,26 @@
+package model_test
+
+import (
+	"testing"
+
+	"github.com/eslider/go-onlyoffice/cmd/office/model"
+)
+
+func TestProjectStatusFromInt(t *testing.T) {
+	if got := model.ProjectStatusFromAny(2); got != model.ProjectLifecycleClosed {
+		t.Fatalf("got %q", got)
+	}
+	if got := model.ProjectStatusFromAny(0); got != model.ProjectLifecycleOpen {
+		t.Fatalf("got %q", got)
+	}
+}
+
+func TestProjectStatusToggle(t *testing.T) {
+	s := model.ProjectLifecycleOpen
+	if s.Next() != model.ProjectLifecycleClosed {
+		t.Fatal("expected closed")
+	}
+	if s.Next().Prev() != model.ProjectLifecycleOpen {
+		t.Fatal("expected open after toggle back")
+	}
+}

cmd/office/model/task_display.go

@@ -0,0 +1,185 @@
+package model
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// TaskStatusLabel returns a human-readable project/CRM task status.
+func TaskStatusLabel(v any) string {
+	if v == nil {
+		return ""
+	}
+	if s, ok := v.(string); ok {
+		if label := taskStatusFromString(s); label != "" {
+			return label
+		}
+	}
+	n := intRawVal(map[string]any{"status": v}, "status")
+	switch n {
+	case 0:
+		return "Not accepted"
+	case 1:
+		return "Open"
+	case 2:
+		return "Closed"
+	case 3:
+		return "Disabled"
+	case 4:
+		return "Unclassified"
+	case 5:
+		return "Not in milestone"
+	default:
+		if s := fmt.Sprint(v); s != "" && s != "<nil>" {
+			return s
+		}
+		return ""
+	}
+}
+
+func taskStatusFromString(s string) string {
+	switch strings.ToLower(strings.TrimSpace(s)) {
+	case "open":
+		return "Open"
+	case "closed":
+		return "Closed"
+	case "notaccept", "not accept", "not accepted":
+		return "Not accepted"
+	case "disable", "disabled":
+		return "Disabled"
+	case "unclassified":
+		return "Unclassified"
+	case "notinmilestone", "not in milestone":
+		return "Not in milestone"
+	default:
+		return ""
+	}
+}
+
+// FormatRelativeDeadline formats a deadline as "in 2 hours" or "3 days ago".
+func FormatRelativeDeadline(v any) string {
+	return FormatRelativeDeadlineAt(v, time.Now())
+}
+
+// FormatRelativeDeadlineAt is FormatRelativeDeadline with a fixed clock (for tests).
+func FormatRelativeDeadlineAt(v any, now time.Time) string {
+	t, ok := parseDeadlineTime(v)
+	if !ok {
+		return ""
+	}
+	return relativeTimePhrase(now, t)
+}
+
+func relativeTimePhrase(now, target time.Time) string {
+	d := target.Sub(now)
+	future := d >= 0
+	if !future {
+		d = -d
+	}
+	phrase := func(n int, unit string) string {
+		if n == 1 {
+			unit = strings.TrimSuffix(unit, "s")
+		}
+		if future {
+			return fmt.Sprintf("in %d %s", n, unit)
+		}
+		return fmt.Sprintf("%d %s ago", n, unit)
+	}
+	switch {
+	case d < time.Minute:
+		if future {
+			return "in 1 minute"
+		}
+		return "just now"
+	case d < time.Hour:
+		return phrase(int(d.Round(time.Minute)/time.Minute), "minutes")
+	case d < 24*time.Hour:
+		return phrase(int(d.Round(time.Hour)/time.Hour), "hours")
+	default:
+		return phrase(int(d.Round(24*time.Hour)/(24*time.Hour)), "days")
+	}
+}
+
+func parseDeadlineTime(v any) (time.Time, bool) {
+	if v == nil {
+		return time.Time{}, false
+	}
+	switch x := v.(type) {
+	case time.Time:
+		return x, true
+	case string:
+		s := strings.TrimSpace(x)
+		if s == "" {
+			return time.Time{}, false
+		}
+		formats := []string{
+			time.RFC3339Nano,
+			"2006-01-02T15:04:05.0000000-07:00",
+			"2006-01-02T15:04:05-07:00",
+			"2006-01-02T15:04:05",
+			"2006-01-02",
+		}
+		for _, layout := range formats {
+			if t, err := time.Parse(layout, s); err == nil {
+				return t, true
+			}
+		}
+		return time.Time{}, false
+	case float64:
+		return time.Unix(int64(x), 0), true
+	case int64:
+		return time.Unix(x, 0), true
+	case int:
+		return time.Unix(int64(x), 0), true
+	default:
+		return parseDeadlineTime(fmt.Sprint(v))
+	}
+}
+
+// TaskResponsibleLabel returns the assignee display name when present.
+func TaskResponsibleLabel(raw map[string]any) string {
+	if raw == nil {
+		return ""
+	}
+	if name := personName(raw["responsible"]); name != "" {
+		return name
+	}
+	if list, ok := raw["responsibles"].([]any); ok {
+		names := make([]string, 0, len(list))
+		for _, entry := range list {
+			if name := personName(entry); name != "" {
+				names = append(names, name)
+			}
+		}
+		if len(names) > 0 {
+			return strings.Join(names, ", ")
+		}
+	}
+	if s := strRaw(raw, "responsible"); s != "" && !looksLikeID(s) {
+		return s
+	}
+	return ""
+}
+
+func personName(v any) string {
+	m, ok := v.(map[string]any)
+	if !ok {
+		return ""
+	}
+	if name := strRaw(m, "displayName"); name != "" {
+		return name
+	}
+	first := strRaw(m, "firstName")
+	last := strRaw(m, "lastName")
+	return strings.TrimSpace(first + " " + last)
+}
+
+func looksLikeID(s string) bool {
+	if len(s) == 36 && strings.Count(s, "-") == 4 {
+		return true
+	}
+	_, err := strconv.Atoi(s)
+	return err == nil
+}

cmd/office/model/task_display_test.go

@@ -0,0 +1,49 @@
+package model
+
+import (
+	"testing"
+	"time"
+)
+
+func TestTaskStatusLabelFromInt(t *testing.T) {
+	if got := TaskStatusLabel(1); got != "Open" {
+		t.Fatalf("got %q", got)
+	}
+	if got := TaskStatusLabel(2); got != "Closed" {
+		t.Fatalf("got %q", got)
+	}
+}
+
+func TestFormatRelativeDeadlineFuture(t *testing.T) {
+	now := time.Date(2026, 6, 24, 12, 0, 0, 0, time.UTC)
+	deadline := now.Add(2 * time.Hour)
+	got := FormatRelativeDeadlineAt(deadline.Format(time.RFC3339), now)
+	if got != "in 2 hours" {
+		t.Fatalf("got %q", got)
+	}
+}
+
+func TestFormatRelativeDeadlineDays(t *testing.T) {
+	now := time.Date(2026, 6, 24, 12, 0, 0, 0, time.UTC)
+	deadline := now.Add(26 * time.Hour)
+	got := FormatRelativeDeadlineAt(deadline.Format(time.RFC3339), now)
+	if got != "in 1 day" {
+		t.Fatalf("got %q", got)
+	}
+}
+
+func TestBuildTaskColumnsOmitsSubtitle(t *testing.T) {
+	items := []Item{{
+		ID: "1", Title: "Fix bug", Kind: KindTask, Subtitle: "1",
+		Raw: map[string]any{"status": 1, "deadline": "2026-06-25T12:00:00Z"},
+	}}
+	cols := BuildColumns(SubjectTasks, items)
+	for _, c := range cols {
+		if c.Key == "subtitle" {
+			t.Fatalf("unexpected subtitle column")
+		}
+	}
+	if CellText(items[0], "status") != "Open" {
+		t.Fatalf("status not humanized")
+	}
+}

cmd/office/preview/entity.go

@@ -42,25 +42,71 @@ func OpportunityMarkdown(m map[string]any) string {
 	return strings.TrimSpace(b.String()) + "\n"
 }
 
-// MailMarkdown formats a mail message for preview.
+// MailMarkdown formats a mail message for terminal preview (HTML body is converted to markdown).
 func MailMarkdown(m map[string]any) string {
 	var b strings.Builder
 	fmt.Fprintf(&b, "# %s\n\n", str(m, "subject"))
-	fmt.Fprintf(&b, "**From:** %s\n\n", str(m, "from"))
-	if to := str(m, "to"); to != "" {
+	fmt.Fprintf(&b, "**From:** %s\n\n", mailAddressLine(m, "from"))
+	if to := mailAddressLine(m, "to"); to != "" {
 		fmt.Fprintf(&b, "**To:** %s\n\n", to)
 	}
-	body := str(m, "body")
-	if body == "" {
-		body = str(m, "htmlBody")
+	if cc := mailAddressLine(m, "cc"); cc != "" {
+		fmt.Fprintf(&b, "**Cc:** %s\n\n", cc)
 	}
-	body = stripHTML(body)
-	if body != "" {
-		fmt.Fprintf(&b, "## Body\n\n%s\n\n", body)
+	if date := str(m, "date"); date != "" {
+		fmt.Fprintf(&b, "**Date:** %s\n\n", date)
+	}
+	if body := mailBodyMarkdown(m); body != "" {
+		fmt.Fprintf(&b, "---\n\n%s\n", body)
 	}
 	return strings.TrimSpace(b.String()) + "\n"
 }
 
+func mailAddressLine(m map[string]any, key string) string {
+	if v := str(m, key); v != "" {
+		return v
+	}
+	name := str(m, key+"Name")
+	addr := str(m, key+"Address")
+	switch {
+	case name != "" && addr != "":
+		return fmt.Sprintf("%s <%s>", name, addr)
+	case addr != "":
+		return addr
+	default:
+		return name
+	}
+}
+
+func mailBodyMarkdown(m map[string]any) string {
+	htmlBody := strings.TrimSpace(str(m, "htmlBody"))
+	plainBody := strings.TrimSpace(str(m, "body"))
+
+	for _, candidate := range []string{htmlBody, plainBody} {
+		if candidate == "" {
+			continue
+		}
+		if looksLikeHTML(candidate) {
+			if md, err := HTMLToMarkdown(candidate); err == nil {
+				if md = strings.TrimSpace(md); md != "" {
+					return md
+				}
+			}
+		}
+	}
+	if plainBody != "" {
+		return plainBody
+	}
+	if htmlBody != "" {
+		return stripHTML(htmlBody)
+	}
+	return ""
+}
+
+func looksLikeHTML(s string) bool {
+	return strings.Contains(s, "<") && strings.Contains(s, ">") && htmlTagRe.MatchString(s)
+}
+
 // EventMarkdown formats a calendar event for preview.
 func EventMarkdown(m map[string]any) string {
 	var b strings.Builder

cmd/office/preview/entity_test.go

@@ -0,0 +1,58 @@
+package preview_test
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/eslider/go-onlyoffice/cmd/office/preview"
+)
+
+func TestMailMarkdownConvertsHTMLBody(t *testing.T) {
+	raw := map[string]any{
+		"subject":  "Weekly update",
+		"from":     `"Team" <team@example.com>`,
+		"htmlBody": `<p>Hello <strong>world</strong></p><p><a href="https://example.com">Link</a></p>`,
+	}
+	md := preview.MailMarkdown(raw)
+	if !strings.Contains(md, "Weekly update") {
+		t.Fatalf("missing subject:\n%s", md)
+	}
+	if !strings.Contains(md, "team@example.com") {
+		t.Fatalf("missing from:\n%s", md)
+	}
+	if strings.Contains(md, "<strong>") || strings.Contains(md, "<p>") {
+		t.Fatalf("expected HTML converted, got raw tags:\n%s", md)
+	}
+	if !strings.Contains(md, "world") {
+		t.Fatalf("missing body text:\n%s", md)
+	}
+}
+
+func TestMailMarkdownRendersWithColor(t *testing.T) {
+	md := preview.MailMarkdown(map[string]any{
+		"subject":  "Styled",
+		"from":     "a@b.com",
+		"htmlBody": `<h2>Heading</h2><p>Plain text</p>`,
+	})
+	out, err := preview.RenderMarkdown(md, 60)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.TrimSpace(out) == "" {
+		t.Fatal("empty render output")
+	}
+	if !strings.Contains(out, "Heading") || !strings.Contains(out, "Plain text") {
+		t.Fatalf("missing rendered content:\n%s", out)
+	}
+}
+
+func TestMailMarkdownPlainBodyFallback(t *testing.T) {
+	md := preview.MailMarkdown(map[string]any{
+		"subject": "Hi",
+		"from":    "a@b.com",
+		"body":    "Just plain text",
+	})
+	if !strings.Contains(md, "Just plain text") {
+		t.Fatalf("missing plain body:\n%s", md)
+	}
+}

cmd/office/preview/preview_integration_test.go

@@ -119,7 +119,7 @@ func TestIntegrationPreviewMailFromAPI(t *testing.T) {
 
 func TestIntegrationPreviewEventFromAPI(t *testing.T) {
 	loader, ctx := liveLoader(t)
-	items, err := loader.List(ctx, model.ListSpec{Subject: model.SubjectEvents})
+	items, err := loader.List(ctx, model.ListSpec{Subject: model.SubjectCalendar})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -151,6 +151,31 @@ func TestIntegrationPreviewTaskFromAPI(t *testing.T) {
 	}
 }
 
+func TestIntegrationPreviewFileFromAPI(t *testing.T) {
+	skipWithoutLiveAPI(t)
+	if os.Getenv("ONLYOFFICE_PROJECT_ID") == "" {
+		t.Skip("ONLYOFFICE_PROJECT_ID not set")
+	}
+	loader, ctx := liveLoader(t)
+	items, err := loader.List(ctx, model.ListSpec{Subject: model.SubjectProjectFiles})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(items) == 0 {
+		t.Skip("no project files")
+	}
+	md, err := loader.PreviewMarkdown(ctx, items[0])
+	if err != nil {
+		t.Fatalf("PreviewMarkdown: %v", err)
+	}
+	if md == "" {
+		t.Fatal("empty preview")
+	}
+	if !strings.Contains(md, items[0].Title) && !strings.Contains(md, "|") && !strings.Contains(md, "```") {
+		t.Fatalf("unexpected file preview for %q:\n%s", items[0].Title, md)
+	}
+}
+
 func TestIntegrationPreviewCSVFromDownloadedFile(t *testing.T) {
 	skipWithoutLiveAPI(t)
 	if os.Getenv("ONLYOFFICE_PROJECT_ID") == "" {

cmd/office/ui/app_test.go

@@ -17,26 +17,29 @@ func TestKeyActionShiftTabPrevPane(t *testing.T) {
 	if got := ui.KeyAction("shift+tab", model.FocusList); got != ui.ActionPrevPane {
 		t.Fatalf("got %v", got)
 	}
-	if got := ui.KeyAction("backtab", model.FocusPreview); got != ui.ActionPrevPane {
+}
+
+func TestKeyActionTabOnPreviewDoesNotSwitchPane(t *testing.T) {
+	if got := ui.KeyAction("tab", model.FocusPreview); got != ui.ActionNone {
+		t.Fatalf("tab on preview should stay in pane, got %v", got)
+	}
+}
+
+func TestKeyActionSortAndColumns(t *testing.T) {
+	if got := ui.KeyAction("s", model.FocusList); got != ui.ActionSort {
 		t.Fatalf("got %v", got)
 	}
 }
 
-func TestKeyActionTabNextPane(t *testing.T) {
-	if got := ui.KeyAction("tab", model.FocusList); got != ui.ActionNextPane {
-		t.Fatalf("got %v", got)
-	}
-}
-
-func TestKeyActionOpenActions(t *testing.T) {
-	if got := ui.KeyAction("a", model.FocusList); got != ui.ActionOpenActions {
+func TestKeyActionFilter(t *testing.T) {
+	if got := ui.KeyAction("f", model.FocusList); got != ui.ActionFilter {
 		t.Fatalf("got %v", got)
 	}
 }
 
 func TestLayoutWidths(t *testing.T) {
-	menu, list, preview := ui.LayoutWidths(120)
-	if menu+list+preview > 120 {
+	menu, list, preview := ui.LayoutWidthsLegacy(120)
+	if menu+list+preview != 120 {
 		t.Fatalf("widths exceed total: %d+%d+%d", menu, list, preview)
 	}
 }

cmd/office/ui/detail.go

@@ -0,0 +1,503 @@
+package ui
+
+import (
+	"strings"
+
+	"github.com/charmbracelet/bubbles/viewport"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/eslider/go-onlyoffice/cmd/office/model"
+	"github.com/eslider/go-onlyoffice/cmd/office/preview"
+)
+
+const detailContentRatio = 0.72
+
+type detailMode int
+
+const (
+	detailEmpty detailMode = iota
+	detailDocument
+	detailForm
+)
+
+type detailZone int
+
+const (
+	detailZoneContent detailZone = iota
+	detailZoneActions
+)
+
+// DetailPane is the right column: content top, CRUD actions bottom.
+type DetailPane struct {
+	mode      detailMode
+	item      model.Item
+	loadedID  string
+	actions   []model.ItemAction
+	actionIdx int
+	tabStop   int
+	zone      detailZone
+	focused   bool
+	width     int
+	height    int
+	form      EntityForm
+	docVP     viewport.Model
+	formVP    viewport.Model
+	docText   string
+	styles    detailStyles
+}
+
+type detailStyles struct {
+	sep      lipgloss.Style
+	action   lipgloss.Style
+	actionOn lipgloss.Style
+	actionDn lipgloss.Style
+	empty    lipgloss.Style
+}
+
+func newDetailPane() DetailPane {
+	d := DetailPane{
+		form:   newEntityForm(),
+		docVP:  viewport.New(40, 10),
+		formVP: viewport.New(40, 10),
+		styles: newDetailStyles(),
+	}
+	d.docVP.MouseWheelEnabled = true
+	d.formVP.MouseWheelEnabled = true
+	return d
+}
+
+func newDetailStyles() detailStyles {
+	btn := lipgloss.NewStyle().Padding(0, 1).MarginRight(1)
+	return detailStyles{
+		sep:      lipgloss.NewStyle().Foreground(lipgloss.Color("238")),
+		action:   btn.Foreground(lipgloss.Color("252")).Background(lipgloss.Color("236")),
+		actionOn: btn.Bold(true).Foreground(lipgloss.Color("255")).Background(lipgloss.Color("62")),
+		actionDn: btn.Foreground(lipgloss.Color("255")).Background(lipgloss.Color("52")),
+		empty:    lipgloss.NewStyle().Foreground(lipgloss.Color("241")),
+	}
+}
+
+func (d *DetailPane) Clear() {
+	d.mode = detailEmpty
+	d.item = model.Item{}
+	d.loadedID = ""
+	d.actions = nil
+	d.actionIdx = 0
+	d.tabStop = 0
+	d.docText = ""
+	d.form.Clear()
+	d.docVP.SetContent("")
+	d.formVP.SetContent("")
+}
+
+func (d *DetailPane) SetFocused(on bool) {
+	d.focused = on
+	d.applyTabStop(d.tabStop)
+}
+
+func (d *DetailPane) FocusFirstStop() {
+	d.tabStop = 0
+	d.applyTabStop(0)
+}
+
+func (d *DetailPane) maxTabStop() int {
+	switch d.mode {
+	case detailForm:
+		if d.form.readOnly {
+			if len(d.actions) == 0 {
+				return 0
+			}
+			return len(d.actions) - 1
+		}
+		fields := d.form.FieldCount()
+		if len(d.actions) == 0 {
+			if fields == 0 {
+				return 0
+			}
+			return fields - 1
+		}
+		return fields + len(d.actions) - 1
+	case detailDocument:
+		if len(d.actions) == 0 {
+			return 0
+		}
+		return len(d.actions)
+	default:
+		return 0
+	}
+}
+
+func (d *DetailPane) applyTabStop(stop int) {
+	if stop < 0 {
+		stop = 0
+	}
+	max := d.maxTabStop()
+	if stop > max {
+		stop = max
+	}
+	d.tabStop = stop
+
+	switch d.mode {
+	case detailForm:
+		if d.form.readOnly {
+			d.zone = detailZoneActions
+			d.actionIdx = stop
+			d.form.SetFocused(false)
+			return
+		}
+		fields := d.form.FieldCount()
+		if stop < fields {
+			d.zone = detailZoneContent
+			d.form.SetFieldIndex(stop)
+			d.form.SetFocused(d.focused)
+			return
+		}
+		d.zone = detailZoneActions
+		d.actionIdx = stop - fields
+		d.form.SetFocused(false)
+	case detailDocument:
+		if stop == 0 {
+			d.zone = detailZoneContent
+			d.form.SetFocused(false)
+			return
+		}
+		d.zone = detailZoneActions
+		d.actionIdx = stop - 1
+		d.form.SetFocused(false)
+	default:
+		d.zone = detailZoneContent
+		d.form.SetFocused(false)
+	}
+}
+
+// TabForward moves to the next field/button. It returns true when focus should leave the pane.
+func (d *DetailPane) TabForward() bool {
+	max := d.maxTabStop()
+	if d.tabStop < max {
+		d.applyTabStop(d.tabStop + 1)
+		return false
+	}
+	d.FocusFirstStop()
+	return true
+}
+
+// TabBackward moves to the previous field/button. It returns true when focus should leave the pane.
+func (d *DetailPane) TabBackward() bool {
+	if d.tabStop > 0 {
+		d.applyTabStop(d.tabStop - 1)
+		return false
+	}
+	d.applyTabStop(d.maxTabStop())
+	return true
+}
+
+func (d *DetailPane) SetSize(w, h int) {
+	if w < 8 {
+		w = 8
+	}
+	if h < 8 {
+		h = 8
+	}
+	d.width = w
+	d.height = h
+	contentH, _ := d.splitHeights()
+	d.form.SetSize(w, contentH)
+	d.docVP.Width = w
+	d.docVP.Height = contentH
+	d.formVP.Width = w
+	d.formVP.Height = contentH
+}
+
+func (d *DetailPane) splitHeights() (contentH, actionH int) {
+	actionH = int(float64(d.height) * (1 - detailContentRatio))
+	if actionH < 3 {
+		actionH = 3
+	}
+	if actionH > 6 {
+		actionH = 6
+	}
+	contentH = d.height - actionH - 1
+	if contentH < 4 {
+		contentH = 4
+	}
+	return contentH, actionH
+}
+
+func (d *DetailPane) LoadForm(item model.Item, fields model.FormFields) {
+	d.mode = detailForm
+	d.item = item
+	d.loadedID = item.ID
+	d.actions = model.ActionsFor(item.Kind)
+	d.actionIdx = 0
+	d.tabStop = 0
+	d.form.Load(item.Kind, item.ID, fields)
+	d.refreshFormViewport()
+	d.applyTabStop(0)
+	d.layoutContent()
+}
+
+func (d *DetailPane) LoadDocument(item model.Item, markdown string, renderWidth int) {
+	d.mode = detailDocument
+	d.item = item
+	d.loadedID = item.ID
+	d.actions = model.ActionsFor(item.Kind)
+	d.actionIdx = 0
+	d.tabStop = 0
+	d.form.Clear()
+	text, err := preview.RenderMarkdown(markdown, renderWidth)
+	if err != nil {
+		text = markdown
+	}
+	d.docText = text
+	d.docVP.SetContent(text)
+	d.docVP.GotoTop()
+	d.applyTabStop(0)
+	d.layoutContent()
+}
+
+func (d *DetailPane) layoutContent() {
+	contentH, _ := d.splitHeights()
+	d.form.SetSize(d.width, contentH)
+	d.docVP.Width = d.width
+	d.docVP.Height = contentH
+	d.formVP.Width = d.width
+	d.formVP.Height = contentH
+	d.refreshFormViewport()
+}
+
+func (d *DetailPane) refreshFormViewport() {
+	if d.mode != detailForm || !d.form.readOnly {
+		d.formVP.SetContent("")
+		return
+	}
+	d.formVP.SetContent(d.form.View())
+}
+
+func (d *DetailPane) LoadedID() string { return d.loadedID }
+
+func (d *DetailPane) Item() model.Item { return d.item }
+
+func (d *DetailPane) Zone() detailZone { return d.zone }
+
+func (d *DetailPane) FocusContent() {
+	d.applyTabStop(d.tabStop)
+	if d.zone == detailZoneContent && d.mode == detailForm {
+		d.form.SetFocused(d.focused)
+	}
+}
+
+func (d *DetailPane) FocusActions() {
+	max := d.maxTabStop()
+	switch d.mode {
+	case detailForm:
+		if d.form.readOnly {
+			d.applyTabStop(max)
+			return
+		}
+		if len(d.actions) > 0 {
+			d.applyTabStop(d.form.FieldCount())
+		}
+	case detailDocument:
+		if len(d.actions) > 0 {
+			d.applyTabStop(1)
+		}
+	}
+}
+
+// MoveTabStop moves between title, description, and action buttons without leaving the pane.
+func (d *DetailPane) MoveTabStop(delta int) {
+	if delta == 0 {
+		return
+	}
+	next := d.tabStop + delta
+	if next < 0 {
+		next = 0
+	}
+	max := d.maxTabStop()
+	if next > max {
+		next = max
+	}
+	d.applyTabStop(next)
+}
+
+func (d *DetailPane) MoveAction(delta int) {
+	if len(d.actions) == 0 {
+		return
+	}
+	d.actionIdx = clampInt(d.actionIdx+delta, 0, len(d.actions)-1)
+}
+
+func (d *DetailPane) SelectedAction() (model.ItemAction, bool) {
+	if d.actionIdx < 0 || d.actionIdx >= len(d.actions) {
+		return model.ItemAction{}, false
+	}
+	return d.actions[d.actionIdx], true
+}
+
+func (d DetailPane) IsDocumentContent() bool {
+	return d.mode == detailDocument
+}
+
+func (d DetailPane) isReadOnlyFormContent() bool {
+	return d.mode == detailForm && d.form.readOnly
+}
+
+func (d DetailPane) documentContentHeight() int {
+	contentH, _ := d.splitHeights()
+	return contentH
+}
+
+// ScrollDocument scrolls the read-only document viewport (mail, file preview).
+func (d *DetailPane) ScrollDocument(key string) bool {
+	if d.IsDocumentContent() {
+		return scrollViewport(&d.docVP, key)
+	}
+	if d.isReadOnlyFormContent() && d.zone == detailZoneContent {
+		return scrollViewport(&d.formVP, key)
+	}
+	return false
+}
+
+// ScrollDocumentMouse applies wheel events to scrollable preview content.
+func (d *DetailPane) ScrollDocumentMouse(msg tea.MouseMsg) tea.Cmd {
+	var vp *viewport.Model
+	switch {
+	case d.IsDocumentContent():
+		vp = &d.docVP
+	case d.isReadOnlyFormContent():
+		vp = &d.formVP
+	default:
+		return nil
+	}
+	if msg.Y >= d.documentContentHeight() {
+		return nil
+	}
+	if !vp.MouseWheelEnabled || msg.Action != tea.MouseActionPress {
+		return nil
+	}
+	switch msg.Button {
+	case tea.MouseButtonWheelUp, tea.MouseButtonWheelDown:
+	default:
+		return nil
+	}
+	var cmd tea.Cmd
+	*vp, cmd = vp.Update(msg)
+	return cmd
+}
+
+// DocumentYOffset exposes scroll position for tests.
+func (d DetailPane) DocumentYOffset() int {
+	return d.docVP.YOffset
+}
+
+func (d *DetailPane) Update(msg tea.Msg) tea.Cmd {
+	if !d.focused {
+		return nil
+	}
+	if d.zone == detailZoneContent {
+		switch d.mode {
+		case detailForm:
+			if d.form.readOnly {
+				if key, ok := msg.(tea.KeyMsg); ok {
+					if scrollViewport(&d.formVP, key.String()) {
+						return nil
+					}
+				}
+				var cmd tea.Cmd
+				d.formVP, cmd = d.formVP.Update(msg)
+				return cmd
+			}
+			return d.form.Update(msg)
+		case detailDocument:
+			if key, ok := msg.(tea.KeyMsg); ok {
+				if scrollViewport(&d.docVP, key.String()) {
+					return nil
+				}
+			}
+			var cmd tea.Cmd
+			d.docVP, cmd = d.docVP.Update(msg)
+			return cmd
+		}
+	}
+	return nil
+}
+
+func (d DetailPane) View() string {
+	if d.mode == detailEmpty {
+		return d.styles.empty.Render("Select a row to preview or edit.")
+	}
+	contentH, actionH := d.splitHeights()
+	var top string
+	switch d.mode {
+	case detailForm:
+		if d.form.readOnly {
+			top = ApplyVerticalScrollbar(
+				d.formVP.View(),
+				d.formVP.Width,
+				d.formVP.Height,
+				d.formVP.TotalLineCount(),
+				d.formVP.YOffset,
+			)
+		} else {
+			top = lipgloss.NewStyle().Width(d.width).Height(contentH).Render(d.form.View())
+		}
+	case detailDocument:
+		top = ApplyVerticalScrollbar(
+			d.docVP.View(),
+			d.docVP.Width,
+			d.docVP.Height,
+			d.docVP.TotalLineCount(),
+			d.docVP.YOffset,
+		)
+	default:
+		top = ""
+	}
+	sep := d.styles.sep.Width(d.width).Render(strings.Repeat("─", max(1, d.width)))
+	bottom := lipgloss.NewStyle().Width(d.width).Height(actionH).Render(d.renderActions())
+	return lipgloss.JoinVertical(lipgloss.Left, top, sep, bottom)
+}
+
+func (d DetailPane) renderActions() string {
+	if len(d.actions) == 0 {
+		hint := "No actions"
+		if d.focused && d.zone == detailZoneActions {
+			hint = lipgloss.NewStyle().Background(lipgloss.Color("238")).Render(" No actions ")
+		}
+		return d.styles.empty.Render(hint)
+	}
+	parts := make([]string, 0, len(d.actions))
+	for i, act := range d.actions {
+		style := d.styles.action
+		if d.focused && d.zone == detailZoneActions && i == d.actionIdx {
+			if act.Danger {
+				style = d.styles.actionDn
+			} else {
+				style = d.styles.actionOn
+			}
+		} else if act.Danger {
+			style = d.styles.actionDn
+		}
+		parts = append(parts, style.Render(act.Label))
+	}
+	line := strings.Join(parts, "")
+	if d.focused && d.zone == detailZoneActions {
+		line += d.styles.empty.Render("  Tab · Enter run")
+	}
+	return line
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+func (d DetailPane) BlinkCmd() tea.Cmd {
+	return entityFormBlinkCmd()
+}
+
+// NewDetailPaneForTest exposes detail pane for tests.
+func NewDetailPaneForTest() DetailPane {
+	return newDetailPane()
+}

cmd/office/ui/detail_scroll_test.go

@@ -0,0 +1,60 @@
+package ui
+
+import (
+	"testing"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/eslider/go-onlyoffice/cmd/office/model"
+)
+
+func TestDetailDocumentScrollByKey(t *testing.T) {
+	d := newDetailPane()
+	d.SetSize(50, 20)
+	longBody := "# Mail\n\n"
+	for i := 0; i < 80; i++ {
+		longBody += "line\n"
+	}
+	d.LoadDocument(model.Item{ID: "1", Kind: model.KindMail, Title: "M"}, longBody, 40)
+	d.SetFocused(true)
+
+	if d.DocumentYOffset() != 0 {
+		t.Fatalf("expected top offset 0, got %d", d.DocumentYOffset())
+	}
+	if !d.ScrollDocument("down") {
+		t.Fatal("expected scroll down to succeed")
+	}
+	if d.DocumentYOffset() == 0 {
+		t.Fatal("expected offset after scroll down")
+	}
+	if !d.ScrollDocument("up") {
+		t.Fatal("expected scroll up to succeed")
+	}
+}
+
+func TestDetailDocumentMouseWheel(t *testing.T) {
+	d := newDetailPane()
+	d.SetSize(50, 20)
+	longBody := "# Mail\n\n"
+	for i := 0; i < 80; i++ {
+		longBody += "line\n"
+	}
+	d.LoadDocument(model.Item{ID: "1", Kind: model.KindMail, Title: "M"}, longBody, 40)
+
+	d.ScrollDocumentMouse(tea.MouseMsg{
+		X: 10, Y: 2, Button: tea.MouseButtonWheelDown, Action: tea.MouseActionPress,
+	})
+	if d.DocumentYOffset() == 0 {
+		t.Fatal("expected wheel down to scroll document")
+	}
+}
+
+func TestDetailPaneXRange(t *testing.T) {
+	pw := PaneWidths{
+		Menu: 12, List: 72, Detail: 36,
+		Visibility: PaneVisibility{Menu: true, List: true, Detail: true},
+	}
+	start, end := DetailPaneXRange(pw)
+	if start != 84 || end != 120 {
+		t.Fatalf("range=%d..%d want 84..120", start, end)
+	}
+}

cmd/office/ui/detail_tab_test.go

@@ -0,0 +1,65 @@
+package ui
+
+import (
+	"testing"
+
+	"github.com/eslider/go-onlyoffice/cmd/office/model"
+)
+
+func TestDetailTabOrderProjectForm(t *testing.T) {
+	d := newDetailPane()
+	d.SetFocused(true)
+	d.LoadForm(model.Item{ID: "1", Kind: model.KindProject, Title: "P"}, model.FormFields{
+		PrimaryLabel: "Title", SecondaryLabel: "Description",
+		Primary: "Alpha", Secondary: "Beta", HasStatus: true,
+		Status: model.ProjectLifecycleOpen,
+	})
+
+	if d.tabStop != 0 || d.form.field != entityFieldPrimary {
+		t.Fatalf("start on title, tabStop=%d field=%d", d.tabStop, d.form.field)
+	}
+	if d.TabForward() {
+		t.Fatal("tab from title should stay in pane")
+	}
+	if d.form.field != entityFieldSecondary {
+		t.Fatalf("second stop should be description, field=%d", d.form.field)
+	}
+	if d.TabForward() {
+		t.Fatal("tab from description should stay in pane")
+	}
+	if d.form.field != entityFieldStatus {
+		t.Fatalf("third stop should be status, field=%d", d.form.field)
+	}
+	if d.TabForward() {
+		t.Fatal("tab from status should stay in pane")
+	}
+	if d.Zone() != detailZoneActions || d.actionIdx != 0 {
+		t.Fatalf("fourth stop should be Save, zone=%d idx=%d", d.Zone(), d.actionIdx)
+	}
+	if d.TabForward() {
+		t.Fatal("tab from Save should stay in pane")
+	}
+	if d.actionIdx != 1 {
+		t.Fatalf("fifth stop should be Delete, idx=%d", d.actionIdx)
+	}
+	if !d.TabForward() {
+		t.Fatal("tab from Delete should leave pane")
+	}
+	if d.tabStop != 0 {
+		t.Fatalf("after leaving pane tab order resets, tabStop=%d", d.tabStop)
+	}
+}
+
+func TestDetailShiftTabFromTitleLeavesPane(t *testing.T) {
+	d := newDetailPane()
+	d.SetFocused(true)
+	d.LoadForm(model.Item{ID: "1", Kind: model.KindProject}, model.FormFields{
+		PrimaryLabel: "Title", SecondaryLabel: "Description",
+	})
+	if !d.TabBackward() {
+		t.Fatal("shift+tab from title should leave pane")
+	}
+	if d.tabStop != d.maxTabStop() {
+		t.Fatalf("should park on last stop, tabStop=%d max=%d", d.tabStop, d.maxTabStop())
+	}
+}

cmd/office/ui/detail_test.go

@@ -0,0 +1,49 @@
+package ui_test
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/eslider/go-onlyoffice/cmd/office/model"
+	"github.com/eslider/go-onlyoffice/cmd/office/ui"
+)
+
+func TestEntityFormLoadAndView(t *testing.T) {
+	form := ui.NewEntityFormForTest()
+	form.SetSize(40, 16)
+	form.Load(model.KindTask, "42", model.FormFields{
+		PrimaryLabel: "Title", SecondaryLabel: "Description",
+		Primary: "Fix bug", Secondary: "Details here",
+	})
+	view := form.View()
+	if !strings.Contains(view, "Fix bug") {
+		t.Fatal("view missing title")
+	}
+}
+
+func TestDetailPaneFormAndActions(t *testing.T) {
+	d := ui.NewDetailPaneForTest()
+	d.SetSize(50, 20)
+	d.SetFocused(true)
+	d.LoadForm(model.Item{ID: "1", Kind: model.KindTask, Title: "T"}, model.FormFields{
+		PrimaryLabel: "Title", SecondaryLabel: "Description",
+		Primary: "Hello", Secondary: "World",
+	})
+	view := d.View()
+	if !strings.Contains(view, "Save") {
+		t.Fatal("expected Save action button")
+	}
+	if !strings.Contains(view, "Hello") {
+		t.Fatal("expected form content")
+	}
+}
+
+func TestDetailPaneDocumentMode(t *testing.T) {
+	d := ui.NewDetailPaneForTest()
+	d.SetSize(50, 20)
+	d.LoadDocument(model.Item{ID: "9", Kind: model.KindFile, Title: "a.txt"}, "# Doc\n\nbody", 40)
+	view := d.View()
+	if !strings.Contains(view, "Download") {
+		t.Fatal("expected Download action")
+	}
+}

cmd/office/ui/entityform.go

@@ -0,0 +1,331 @@
+package ui
+
+import (
+	"strings"
+
+	"github.com/charmbracelet/bubbles/textinput"
+	"github.com/charmbracelet/bubbles/textarea"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/eslider/go-onlyoffice/cmd/office/model"
+)
+
+type entityField int
+
+const (
+	entityFieldPrimary entityField = iota
+	entityFieldSecondary
+	entityFieldStatus
+)
+
+// EntityForm is the top section of the detail pane for editable entities.
+type EntityForm struct {
+	active         bool
+	kind           model.Kind
+	itemID         string
+	primaryLabel   string
+	secondaryLabel string
+	readOnly       bool
+	hasStatus      bool
+	status         model.ProjectLifecycle
+	responsibleID  string
+	primary        textinput.Model
+	secondary      textarea.Model
+	field          entityField
+	focused        bool
+	dirty          bool
+	width          int
+	height         int
+	styles         entityFormStyles
+}
+
+type entityFormStyles struct {
+	header   lipgloss.Style
+	label    lipgloss.Style
+	labelAct lipgloss.Style
+}
+
+func newEntityFormStyles() entityFormStyles {
+	return entityFormStyles{
+		header:   lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("252")),
+		label:    lipgloss.NewStyle().Foreground(lipgloss.Color("241")),
+		labelAct: lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("255")).Background(lipgloss.Color("62")),
+	}
+}
+
+func newEntityForm() EntityForm {
+	primary := textinput.New()
+	primary.CharLimit = 512
+	primary.Prompt = "> "
+	secondary := textarea.New()
+	secondary.ShowLineNumbers = false
+	secondary.CharLimit = 8000
+	secondary.Prompt = "> "
+	return EntityForm{
+		primary:  primary,
+		secondary: secondary,
+		field:    entityFieldPrimary,
+		styles:   newEntityFormStyles(),
+	}
+}
+
+func (f *EntityForm) FieldCount() int {
+	n := 2
+	if f.hasStatus {
+		n = 3
+	}
+	return n
+}
+
+func (f *EntityForm) FormFields() model.FormFields {
+	return model.FormFields{
+		PrimaryLabel:   f.primaryLabel,
+		SecondaryLabel: f.secondaryLabel,
+		Primary:        f.primary.Value(),
+		Secondary:      f.secondary.Value(),
+		ReadOnly:       f.readOnly,
+		HasStatus:      f.hasStatus,
+		Status:         f.status,
+		ResponsibleID:  f.responsibleID,
+	}
+}
+
+func (f *EntityForm) Active() bool { return f.active }
+
+func (f *EntityForm) ItemID() string { return f.itemID }
+
+func (f *EntityForm) Primary() string { return f.primary.Value() }
+
+func (f *EntityForm) Secondary() string { return f.secondary.Value() }
+
+func (f *EntityForm) MarkClean() { f.dirty = false }
+
+func (f *EntityForm) Load(kind model.Kind, itemID string, fields model.FormFields) {
+	f.active = true
+	f.kind = kind
+	f.itemID = itemID
+	f.primaryLabel = fields.PrimaryLabel
+	f.secondaryLabel = fields.SecondaryLabel
+	f.readOnly = fields.ReadOnly
+	f.hasStatus = fields.HasStatus
+	f.status = fields.Status
+	f.responsibleID = fields.ResponsibleID
+	f.primary.SetValue(fields.Primary)
+	f.secondary.SetValue(fields.Secondary)
+	f.dirty = false
+	f.field = entityFieldPrimary
+	if f.hasStatus && f.readOnly {
+		f.field = entityFieldStatus
+	}
+	f.applyFocus()
+	f.layoutFields()
+}
+
+func (f *EntityForm) Clear() {
+	f.active = false
+	f.itemID = ""
+	f.hasStatus = false
+	f.status = model.ProjectLifecycleOpen
+	f.responsibleID = ""
+	f.primary.SetValue("")
+	f.secondary.SetValue("")
+	f.dirty = false
+	f.primary.Blur()
+	f.secondary.Blur()
+}
+
+func (f *EntityForm) SetFocused(on bool) {
+	f.focused = on && f.active
+	if f.focused {
+		f.applyFocus()
+	} else {
+		f.primary.Blur()
+		f.secondary.Blur()
+	}
+}
+
+func (f *EntityForm) SetSize(w, h int) {
+	if w < 12 {
+		w = 12
+	}
+	if h < 6 {
+		h = 6
+	}
+	f.width = w
+	f.height = h
+	f.layoutFields()
+}
+
+func (f *EntityForm) layoutFields() {
+	if f.width == 0 {
+		return
+	}
+	inner := f.width - 2
+	if inner < 8 {
+		inner = 8
+	}
+	f.primary.Width = inner
+	secH := f.height - 6
+	if secH < 3 {
+		secH = 3
+	}
+	f.secondary.SetWidth(inner)
+	f.secondary.SetHeight(secH)
+}
+
+func (f *EntityForm) FocusNext() {
+	last := entityFieldSecondary
+	if f.hasStatus {
+		last = entityFieldStatus
+	}
+	if f.field < last {
+		f.field++
+	}
+	f.applyFocus()
+}
+
+func (f *EntityForm) FocusPrev() {
+	first := entityFieldPrimary
+	if f.field > first {
+		f.field--
+	}
+	f.applyFocus()
+}
+
+func (f *EntityForm) SetFieldIndex(i int) {
+	switch i {
+	case 0:
+		f.field = entityFieldPrimary
+	case 1:
+		f.field = entityFieldSecondary
+	case 2:
+		if f.hasStatus {
+			f.field = entityFieldStatus
+		}
+	default:
+		return
+	}
+	f.applyFocus()
+}
+
+func (f *EntityForm) cycleStatus(delta int) {
+	if !f.hasStatus || f.readOnly {
+		return
+	}
+	if delta > 0 {
+		f.status = f.status.Next()
+	} else {
+		f.status = f.status.Prev()
+	}
+	f.dirty = true
+}
+
+func (f *EntityForm) applyFocus() {
+	if f.readOnly {
+		f.primary.Blur()
+		f.secondary.Blur()
+		return
+	}
+	switch f.field {
+	case entityFieldPrimary:
+		f.primary.Focus()
+		f.secondary.Blur()
+	case entityFieldSecondary:
+		f.primary.Blur()
+		f.secondary.Focus()
+	default:
+		f.primary.Blur()
+		f.secondary.Blur()
+	}
+}
+
+func (f *EntityForm) Update(msg tea.Msg) tea.Cmd {
+	if !f.active || !f.focused || f.readOnly {
+		return nil
+	}
+	if key, ok := msg.(tea.KeyMsg); ok && f.field == entityFieldStatus {
+		switch key.String() {
+		case "left", "h":
+			f.cycleStatus(-1)
+			return nil
+		case "right", "l":
+			f.cycleStatus(1)
+			return nil
+		case " ":
+			f.cycleStatus(1)
+			return nil
+		}
+	}
+	var cmd tea.Cmd
+	switch f.field {
+	case entityFieldPrimary:
+		f.primary, cmd = f.primary.Update(msg)
+	case entityFieldSecondary:
+		f.secondary, cmd = f.secondary.Update(msg)
+	default:
+		return nil
+	}
+	if _, ok := msg.(tea.KeyMsg); ok {
+		f.dirty = true
+	}
+	return cmd
+}
+
+func (f EntityForm) View() string {
+	if !f.active {
+		return ""
+	}
+	header := f.styles.header.Render(model.KindHeading(f.kind, f.itemID))
+	pLabel := f.styles.label.Render(f.primaryLabel)
+	if f.focused && f.field == entityFieldPrimary && !f.readOnly {
+		pLabel = f.styles.labelAct.Render(f.primaryLabel)
+	}
+	sLabel := f.styles.label.Render(f.secondaryLabel)
+	if f.focused && f.field == entityFieldSecondary && !f.readOnly {
+		sLabel = f.styles.labelAct.Render(f.secondaryLabel)
+	}
+	statusBlock := ""
+	if f.hasStatus {
+		stLabel := f.styles.label.Render("Status")
+		if f.focused && f.field == entityFieldStatus && !f.readOnly {
+			stLabel = f.styles.labelAct.Render("Status")
+		}
+		valStyle := f.styles.label
+		if f.status == model.ProjectLifecycleClosed {
+			valStyle = valStyle.Foreground(lipgloss.Color("245"))
+		} else {
+			valStyle = valStyle.Foreground(lipgloss.Color("42"))
+		}
+		hint := ""
+		if f.focused && f.field == entityFieldStatus && !f.readOnly {
+			hint = f.styles.label.Render("  ←/→ toggle")
+		}
+		statusBlock = strings.Join([]string{
+			"",
+			stLabel,
+			valStyle.Render(f.status.Label()) + hint,
+		}, "\n")
+	}
+	ro := ""
+	if f.readOnly {
+		ro = lipgloss.NewStyle().Foreground(lipgloss.Color("241")).Render(" (read-only)") + "\n"
+	}
+	return strings.Join([]string{
+		header + ro,
+		pLabel,
+		f.primary.View(),
+		"",
+		sLabel,
+		f.secondary.View(),
+		statusBlock,
+	}, "\n")
+}
+
+func entityFormBlinkCmd() tea.Cmd {
+	return tea.Batch(textinput.Blink, textarea.Blink)
+}
+
+// NewEntityFormForTest exposes a form for unit tests.
+func NewEntityFormForTest() EntityForm {
+	return newEntityForm()
+}

cmd/office/ui/filter.go

@@ -0,0 +1,88 @@
+package ui
+
+import (
+	"strings"
+
+	"github.com/charmbracelet/bubbles/textinput"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+)
+
+// FilterSearch is the right-pane query input for nav/list filtering.
+type FilterSearch struct {
+	input   textinput.Model
+	width   int
+	height  int
+	focused bool
+	styles  filterSearchStyles
+}
+
+type filterSearchStyles struct {
+	title lipgloss.Style
+	hint  lipgloss.Style
+}
+
+func newFilterSearch() FilterSearch {
+	in := textinput.New()
+	in.Prompt = "/ "
+	in.Placeholder = "Filter navigation and list…"
+	in.CharLimit = 256
+	return FilterSearch{
+		input: in,
+		styles: filterSearchStyles{
+			title: lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("252")),
+			hint:  lipgloss.NewStyle().Foreground(lipgloss.Color("241")),
+		},
+	}
+}
+
+func (f *FilterSearch) Query() string { return f.input.Value() }
+
+func (f *FilterSearch) SetFocused(on bool) {
+	f.focused = on
+	if on {
+		f.input.Focus()
+	} else {
+		f.input.Blur()
+	}
+}
+
+func (f *FilterSearch) SetSize(w, h int) {
+	if w < 12 {
+		w = 12
+	}
+	if h < 6 {
+		h = 6
+	}
+	f.width = w
+	f.height = h
+	inner := w - 2
+	if inner < 8 {
+		inner = 8
+	}
+	f.input.Width = inner
+}
+
+func (f *FilterSearch) Clear() {
+	f.input.SetValue("")
+}
+
+func (f *FilterSearch) Update(msg tea.Msg) tea.Cmd {
+	if !f.focused {
+		return nil
+	}
+	var cmd tea.Cmd
+	f.input, cmd = f.input.Update(msg)
+	return cmd
+}
+
+func (f FilterSearch) View() string {
+	title := f.styles.title.Render("Filter")
+	body := lipgloss.NewStyle().Width(f.width).Render(f.input.View())
+	hint := f.styles.hint.Render("Filters left nav and center table · Esc clear · f focus")
+	return strings.Join([]string{title, "", body, "", hint}, "\n")
+}
+
+func filterSearchBlinkCmd() tea.Cmd {
+	return textinput.Blink
+}

cmd/office/ui/keys.go

@@ -9,14 +9,19 @@ const (
 	ActionNone Action = iota
 	ActionMoveUp
 	ActionMoveDown
+	ActionMoveLeft
+	ActionMoveRight
+	ActionSort
 	ActionToggleSelect
-	ActionOpenPreview
-	ActionOpenActions
+	ActionFocusDetail
+	ActionToggleMenuPane
+	ActionToggleListPane
+	ActionToggleDetailPane
+	ActionFilter
 	ActionNextPane
 	ActionPrevPane
 	ActionRefresh
 	ActionQuit
-	ActionOpenVex
 )
 
 // KeyAction maps a key string and focused pane to an action.
@@ -25,53 +30,51 @@ func KeyAction(key string, pane model.FocusPane) Action {
 	case "q", "ctrl+c":
 		return ActionQuit
 	case "tab":
+		if pane != model.FocusPreview {
 			return ActionNextPane
+		}
 	case "shift+tab", "backtab":
+		if pane != model.FocusPreview {
 			return ActionPrevPane
+		}
 	case "r":
 		return ActionRefresh
+	case "f":
+		return ActionFilter
 	case "up", "k":
 		return ActionMoveUp
 	case "down", "j":
 		return ActionMoveDown
+	case "s":
+		if pane == model.FocusList {
+			return ActionSort
+		}
+	case "left", "h":
+		return ActionMoveLeft
+	case "right", "l":
+		return ActionMoveRight
 	case " ":
 		if pane == model.FocusList {
 			return ActionToggleSelect
 		}
-	case "a":
+	case "v", "p":
 		if pane == model.FocusList {
-			return ActionOpenActions
-		}
-	case "enter":
-		if pane == model.FocusList {
-			return ActionOpenPreview
-		}
-	case "v":
-		if pane == model.FocusList {
-			return ActionOpenVex
+			return ActionFocusDetail
 		}
+	case "alt+1":
+		return ActionToggleMenuPane
+	case "alt+2":
+		return ActionToggleListPane
+	case "alt+3":
+		return ActionToggleDetailPane
 	}
 	return ActionNone
 }
 
-// LayoutWidths splits total terminal width into menu, list, preview columns.
-func LayoutWidths(total int) (menu, list, preview int) {
-	if total < 80 {
-		total = 80
-	}
-	menu = total / 5
-	if menu < 22 {
-		menu = 22
-	}
-	preview = total / 3
-	if preview < 28 {
-		preview = 28
-	}
-	list = total - menu - preview - 2
-	if list < 24 {
-		list = 24
-	}
-	return menu, list, preview
+// LayoutWidthsLegacy is kept for tests that expect the old signature.
+func LayoutWidthsLegacy(total int) (menu, list, preview int) {
+	pw := LayoutWidths(total, defaultPaneVisibility())
+	return pw.Menu, pw.List, pw.Detail
 }
 
 // ResolveMoveUp returns the action for upward navigation keys.

cmd/office/ui/layout.go

@@ -0,0 +1,145 @@
+package ui
+
+import "github.com/eslider/go-onlyoffice/cmd/office/model"
+
+// PaneVisibility controls which columns are shown.
+type PaneVisibility struct {
+	Menu, List, Detail bool
+}
+
+// PaneWidths is outer lipgloss width per column (sums to terminal width).
+type PaneWidths struct {
+	Menu, List, Detail int
+	Visibility         PaneVisibility
+}
+
+func defaultPaneVisibility() PaneVisibility {
+	return PaneVisibility{Menu: true, List: true, Detail: true}
+}
+
+const (
+	defaultMenuShare  = 10
+	defaultListShare  = 60
+	defaultDetailShare = 30
+)
+
+// LayoutWidths splits total terminal width across visible panes (default 10% / 60% / 30%).
+func LayoutWidths(total int, vis PaneVisibility) PaneWidths {
+	if total < 1 {
+		total = 80
+	}
+	v := vis
+	if countVisible(v) == 0 {
+		v = defaultPaneVisibility()
+	}
+	shareSum := 0
+	if v.Menu {
+		shareSum += defaultMenuShare
+	}
+	if v.List {
+		shareSum += defaultListShare
+	}
+	if v.Detail {
+		shareSum += defaultDetailShare
+	}
+	assign := func(visible bool, share int) int {
+		if !visible || shareSum == 0 {
+			return 0
+		}
+		return total * share / shareSum
+	}
+	out := PaneWidths{Visibility: v}
+	out.Menu = assign(v.Menu, defaultMenuShare)
+	out.List = assign(v.List, defaultListShare)
+	out.Detail = assign(v.Detail, defaultDetailShare)
+	fixPaneWidthSum(&out, total)
+	return out
+}
+
+// DetailPaneXRange returns the [start, end) column span of the detail pane.
+func DetailPaneXRange(pw PaneWidths) (start, end int) {
+	if !pw.Visibility.Detail {
+		return 0, 0
+	}
+	if pw.Visibility.Menu {
+		start += pw.Menu
+	}
+	if pw.Visibility.List {
+		start += pw.List
+	}
+	end = start + pw.Detail
+	return start, end
+}
+
+func countVisible(v PaneVisibility) int {
+	n := 0
+	if v.Menu {
+		n++
+	}
+	if v.List {
+		n++
+	}
+	if v.Detail {
+		n++
+	}
+	return n
+}
+
+// NextVisibleFocus cycles focus forward, skipping hidden panes.
+func NextVisibleFocus(cur model.FocusPane, vis PaneVisibility) model.FocusPane {
+	order := []model.FocusPane{model.FocusMenu, model.FocusList, model.FocusPreview}
+	start := 0
+	for i, p := range order {
+		if p == cur {
+			start = i
+			break
+		}
+	}
+	for step := 1; step <= len(order); step++ {
+		p := order[(start+step)%len(order)]
+		if paneVisible(p, vis) {
+			return p
+		}
+	}
+	return cur
+}
+
+// PrevVisibleFocus cycles focus backward, skipping hidden panes.
+func PrevVisibleFocus(cur model.FocusPane, vis PaneVisibility) model.FocusPane {
+	order := []model.FocusPane{model.FocusMenu, model.FocusList, model.FocusPreview}
+	start := 0
+	for i, p := range order {
+		if p == cur {
+			start = i
+			break
+		}
+	}
+	for step := 1; step <= len(order); step++ {
+		p := order[(start-step+len(order))%len(order)]
+		if paneVisible(p, vis) {
+			return p
+		}
+	}
+	return cur
+}
+
+func paneVisible(p model.FocusPane, vis PaneVisibility) bool {
+	switch p {
+	case model.FocusMenu:
+		return vis.Menu
+	case model.FocusList:
+		return vis.List
+	default:
+		return vis.Detail
+	}
+}
+
+func firstVisibleFocus(vis PaneVisibility) model.FocusPane {
+	if vis.Menu {
+		return model.FocusMenu
+	}
+	if vis.List {
+		return model.FocusList
+	}
+	return model.FocusPreview
+}

cmd/office/ui/layout_resize.go

@@ -0,0 +1,203 @@
+package ui
+
+import (
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+const (
+	minPaneOuterWidth = 14
+	resizeHitSlop     = 1
+)
+
+type paneResizeState struct {
+	active   bool
+	divider  int
+	anchorX  int
+	anchorPW PaneWidths
+}
+
+// FitPaneWidths scales stored pane widths to fill total width for visible panes.
+func FitPaneWidths(total int, vis PaneVisibility, sizes PaneWidths) PaneWidths {
+	if total < 1 {
+		total = 80
+	}
+	out := PaneWidths{Visibility: vis}
+	if countVisible(vis) == 0 {
+		return LayoutWidths(total, vis)
+	}
+	sum := 0
+	if vis.Menu {
+		sum += sizes.Menu
+	}
+	if vis.List {
+		sum += sizes.List
+	}
+	if vis.Detail {
+		sum += sizes.Detail
+	}
+	if sum <= 0 {
+		return LayoutWidths(total, vis)
+	}
+	assign := func(visible bool, stored int) int {
+		if !visible {
+			return 0
+		}
+		return stored * total / sum
+	}
+	out.Menu = assign(vis.Menu, sizes.Menu)
+	out.List = assign(vis.List, sizes.List)
+	out.Detail = assign(vis.Detail, sizes.Detail)
+	fixPaneWidthSum(&out, total)
+	return out
+}
+
+func fixPaneWidthSum(pw *PaneWidths, total int) {
+	if pw == nil || total < 1 {
+		return
+	}
+	type slot struct {
+		visible bool
+		width   *int
+	}
+	slots := []slot{
+		{pw.Visibility.Menu, &pw.Menu},
+		{pw.Visibility.List, &pw.List},
+		{pw.Visibility.Detail, &pw.Detail},
+	}
+	sum := 0
+	var last *int
+	for _, s := range slots {
+		if !s.visible {
+			continue
+		}
+		sum += *s.width
+		last = s.width
+	}
+	if last == nil {
+		return
+	}
+	*last += total - sum
+	if *last < minPaneOuterWidth {
+		*last = minPaneOuterWidth
+	}
+}
+
+// DividerPositions returns x coordinates of vertical pane separators.
+func DividerPositions(pw PaneWidths) []int {
+	var out []int
+	x := 0
+	if pw.Visibility.Menu {
+		x += pw.Menu
+		if pw.Visibility.List || pw.Visibility.Detail {
+			out = append(out, x)
+		}
+	}
+	if pw.Visibility.List {
+		x += pw.List
+		if pw.Visibility.Detail {
+			out = append(out, x)
+		}
+	}
+	return out
+}
+
+// DividerAt returns the divider index under x, or -1.
+func DividerAt(x int, pw PaneWidths) int {
+	for i, pos := range DividerPositions(pw) {
+		if x >= pos-resizeHitSlop && x <= pos+resizeHitSlop {
+			return i
+		}
+	}
+	return -1
+}
+
+// DragPaneDivider adjusts adjacent pane widths by deltaX pixels.
+func DragPaneDivider(pw PaneWidths, divider, deltaX int) (PaneWidths, bool) {
+	if deltaX == 0 {
+		return pw, false
+	}
+	changed := false
+	switch divider {
+	case 0:
+		if pw.Visibility.Menu && pw.Visibility.List {
+			if resizePair(&pw.Menu, &pw.List, deltaX) {
+				changed = true
+			}
+		} else if pw.Visibility.Menu && pw.Visibility.Detail {
+			if resizePair(&pw.Menu, &pw.Detail, deltaX) {
+				changed = true
+			}
+		}
+	case 1:
+		if pw.Visibility.List && pw.Visibility.Detail {
+			if resizePair(&pw.List, &pw.Detail, deltaX) {
+				changed = true
+			}
+		}
+	}
+	return pw, changed
+}
+
+func resizePair(left, right *int, delta int) bool {
+	if left == nil || right == nil {
+		return false
+	}
+	newLeft := *left + delta
+	newRight := *right - delta
+	if newLeft < minPaneOuterWidth || newRight < minPaneOuterWidth {
+		return false
+	}
+	*left = newLeft
+	*right = newRight
+	return true
+}
+
+func (m Model) paneResizeMaxY() int {
+	return m.paneHeight() + 1
+}
+
+func (m *Model) handlePaneResizeMouse(msg tea.MouseMsg) bool {
+	if msg.Y >= m.paneResizeMaxY() {
+		if m.resize.active && msg.Action == tea.MouseActionRelease {
+			m.resize.active = false
+			return true
+		}
+		return false
+	}
+
+	pw := m.paneLayout()
+	switch msg.Action {
+	case tea.MouseActionPress:
+		if msg.Button != tea.MouseButtonLeft {
+			return false
+		}
+		if div := DividerAt(msg.X, pw); div >= 0 {
+			m.paneSizes = pw
+			m.customPaneLayout = true
+			m.resize = paneResizeState{
+				active:   true,
+				divider:  div,
+				anchorX:  msg.X,
+				anchorPW: pw,
+			}
+			return true
+		}
+	case tea.MouseActionRelease:
+		if m.resize.active {
+			m.resize.active = false
+			return true
+		}
+	case tea.MouseActionMotion:
+		if m.resize.active {
+			delta := msg.X - m.resize.anchorX
+			next, ok := DragPaneDivider(m.resize.anchorPW, m.resize.divider, delta)
+			if ok {
+				m.paneSizes = next
+				m.layoutViewports()
+				m.syncAllContent()
+			}
+			return true
+		}
+	}
+	return m.resize.active
+}

cmd/office/ui/layout_resize_test.go

@@ -0,0 +1,41 @@
+package ui
+
+import "testing"
+
+func TestDividerAtBetweenMenuAndList(t *testing.T) {
+	pw := PaneWidths{
+		Menu: 30, List: 50, Detail: 40,
+		Visibility: PaneVisibility{Menu: true, List: true, Detail: true},
+	}
+	if got := DividerAt(30, pw); got != 0 {
+		t.Fatalf("divider at 30=%d want 0", got)
+	}
+	if got := DividerAt(80, pw); got != 1 {
+		t.Fatalf("divider at 80=%d want 1", got)
+	}
+}
+
+func TestDragPaneDividerRespectsMinimum(t *testing.T) {
+	pw := PaneWidths{
+		Menu: 40, List: 40, Detail: 40,
+		Visibility: PaneVisibility{Menu: true, List: true, Detail: true},
+	}
+	next, ok := DragPaneDivider(pw, 0, -30)
+	if ok {
+		t.Fatalf("expected resize blocked by minimum, got %+v", next)
+	}
+	next, ok = DragPaneDivider(pw, 0, 5)
+	if !ok || next.Menu != 45 || next.List != 35 {
+		t.Fatalf("resize failed: ok=%v %+v", ok, next)
+	}
+}
+
+func TestFitPaneWidthsScalesToTotal(t *testing.T) {
+	vis := PaneVisibility{Menu: true, List: true, Detail: true}
+	sizes := PaneWidths{Menu: 20, List: 30, Detail: 50, Visibility: vis}
+	out := FitPaneWidths(120, vis, sizes)
+	sum := out.Menu + out.List + out.Detail
+	if sum != 120 {
+		t.Fatalf("sum=%d want 120", sum)
+	}
+}

cmd/office/ui/layout_test.go

@@ -0,0 +1,86 @@
+package ui
+
+import (
+	"testing"
+
+	"github.com/eslider/go-onlyoffice/cmd/office/model"
+)
+
+func TestLayoutWidthsAllVisibleUsesFullWidth(t *testing.T) {
+	vis := PaneVisibility{Menu: true, List: true, Detail: true}
+	pw := LayoutWidths(120, vis)
+	sum := pw.Menu + pw.List + pw.Detail
+	if sum != 120 {
+		t.Fatalf("sum=%d want 120", sum)
+	}
+	if pw.Menu != 12 || pw.List != 72 || pw.Detail != 36 {
+		t.Fatalf("menu=%d list=%d detail=%d want 12/72/36 (10/60/30)", pw.Menu, pw.List, pw.Detail)
+	}
+}
+
+func TestLayoutWidthsSinglePane(t *testing.T) {
+	pw := LayoutWidths(100, PaneVisibility{Menu: false, List: true, Detail: false})
+	if pw.List != 100 {
+		t.Fatalf("list=%d want 100", pw.List)
+	}
+	if pw.Menu != 0 || pw.Detail != 0 {
+		t.Fatalf("unexpected widths: %+v", pw)
+	}
+}
+
+func TestLayoutWidthsTwoPanes(t *testing.T) {
+	pw := LayoutWidths(80, PaneVisibility{Menu: true, List: false, Detail: true})
+	if pw.Menu+pw.Detail != 80 {
+		t.Fatalf("sum=%d want 80", pw.Menu+pw.Detail)
+	}
+	if pw.Menu != 20 || pw.Detail != 60 {
+		t.Fatalf("menu=%d detail=%d want 20/60 (10/30 of pair)", pw.Menu, pw.Detail)
+	}
+}
+
+func TestDetailPaneXRangeSkipsHidden(t *testing.T) {
+	pw := PaneWidths{
+		Menu: 20, List: 60, Detail: 0,
+		Visibility: PaneVisibility{Menu: true, List: true, Detail: false},
+	}
+	start, end := DetailPaneXRange(pw)
+	if start != 0 || end != 0 {
+		t.Fatalf("hidden detail should have empty range, got %d..%d", start, end)
+	}
+}
+
+func TestNextVisibleFocusSkipsHidden(t *testing.T) {
+	vis := PaneVisibility{Menu: false, List: true, Detail: true}
+	if got := NextVisibleFocus(model.FocusList, vis); got != model.FocusPreview {
+		t.Fatalf("got %v", got)
+	}
+	if got := NextVisibleFocus(model.FocusPreview, vis); got != model.FocusList {
+		t.Fatalf("got %v", got)
+	}
+}
+
+func TestPrevVisibleFocusSkipsHidden(t *testing.T) {
+	vis := PaneVisibility{Menu: true, List: false, Detail: true}
+	if got := PrevVisibleFocus(model.FocusPreview, vis); got != model.FocusMenu {
+		t.Fatalf("got %v", got)
+	}
+}
+
+func TestLayoutWidthsLegacyHelper(t *testing.T) {
+	menu, list, preview := LayoutWidthsLegacy(120)
+	if menu+list+preview != 120 {
+		t.Fatalf("widths exceed total")
+	}
+}
+
+func TestKeyActionTogglePanes(t *testing.T) {
+	if got := KeyAction("alt+1", model.FocusList); got != ActionToggleMenuPane {
+		t.Fatalf("got %v", got)
+	}
+	if got := KeyAction("alt+2", model.FocusMenu); got != ActionToggleListPane {
+		t.Fatalf("got %v", got)
+	}
+	if got := KeyAction("alt+3", model.FocusList); got != ActionToggleDetailPane {
+		t.Fatalf("got %v", got)
+	}
+}

cmd/office/ui/scroll.go

@@ -0,0 +1,73 @@
+package ui
+
+import (
+	"github.com/charmbracelet/bubbles/viewport"
+	"github.com/eslider/go-onlyoffice/cmd/office/model"
+)
+
+func (m *Model) scrollFocusedPane(key string) bool {
+	switch m.focus {
+	case model.FocusMenu:
+		return scrollViewport(&m.menuVP, key)
+	case model.FocusList:
+		switch key {
+		case "pgdown", "pgdn", "ctrl+d":
+			m.listTable.PageScroll(1)
+			return true
+		case "pgup", "b", "ctrl+u":
+			m.listTable.PageScroll(-1)
+			return true
+		}
+		return false
+	case model.FocusPreview:
+		if m.detail.Zone() != detailZoneContent {
+			return false
+		}
+		return m.detail.ScrollDocument(key)
+	default:
+		return false
+	}
+}
+
+func (m *Model) paneHeight() int {
+	h := m.height - 3
+	if h < 3 {
+		h = 3
+	}
+	return h
+}
+
+func (m *Model) paneInnerWidth(outer int) int {
+	if outer <= 0 {
+		return 8
+	}
+	w := outer - 2 // border only; content fills inner box
+	if w < 8 {
+		w = 8
+	}
+	return w
+}
+
+func scrollViewport(vp *viewport.Model, key string) bool {
+	switch key {
+	case "up", "k":
+		vp.LineUp(1)
+		return true
+	case "down", "j":
+		vp.LineDown(1)
+		return true
+	case "pgdown", "pgdn", "ctrl+d":
+		vp.ViewDown()
+		return true
+	case "pgup", "b", "ctrl+u":
+		vp.ViewUp()
+		return true
+	case "home", "g":
+		vp.GotoTop()
+		return true
+	case "end", "G":
+		vp.GotoBottom()
+		return true
+	}
+	return false
+}

cmd/office/ui/scrollbar.go

@@ -0,0 +1,76 @@
+package ui
+
+import (
+	"strings"
+
+	"github.com/charmbracelet/lipgloss"
+	"github.com/mattn/go-runewidth"
+)
+
+// ScrollbarMetrics computes thumb position for a vertical scrollbar.
+func ScrollbarMetrics(totalLines, viewportHeight, yOffset int) (show bool, thumbStart, thumbEnd int) {
+	if totalLines <= viewportHeight || viewportHeight < 1 {
+		return false, 0, 0
+	}
+	maxOff := totalLines - viewportHeight
+	if maxOff < 0 {
+		maxOff = 0
+	}
+	thumbSize := viewportHeight * viewportHeight / totalLines
+	if thumbSize < 1 {
+		thumbSize = 1
+	}
+	if thumbSize > viewportHeight {
+		thumbSize = viewportHeight
+	}
+	travel := viewportHeight - thumbSize
+	thumbStart = 0
+	if maxOff > 0 {
+		thumbStart = yOffset * travel / maxOff
+	}
+	return true, thumbStart, thumbStart + thumbSize
+}
+
+// ApplyVerticalScrollbar draws a 1-column scrollbar on the right when content overflows.
+func ApplyVerticalScrollbar(view string, width, height, totalLines, yOffset int) string {
+	show, thumbStart, thumbEnd := ScrollbarMetrics(totalLines, height, yOffset)
+	if !show || width < 2 {
+		return view
+	}
+	contentWidth := width - 1
+	lines := strings.Split(view, "\n")
+	for len(lines) < height {
+		lines = append(lines, "")
+	}
+	if len(lines) > height {
+		lines = lines[:height]
+	}
+	track := lipgloss.NewStyle().Foreground(lipgloss.Color("238"))
+	thumb := lipgloss.NewStyle().Foreground(lipgloss.Color("245"))
+	out := make([]string, height)
+	for row := 0; row < height; row++ {
+		line := padDisplayWidth(lines[row], contentWidth)
+		ch := "│"
+		style := track
+		if row >= thumbStart && row < thumbEnd {
+			ch = "█"
+			style = thumb
+		}
+		out[row] = line + style.Render(ch)
+	}
+	return strings.Join(out, "\n")
+}
+
+func padDisplayWidth(line string, width int) string {
+	if width < 1 {
+		return ""
+	}
+	w := runewidth.StringWidth(line)
+	if w > width {
+		return runewidth.Truncate(line, width, "")
+	}
+	if w < width {
+		line += strings.Repeat(" ", width-w)
+	}
+	return line
+}

cmd/office/ui/scrollbar_test.go

@@ -0,0 +1,32 @@
+package ui
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestScrollbarMetricsHiddenWhenFits(t *testing.T) {
+	show, _, _ := ScrollbarMetrics(5, 10, 0)
+	if show {
+		t.Fatal("expected no scrollbar when content fits")
+	}
+}
+
+func TestScrollbarMetricsVisibleWhenOverflow(t *testing.T) {
+	show, start, end := ScrollbarMetrics(100, 10, 50)
+	if !show || end <= start {
+		t.Fatalf("expected thumb, got %d..%d", start, end)
+	}
+}
+
+func TestApplyVerticalScrollbarAddsColumn(t *testing.T) {
+	view := "line1\nline2\nline3"
+	out := ApplyVerticalScrollbar(view, 12, 3, 10, 0)
+	lines := strings.Split(out, "\n")
+	if len(lines) != 3 {
+		t.Fatalf("lines=%d", len(lines))
+	}
+	if !strings.HasSuffix(lines[0], "█") && !strings.HasSuffix(lines[0], "│") {
+		t.Fatalf("expected scrollbar glyph: %q", lines[0])
+	}
+}

cmd/office/ui/table.go

@@ -0,0 +1,595 @@
+package ui
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+
+	"github.com/charmbracelet/bubbles/viewport"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/eslider/go-onlyoffice/cmd/office/model"
+	"github.com/mattn/go-runewidth"
+)
+
+type tableStyles struct {
+	title      lipgloss.Style
+	header     lipgloss.Style
+	headerSort lipgloss.Style
+	cell       lipgloss.Style
+	rowActive  lipgloss.Style
+	colActive  lipgloss.Style
+	cellActive lipgloss.Style
+	rowSelect  lipgloss.Style
+	cellSelect lipgloss.Style
+	help       lipgloss.Style
+}
+
+func defaultTableStyles() tableStyles {
+	return tableStyles{
+		title:      lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("252")),
+		header:     lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("255")).Background(lipgloss.Color("236")).Padding(0, 1),
+		headerSort: lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("229")).Background(lipgloss.Color("62")).Padding(0, 1),
+		cell:       lipgloss.NewStyle().Foreground(lipgloss.Color("252")).Padding(0, 1),
+		rowActive:  lipgloss.NewStyle().Foreground(lipgloss.Color("255")).Background(lipgloss.Color("238")),
+		colActive:  lipgloss.NewStyle().Foreground(lipgloss.Color("255")).Background(lipgloss.Color("237")),
+		cellActive: lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("255")).Background(lipgloss.Color("62")),
+		rowSelect:  lipgloss.NewStyle().Foreground(lipgloss.Color("255")).Background(lipgloss.Color("22")),
+		cellSelect: lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("255")).Background(lipgloss.Color("34")),
+		help:       lipgloss.NewStyle().Foreground(lipgloss.Color("241")),
+	}
+}
+
+// DataTable is a spreadsheet-style listContent table for the list pane.
+type DataTable struct {
+	spec      model.ListSpec
+	columns   []model.TableColumn
+	items     []model.Item
+	order     []int
+	cursorRow int
+	cursorCol int
+	colScroll int
+	sortCol   int
+	sortAsc   bool
+	focused   bool
+	ready     bool
+	loadingMore bool
+	width     int
+	height    int
+	viewport  viewport.Model
+	styles    tableStyles
+}
+
+func newDataTable() DataTable {
+	t := DataTable{
+		sortCol:  -1,
+		styles:   defaultTableStyles(),
+		viewport: viewport.New(40, 10),
+	}
+	t.viewport.MouseWheelEnabled = true
+	return t
+}
+
+func (t *DataTable) SetSize(w, h int) {
+	if w < 8 {
+		w = 8
+	}
+	if h < 3 {
+		h = 3
+	}
+	t.width = w
+	t.height = h
+	t.viewport.Width = w
+	t.viewport.Height = h - 2 // title + header
+	if t.viewport.Height < 1 {
+		t.viewport.Height = 1
+	}
+	t.refreshViewport()
+}
+
+func (t *DataTable) SetFocused(f bool) {
+	t.focused = f
+	t.refreshViewport()
+}
+
+func (t *DataTable) SetData(spec model.ListSpec, items []model.Item) {
+	t.spec = spec
+	t.items = items
+	t.columns = model.BuildColumns(spec.Subject, items)
+	t.order = make([]int, len(items))
+	for i := range t.order {
+		t.order[i] = i
+	}
+	t.cursorRow = 0
+	t.cursorCol = 0
+	t.colScroll = 0
+	t.ready = true
+	if t.sortCol >= 0 {
+		t.applySort()
+	}
+	t.clampCursor()
+	t.refreshViewport()
+}
+
+func (t *DataTable) Clear() {
+	t.ready = false
+	t.items = nil
+	t.order = nil
+	t.columns = nil
+	t.cursorRow = 0
+	t.cursorCol = 0
+	t.viewport.SetContent("")
+}
+
+func (t *DataTable) ItemIndex() int {
+	if t.cursorRow < 0 || t.cursorRow >= len(t.order) {
+		return -1
+	}
+	return t.order[t.cursorRow]
+}
+
+// CursorRow is the visual row index in the current table order.
+func (t DataTable) CursorRow() int {
+	return t.cursorRow
+}
+
+// Items returns the backing slice (after appends).
+func (t DataTable) Items() []model.Item {
+	return t.items
+}
+
+// NearEnd reports whether the cursor is within threshold rows of the last row.
+func (t DataTable) NearEnd(threshold int) bool {
+	if !t.ready || len(t.order) == 0 {
+		return false
+	}
+	return t.cursorRow >= len(t.order)-threshold
+}
+
+func (t *DataTable) SetLoadingMore(on bool) {
+	t.loadingMore = on
+}
+
+// AppendItems adds new rows, skipping duplicate IDs. Returns how many were added.
+func (t *DataTable) AppendItems(items []model.Item) int {
+	if !t.ready || len(items) == 0 {
+		return 0
+	}
+	seen := make(map[string]struct{}, len(t.items))
+	for _, it := range t.items {
+		if it.ID != "" {
+			seen[it.ID] = struct{}{}
+		}
+	}
+	added := 0
+	for _, it := range items {
+		if it.ID != "" {
+			if _, ok := seen[it.ID]; ok {
+				continue
+			}
+			seen[it.ID] = struct{}{}
+		}
+		idx := len(t.items)
+		t.items = append(t.items, it)
+		t.order = append(t.order, idx)
+		added++
+	}
+	if added > 0 {
+		if t.sortCol >= 0 {
+			t.applySort()
+		}
+		t.clampCursor()
+		t.refreshViewport()
+	}
+	return added
+}
+
+func (t *DataTable) MoveRow(delta int) {
+	if !t.ready || len(t.order) == 0 {
+		return
+	}
+	prev := t.cursorRow
+	t.cursorRow = clampInt(t.cursorRow+delta, 0, len(t.order)-1)
+	t.syncRowScroll(prev)
+	t.refreshViewport()
+}
+
+func (t *DataTable) MoveCol(delta int) {
+	if !t.ready || len(t.columns) == 0 {
+		return
+	}
+	t.cursorCol = clampInt(t.cursorCol+delta, 0, len(t.columns)-1)
+	t.ensureColVisible()
+	t.refreshViewport()
+}
+
+func (t *DataTable) ToggleSort() {
+	if !t.ready || len(t.columns) == 0 || len(t.order) == 0 {
+		return
+	}
+	if t.sortCol == t.cursorCol {
+		t.sortAsc = !t.sortAsc
+	} else {
+		t.sortCol = t.cursorCol
+		t.sortAsc = true
+	}
+	t.applySort()
+	t.refreshViewport()
+}
+
+func (t *DataTable) applySort() {
+	if t.sortCol < 0 || t.sortCol >= len(t.columns) {
+		return
+	}
+	key := t.columns[t.sortCol].Key
+	sort.SliceStable(t.order, func(i, j int) bool {
+		a := model.CellText(t.items[t.order[i]], key)
+		b := model.CellText(t.items[t.order[j]], key)
+		if t.sortAsc {
+			return strings.ToLower(a) < strings.ToLower(b)
+		}
+		return strings.ToLower(a) > strings.ToLower(b)
+	})
+}
+
+func (t *DataTable) PageScroll(delta int) {
+	if delta > 0 {
+		t.viewport.ViewDown()
+	} else {
+		t.viewport.ViewUp()
+	}
+}
+
+func (t *DataTable) Update(msg tea.Msg) tea.Cmd {
+	if !t.focused || !t.ready {
+		return nil
+	}
+	switch msg := msg.(type) {
+	case tea.KeyMsg:
+		switch msg.String() {
+		case "pgdown", "pgdn", "ctrl+d":
+			t.viewport.ViewDown()
+		case "pgup", "b", "ctrl+u":
+			t.viewport.ViewUp()
+		}
+	case tea.MouseMsg:
+		var cmd tea.Cmd
+		t.viewport, cmd = t.viewport.Update(msg)
+		return cmd
+	}
+	return nil
+}
+
+func (t DataTable) View() string {
+	if !t.ready {
+		return "List\n\nSelect a leaf node in the tree\n(marked with •) and press Enter.\n"
+	}
+	title := t.styles.title.Render(fmt.Sprintf("%s (%d)", t.spec.Subject, len(t.items)))
+	if t.loadingMore {
+		title += t.styles.help.Render("  …")
+	}
+	sortHint := ""
+	if t.sortCol >= 0 && t.sortCol < len(t.columns) {
+		dir := "▲"
+		if !t.sortAsc {
+			dir = "▼"
+		}
+		sortHint = t.styles.help.Render(fmt.Sprintf("  sort: %s %s", t.columns[t.sortCol].Title, dir))
+	}
+	header := t.renderHeader()
+	body := ApplyVerticalScrollbar(
+		t.viewport.View(),
+		t.viewport.Width,
+		t.viewport.Height,
+		t.viewport.TotalLineCount(),
+		t.viewport.YOffset,
+	)
+	content := lipgloss.JoinVertical(lipgloss.Left, title+sortHint, header, body)
+	return lipgloss.NewStyle().Width(t.width).Render(content)
+}
+
+func (t *DataTable) visibleLayout() (indices []int, widths map[int]int) {
+	widths = make(map[int]int)
+	if len(t.columns) == 0 || t.width <= 0 {
+		return nil, widths
+	}
+	indices = t.pickVisibleColumnIndices()
+	if len(indices) == 0 {
+		return indices, widths
+	}
+	minSum := 0
+	for _, i := range indices {
+		minSum += t.columns[i].Width
+	}
+	widths = distributeColumnWidths(minSum, t.width, indices, t.columns)
+	return indices, widths
+}
+
+func (t *DataTable) pickVisibleColumnIndices() []int {
+	var out []int
+	used := 0
+	for colIdx := t.colScroll; colIdx < len(t.columns); colIdx++ {
+		w := t.columns[colIdx].Width
+		if len(out) > 0 && used+w > t.width {
+			break
+		}
+		out = append(out, colIdx)
+		used += w
+	}
+	if len(out) == 0 {
+		colIdx := t.colScroll
+		if colIdx < 0 || colIdx >= len(t.columns) {
+			colIdx = 0
+		}
+		out = []int{colIdx}
+	}
+	return out
+}
+
+// distributeColumnWidths expands or shrinks visible columns to exactly fill total width.
+func distributeColumnWidths(minSum, total int, indices []int, cols []model.TableColumn) map[int]int {
+	out := make(map[int]int, len(indices))
+	if len(indices) == 0 {
+		return out
+	}
+	if total < len(indices) {
+		total = len(indices)
+	}
+	if minSum <= 0 {
+		each := total / len(indices)
+		if each < 1 {
+			each = 1
+		}
+		for _, i := range indices {
+			out[i] = each
+		}
+		fixColumnWidthSum(out, indices, total)
+		return out
+	}
+	for _, i := range indices {
+		out[i] = cols[i].Width
+	}
+	if minSum >= total {
+		for _, i := range indices {
+			out[i] = cols[i].Width * total / minSum
+			if out[i] < 1 {
+				out[i] = 1
+			}
+		}
+		fixColumnWidthSum(out, indices, total)
+		return out
+	}
+	extra := total - minSum
+	flex := make([]int, 0, len(indices))
+	for _, i := range indices {
+		switch cols[i].Key {
+		case "title", "subtitle", "description", "displayName", "primaryEmail", "from", "to", "tasks", "type":
+			flex = append(flex, i)
+		}
+	}
+	if len(flex) == 0 {
+		flex = append(flex, indices...)
+	}
+	flexSum := 0
+	for _, i := range flex {
+		flexSum += cols[i].Width
+	}
+	if flexSum <= 0 {
+		flexSum = len(flex)
+	}
+	for _, i := range flex {
+		out[i] += extra * cols[i].Width / flexSum
+	}
+	fixColumnWidthSum(out, indices, total)
+	return out
+}
+
+func fixColumnWidthSum(widths map[int]int, indices []int, total int) {
+	if len(indices) == 0 {
+		return
+	}
+	sum := 0
+	for _, i := range indices {
+		sum += widths[i]
+	}
+	widths[indices[len(indices)-1]] += total - sum
+	if widths[indices[len(indices)-1]] < 1 {
+		widths[indices[len(indices)-1]] = 1
+	}
+}
+
+const cellHPadding = 2 // lipgloss Padding(0, 1) on each side
+
+func truncateCellText(text string, colWidth int) string {
+	inner := colWidth - cellHPadding
+	if inner < 1 {
+		inner = 1
+	}
+	if runewidth.StringWidth(text) <= inner {
+		return text
+	}
+	return runewidth.Truncate(text, inner, "...")
+}
+
+func (t *DataTable) renderHeader() string {
+	indices, widths := t.visibleLayout()
+	cells := make([]string, 0, len(indices))
+	for _, colIdx := range indices {
+		col := t.columns[colIdx]
+		w := widths[colIdx]
+		title := col.Title
+		if t.sortCol == colIdx {
+			if t.sortAsc {
+				title += " ▲"
+			} else {
+				title += " ▼"
+			}
+		}
+		text := truncateCellText(title, w)
+		style := t.styles.header
+		if t.focused && colIdx == t.cursorCol {
+			style = t.styles.headerSort
+		}
+		cells = append(cells, style.Width(w).MaxWidth(w).Render(text))
+	}
+	return lipgloss.JoinHorizontal(lipgloss.Left, cells...)
+}
+
+func (t *DataTable) refreshViewport() {
+	if !t.ready {
+		return
+	}
+	rows := make([]string, 0, len(t.order))
+	for row := 0; row < len(t.order); row++ {
+		rows = append(rows, t.renderRow(row))
+	}
+	t.viewport.SetContent(strings.Join(rows, "\n"))
+	t.syncRowScroll(t.cursorRow)
+}
+
+func (t *DataTable) renderRow(row int) string {
+	item := t.items[t.order[row]]
+	selected := item.Selected
+	fullRow := row == t.cursorRow || selected
+	indices, widths := t.visibleLayout()
+	cells := make([]string, 0, len(indices))
+	for _, colIdx := range indices {
+		col := t.columns[colIdx]
+		w := widths[colIdx]
+		raw := strings.TrimSpace(model.CellText(item, col.Key))
+		text := raw
+		if !fullRow {
+			text = truncateCellText(raw, w)
+		}
+		cells = append(cells, t.styleCell(row, colIdx, col.Key, selected, item, text, w, fullRow))
+	}
+	return lipgloss.JoinHorizontal(lipgloss.Left, cells...)
+}
+
+func applyCellWidth(s lipgloss.Style, width int, full bool) lipgloss.Style {
+	if full {
+		return s
+	}
+	return s.Width(width).MaxWidth(width)
+}
+
+func (t *DataTable) styleCell(row, col int, colKey string, selected bool, item model.Item, text string, width int, fullWidth bool) string {
+	isRow := row == t.cursorRow
+	isCol := col == t.cursorCol
+	isCell := t.focused && isRow && isCol
+
+	var base lipgloss.Style
+	switch {
+	case selected && isCell:
+		base = t.styles.cellSelect
+	case selected && isRow:
+		base = t.styles.rowSelect
+	case selected:
+		base = t.styles.rowSelect
+	case isCell:
+		base = t.styles.cellActive
+	case t.focused && isRow:
+		base = t.styles.rowActive
+	case t.focused && isCol:
+		base = t.styles.colActive
+	default:
+		base = t.styles.cell
+	}
+	base = t.applyProjectRowStyle(base, item, colKey)
+	return applyCellWidth(base, width, fullWidth).Render(text)
+}
+
+func (t *DataTable) applyProjectRowStyle(base lipgloss.Style, item model.Item, colKey string) lipgloss.Style {
+	if t.spec.Subject != model.SubjectProjects {
+		return base
+	}
+	open := model.ProjectIsOpen(item.Raw)
+	if colKey == "status" {
+		if open {
+			return base.Foreground(lipgloss.Color("42")).Bold(true)
+		}
+		return base.Foreground(lipgloss.Color("245"))
+	}
+	if open {
+		return base.Background(lipgloss.Color("22")).Foreground(lipgloss.Color("255"))
+	}
+	return base.Background(lipgloss.Color("238")).Foreground(lipgloss.Color("252"))
+}
+
+func (t *DataTable) ensureColVisible() {
+	vis := t.pickVisibleColumnIndices()
+	if len(vis) == 0 {
+		return
+	}
+	first, last := vis[0], vis[len(vis)-1]
+	if t.cursorCol < first {
+		t.colScroll = t.cursorCol
+	}
+	if t.cursorCol > last {
+		t.colScroll = t.cursorCol
+		for t.cursorCol >= 0 {
+			vis = t.pickVisibleColumnIndices()
+			if len(vis) == 0 {
+				break
+			}
+			last = vis[len(vis)-1]
+			if t.cursorCol <= last {
+				break
+			}
+			if t.colScroll < len(t.columns)-1 {
+				t.colScroll++
+			} else {
+				break
+			}
+		}
+	}
+}
+
+func (t *DataTable) syncRowScroll(prev int) {
+	if t.cursorRow < t.viewport.YOffset {
+		t.viewport.YOffset = t.cursorRow
+	} else if t.cursorRow >= t.viewport.YOffset+t.viewport.Height {
+		t.viewport.YOffset = t.cursorRow - t.viewport.Height + 1
+	}
+	if t.viewport.YOffset < 0 {
+		t.viewport.YOffset = 0
+	}
+	maxOff := len(t.order) - t.viewport.Height
+	if maxOff < 0 {
+		maxOff = 0
+	}
+	if t.viewport.YOffset > maxOff {
+		t.viewport.YOffset = maxOff
+	}
+	_ = prev
+}
+
+func (t *DataTable) clampCursor() {
+	if len(t.order) == 0 {
+		t.cursorRow = 0
+	} else {
+		t.cursorRow = clampInt(t.cursorRow, 0, len(t.order)-1)
+	}
+	if len(t.columns) == 0 {
+		t.cursorCol = 0
+	} else {
+		t.cursorCol = clampInt(t.cursorCol, 0, len(t.columns)-1)
+	}
+}
+
+func clampInt(v, lo, hi int) int {
+	if v < lo {
+		return lo
+	}
+	if v > hi {
+		return hi
+	}
+	return v
+}
+
+// tableKeyMatches helps avoid importing key in app.go for sort-only bindings.
+func (t *DataTable) UpdateItems(items []model.Item) {
+	t.items = items
+	t.clampCursor()
+	t.refreshViewport()
+}

cmd/office/ui/table_append_test.go

@@ -0,0 +1,40 @@
+package ui
+
+import (
+	"testing"
+
+	"github.com/eslider/go-onlyoffice/cmd/office/model"
+)
+
+func TestDataTableAppendItemsDedupes(t *testing.T) {
+	tbl := newDataTable()
+	tbl.SetSize(40, 10)
+	tbl.SetData(model.ListSpec{Subject: model.SubjectMailInbox}, []model.Item{
+		{ID: "1", Title: "A", Kind: model.KindMail},
+	})
+	added := tbl.AppendItems([]model.Item{
+		{ID: "1", Title: "dup", Kind: model.KindMail},
+		{ID: "2", Title: "B", Kind: model.KindMail},
+	})
+	if added != 1 || len(tbl.Items()) != 2 {
+		t.Fatalf("added=%d len=%d", added, len(tbl.Items()))
+	}
+}
+
+func TestDataTableNearEnd(t *testing.T) {
+	tbl := newDataTable()
+	tbl.SetSize(40, 10)
+	items := make([]model.Item, 10)
+	for i := range items {
+		items[i] = model.Item{ID: string(rune('0' + i)), Title: "x", Kind: model.KindMail}
+	}
+	tbl.SetData(model.ListSpec{Subject: model.SubjectMailInbox}, items)
+	tbl.cursorRow = 7
+	if !tbl.NearEnd(3) {
+		t.Fatal("expected near end")
+	}
+	tbl.cursorRow = 0
+	if tbl.NearEnd(3) {
+		t.Fatal("expected not near end")
+	}
+}

cmd/office/ui/table_test.go

@@ -0,0 +1,148 @@
+package ui
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/eslider/go-onlyoffice/cmd/office/model"
+	"github.com/mattn/go-runewidth"
+)
+
+func sampleItems() []model.Item {
+	return []model.Item{
+		{ID: "2", Title: "Bravo", Subtitle: "b", Kind: model.KindTask, Raw: map[string]any{"status": "Open"}},
+		{ID: "1", Title: "Alpha", Subtitle: "a", Kind: model.KindTask, Raw: map[string]any{"status": "Done"}},
+	}
+}
+
+func TestDataTableSortByTitle(t *testing.T) {
+	tbl := newDataTable()
+	tbl.SetSize(80, 12)
+	tbl.SetData(model.ListSpec{Subject: model.SubjectTasks}, sampleItems())
+	tbl.cursorCol = indexOfColumn(tbl, "title")
+	tbl.ToggleSort()
+	if model.CellText(tbl.items[tbl.order[0]], "title") != "Alpha" {
+		t.Fatalf("expected Alpha first after sort, order=%v", tbl.order)
+	}
+}
+
+func TestDataTableMoveColScrolls(t *testing.T) {
+	tbl := newDataTable()
+	tbl.SetSize(24, 10)
+	items := make([]model.Item, 1)
+	items[0] = model.Item{ID: "1", Title: "One", Raw: map[string]any{
+		"alpha": "a", "beta": "b", "gamma": "c", "delta": "d",
+	}}
+	tbl.SetData(model.ListSpec{Subject: model.SubjectContacts}, items)
+	last := len(tbl.columns) - 1
+	tbl.cursorCol = last
+	tbl.ensureColVisible()
+	if tbl.colScroll == 0 && last > 2 {
+		t.Fatalf("expected horizontal scroll for wide table, colScroll=%d", tbl.colScroll)
+	}
+}
+
+func TestDataTableViewHighlightsActiveCell(t *testing.T) {
+	tbl := newDataTable()
+	tbl.SetSize(80, 12)
+	tbl.SetFocused(true)
+	tbl.SetData(model.ListSpec{Subject: model.SubjectTasks}, sampleItems())
+	tbl.cursorRow = 1
+	tbl.cursorCol = 2
+	view := tbl.View()
+	if !strings.Contains(view, "Alpha") {
+		t.Fatal("view missing row data")
+	}
+	if !strings.Contains(view, "Title") {
+		t.Fatal("view missing header")
+	}
+}
+
+func TestDataTableFillsPaneWidth(t *testing.T) {
+	tbl := newDataTable()
+	tbl.SetSize(80, 12)
+	tbl.SetData(model.ListSpec{Subject: model.SubjectTasks}, sampleItems())
+	indices, widths := tbl.visibleLayout()
+	sum := 0
+	for _, i := range indices {
+		sum += widths[i]
+	}
+	if sum != 80 {
+		t.Fatalf("visible columns width sum=%d want 80", sum)
+	}
+}
+
+func TestDistributeColumnWidthsFillsTotal(t *testing.T) {
+	cols := []model.TableColumn{
+		{Key: "_sel", Width: 3},
+		{Key: "id", Width: 10},
+		{Key: "title", Width: 20},
+	}
+	indices := []int{0, 1, 2}
+	w := distributeColumnWidths(33, 80, indices, cols)
+	sum := w[0] + w[1] + w[2]
+	if sum != 80 {
+		t.Fatalf("sum=%d want 80", sum)
+	}
+	if w[2] <= 20 {
+		t.Fatalf("title should expand, got %d", w[2])
+	}
+}
+
+func TestTruncateCellText(t *testing.T) {
+	long := strings.Repeat("x", 40)
+	got := truncateCellText(long, 10)
+	if runewidth.StringWidth(got) > 10 {
+		t.Fatalf("truncated width=%d want <=10", runewidth.StringWidth(got))
+	}
+	if !strings.HasSuffix(got, "...") {
+		t.Fatalf("expected ellipsis suffix, got %q", got)
+	}
+}
+
+func TestDataTableTruncatesNonSelectedRows(t *testing.T) {
+	long := strings.Repeat("A", 60)
+	items := []model.Item{
+		{ID: "1", Title: "Short"},
+		{ID: "2", Title: long},
+	}
+	tbl := newDataTable()
+	tbl.SetSize(50, 10)
+	tbl.SetData(model.ListSpec{Subject: model.SubjectTasks}, items)
+	tbl.cursorRow = 0
+
+	if strings.Contains(tbl.renderRow(1), long) {
+		t.Fatal("non-cursor row should truncate long title")
+	}
+
+	tbl.cursorRow = 1
+	if !strings.Contains(tbl.renderRow(1), long) {
+		t.Fatal("cursor row should show full title")
+	}
+}
+
+func TestDataTableShowsFullTextWhenSpaceSelected(t *testing.T) {
+	long := strings.Repeat("B", 60)
+	items := []model.Item{
+		{ID: "1", Title: "Short"},
+		{ID: "2", Title: long, Selected: true},
+	}
+	tbl := newDataTable()
+	tbl.SetSize(50, 10)
+	tbl.SetData(model.ListSpec{Subject: model.SubjectTasks}, items)
+	tbl.cursorRow = 0
+
+	rowSelected := tbl.renderRow(1)
+	if !strings.Contains(rowSelected, long) {
+		t.Fatal("space-selected row should show full title")
+	}
+}
+
+func indexOfColumn(tbl DataTable, key string) int {
+	for i, c := range tbl.columns {
+		if c.Key == key {
+			return i
+		}
+	}
+	return 0
+}

projects.go

@@ -204,3 +204,15 @@ func (c *Client) UpdateProject(req ProjectUpdateRequest) (*Project, error) {
 			Response *Project `json:"response"`
 		}{p})
 }
+
+// UpdateProjectStatus sets project lifecycle status (open, paused, closed).
+func (c *Client) UpdateProjectStatus(id int, status string) (*Project, error) {
+	p := &Project{}
+	return p, c.Query(Request{
+		Uri:    fmt.Sprintf("/api/2.0/project/%d/status", id),
+		Method: "PUT",
+		Body:   map[string]string{"status": status},
+	}, &struct {
+		Response *Project `json:"response"`
+	}{p})
+}