feat(data): first-class Data mode for project inventory and reclassification

Replace the Activity-page project-reclassification affordances with a
dedicated Data mode:

- New read-only Data API group on all stores (SQLite, PostgreSQL, DuckDB):
  project inventory with summary totals, per-machine project rules with
  governed counts, and archive-wide reclassification candidates selected
  by (display label, project key).
- Svelte Data page: sortable/filterable inventory table, project
  workspace with the extracted ProjectReclassificationEditor
  (prefix edit, debounced preview, atomic apply, after-apply selection
  rules), and the relocated worktree mapping Rules view; Activity project
  labels become plain links into Data.
- Remove the legacy Activity-scoped candidates endpoint, its SQLite-only
  db method, and the generated client method; regenerate the API client.
- Parser: recognize the generic github.com worktree layout marker and
  bump dataVersion to force reparse; chunk project-identity label
  lookups on all backends to stay under bind-variable limits.
- PostgreSQL: split push vs serve schema probes, exempt filtered pushes
  from the provenance backfill marker.
- E2E: new data-mode Playwright spec covering the full writable flow and
  DuckDB-gated read-only variants; wired into e2e-duckdb.

Additional branch commits:

- docs: remove superpowers artifacts and document the Data page
- docs: describe Data page relative to shipped Settings surface

Author: wesm

.github/workflows/ci.yml

@@ -118,6 +118,7 @@ jobs:
         run: |
           bash scripts/install_test.sh
           bash scripts/retry_test.sh
+          bash scripts/e2e-server_test.sh
           bash scripts/check_desktop_release_health_test.sh
           bash scripts/check_desktop_release_health_from_event_test.sh
           bash desktop/scripts/test-repair-appimage-diricon.sh
@@ -362,3 +363,9 @@ jobs:
         env:
           E2E_PREBUILT_FIXTURE: /tmp/testfixture
           E2E_PREBUILT_SERVER: /tmp/agentsview
+
+      - name: Run DuckDB E2E tests
+        run: make e2e-duckdb
+        env:
+          E2E_PREBUILT_FIXTURE: /tmp/testfixture
+          E2E_PREBUILT_SERVER: /tmp/agentsview

.gitignore

@@ -67,9 +67,9 @@ docs/.env*.local
 testdata/ssh/test_key
 
 # Local data
-data/
-sessions/
-html/
+/data/
+/sessions/
+/html/
 .superset/
 .github/hooks/
 .superpowers/

Makefile

@@ -378,7 +378,8 @@ e2e:
 # Run focused Playwright smoke tests against duckdb serve.
 e2e-duckdb:
 	cd frontend && AGENTSVIEW_E2E_BACKEND=duckdb npx playwright test \
-		e2e/duckdb-backend.spec.ts e2e/session-list.spec.ts --project=chromium
+		e2e/duckdb-backend.spec.ts e2e/data-mode.spec.ts \
+		e2e/session-list.spec.ts --project=chromium
 
 # Vet
 vet: pricing-snapshot ensure-embed-dir

cmd/testfixture/main.go

@@ -12,6 +12,7 @@ import (
 
 	"go.kenn.io/agentsview/internal/db"
 	duckdbsync "go.kenn.io/agentsview/internal/duckdb"
+	"go.kenn.io/agentsview/internal/export"
 )
 
 type sessionSpec struct {
@@ -118,6 +119,12 @@ func main() {
 		log.Fatalf("creating recent-edits fixture: %v", err)
 	}
 
+	if err := createProjectReclassificationFixture(
+		database, base.Add(120*time.Hour),
+	); err != nil {
+		log.Fatalf("creating project-reclassification fixture: %v", err)
+	}
+
 	fmt.Printf("Fixture DB written to %s\n", *out)
 	if *duckDBOut != "" {
 		if err := writeDuckDBMirror(database, *duckDBOut); err != nil {
@@ -127,6 +134,80 @@ func main() {
 	}
 }
 
+func createProjectReclassificationFixture(
+	database *db.DB, start time.Time,
+) error {
+	const (
+		machine      = "remote-example-host"
+		project      = "wrong_branch_label"
+		worktreeRoot = "/srv/worktrees/github.com/example-org/sample-service/example-worktree"
+		model        = "claude-sonnet-4-20250514"
+	)
+	cwds := []struct {
+		suffix string
+		cwd    string
+	}{
+		{suffix: "root", cwd: worktreeRoot},
+		{suffix: "nested", cwd: worktreeRoot + "/cmd/server"},
+	}
+	ctx := context.Background()
+	for index, item := range cwds {
+		sessionID := "test-session-project-reclassification-" + item.suffix
+		startedAt := start.Add(time.Duration(index) * time.Hour)
+		endedAt := startedAt.Add(12 * time.Minute)
+		firstMessage := "Inspect the sample service worktree."
+		session := db.Session{
+			ID:               sessionID,
+			Project:          project,
+			Machine:          machine,
+			Agent:            "claude",
+			StartedAt:        new(startedAt.Format(time.RFC3339Nano)),
+			EndedAt:          new(endedAt.Format(time.RFC3339Nano)),
+			MessageCount:     2,
+			UserMessageCount: 1,
+			FirstMessage:     new(firstMessage),
+			Cwd:              item.cwd,
+		}
+		if err := database.UpsertSession(session); err != nil {
+			return fmt.Errorf(
+				"upserting project-reclassification session: %w", err,
+			)
+		}
+		if err := database.InsertMessages(generateMessages(
+			sessionID, session.MessageCount, startedAt, model,
+		)); err != nil {
+			return fmt.Errorf(
+				"inserting project-reclassification messages: %w", err,
+			)
+		}
+		if err := database.UpsertProjectIdentityObservation(
+			ctx,
+			export.ProjectIdentityObservation{
+				SessionID:            sessionID,
+				Project:              project,
+				Machine:              machine,
+				RootPath:             worktreeRoot,
+				RepositoryPath:       "/srv/worktrees/github.com/example-org/sample-service",
+				WorktreeName:         "example-worktree",
+				WorktreeRootPath:     worktreeRoot,
+				WorktreeRelationship: export.WorktreeLinked,
+				CheckoutState:        export.CheckoutBranch,
+				GitBranch:            "example-worktree",
+				ObservedAt:           startedAt,
+			},
+		); err != nil {
+			return fmt.Errorf(
+				"upserting project-reclassification identity: %w", err,
+			)
+		}
+		fmt.Printf(
+			"  %s: %d messages (project reclassification)\n",
+			sessionID, session.MessageCount,
+		)
+	}
+	return nil
+}
+
 func writeDuckDBMirror(database *db.DB, path string) error {
 	if err := os.Remove(path); err != nil &&
 		!errors.Is(err, os.ErrNotExist) {

cmd/testfixture/main_test.go

@@ -0,0 +1,53 @@
+package main
+
+import (
+	"context"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"go.kenn.io/agentsview/internal/db"
+)
+
+func TestCreateProjectReclassificationFixture(t *testing.T) {
+	database, err := db.Open(filepath.Join(t.TempDir(), "sessions.db"))
+	require.NoError(t, err)
+	t.Cleanup(func() { require.NoError(t, database.Close()) })
+
+	base := time.Date(2026, 7, 1, 10, 0, 0, 0, time.UTC)
+	require.NoError(t, createProjectReclassificationFixture(database, base))
+
+	const (
+		machine      = "remote-example-host"
+		wrongProject = "wrong_branch_label"
+		worktreeRoot = "/srv/worktrees/github.com/example-org/sample-service/example-worktree"
+	)
+	wantCwds := map[string]string{
+		"test-session-project-reclassification-root":   worktreeRoot,
+		"test-session-project-reclassification-nested": worktreeRoot + "/cmd/server",
+	}
+	for sessionID, wantCwd := range wantCwds {
+		session, getErr := database.GetSession(context.Background(), sessionID)
+		require.NoError(t, getErr)
+		require.NotNil(t, session)
+		assert.Equal(t, machine, session.Machine)
+		assert.Equal(t, wrongProject, session.Project)
+		assert.Equal(t, wantCwd, session.Cwd)
+	}
+
+	snapshots, err := database.ListSessionProjectIdentitySnapshots(
+		context.Background(),
+	)
+	require.NoError(t, err)
+	require.Len(t, snapshots, 2)
+	for _, snapshot := range snapshots {
+		assert.Equal(t, machine, snapshot.Machine)
+		assert.Equal(t, wrongProject, snapshot.Project)
+		assert.Equal(t, worktreeRoot, snapshot.RootPath)
+		assert.Equal(t, worktreeRoot, snapshot.WorktreeRootPath)
+		assert.NotEmpty(t, snapshot.Key)
+	}
+}

docs/activity.md

@@ -106,6 +106,17 @@ allocates that total across usage rows in proportion to their catalog-price
 estimates. The per-model costs are therefore estimated attributions, not
 provider-reported model charges, but they still sum to the displayed total.
 
+## Reclassify A Project
+
+Worktree layouts the parser does not recognize can surface a branch or
+worktree directory name as a project. Each row in the **Project** breakdown
+links to that project on the [Data page](/data/), where the reclassification
+editor suggests a path prefix from the project's worktree evidence, previews
+the full-archive impact, and applies a
+[worktree project mapping](/configuration/#worktree-project-mappings) rule in
+one atomic step. Cleaning always evaluates the complete archive; the current
+Activity range and filters do not carry over.
+
 ## Activity Insight
 
 At the bottom of the page, **Activity Insight** shows an existing global

docs/configuration.md

@@ -689,27 +689,43 @@ manual sync, and the periodic directory scan.
 
 ### Worktree Project Mappings
 
-The parser infers a session's project from its `cwd`, which works for standard
-layouts but not custom worktree conventions like
-`~/code/{project}.worktrees/feat/<branch>/` — those sessions otherwise group
-under `<branch>` rather than `{project}`. As of 0.29.0, you can register manual
-**path-prefix → project** rules from the **Worktree Project Mappings** section
-in Settings:
-
-![Worktree Project Mappings settings section](/assets/generated/screenshots/worktree-mappings.png)
+The parser infers a session's project from its `cwd`. It recognizes common
+worktree manager layouts, including the generic
+`worktrees/github.com/<owner>/<repository>/<worktree>` convention, where the
+repository segment becomes the project. Layouts it does not recognize — such
+as `~/code/{project}.worktrees/feat/<branch>/` — otherwise group sessions
+under `<branch>` rather than `{project}`. For those, register manual
+**path-prefix → project** rules from the **Rules** view on the
+[Data page](/data/#rules), or let the
+[reclassification editor](/data/#reclassify-a-project) create one from a
+project's worktree evidence:
+
+![Worktree mapping rules on the Data page](/assets/generated/screenshots/worktree-mappings.png)
 
 - Mappings are explicit; there is no auto-discovery.
+- Each rule is scoped to one machine. The machine selector manages rules for
+  the local machine and for any remotely synced machine. Rules live in the
+  writable archive that ingests that machine's sessions, which may be the
+  source machine's local SQLite archive or a separate collector archive.
 - Each rule applies whenever a session's `cwd` falls under the configured
   prefix, on both new sessions as they sync and (via the **Apply** button)
-  already-imported sessions.
+  already-imported sessions. Prefixes match on directory boundaries, so
+  `/worktrees/service` does not match `/worktrees/service-old`.
+- Enabled mappings run after parser inference, so an explicit rule always wins
+  when the two disagree.
 - The default `explicit` layout maps every matching path to the project name
   stored on the rule. The `repo_dot_worktrees` layout derives the project from
   the first path segment under the prefix when it is named `<repo>.worktrees`,
   so a path like `/code/agentsview.worktrees/feature/frontend` resolves to
   project `agentsview`.
-- Rules are stored in a `worktree_project_mappings` SQLite table scoped to the
-  host machine, so a mapping created on one machine does not leak into another
-  machine's view of synced sessions.
+- Rules created from the Data reclassification editor record the mislabeled
+  project they corrected, shown as the rule's **original label**. The value is
+  informational and set once; to manually revert a reclassification, edit the
+  rule's target back to that original label and apply again.
+- Disabling or deleting a rule does not rewrite sessions by itself. Sessions
+  whose source files still exist revert to parser-derived names on a later
+  reparse or full resync, while orphaned sessions keep their stored
+  classification.
 - Excluded, trashed, and skipped session files are left alone.
 
 Mappings only mutate the session's `project` field; the rest of the session

docs/data.md

@@ -0,0 +1,76 @@
+---
+title: Data
+description: Project inventory, reclassification, and worktree mapping rules
+---
+
+The **Data** page is where you inspect and clean project classification across
+the whole archive. It is the home of the worktree mapping rules that previously
+lived in the Settings **Worktree mappings** section.
+
+Open it from the **Data** tab in the header, or follow a project link from the
+[Activity breakdown](/activity/#breakdowns). Deep links are stable:
+`/data?project_key=<key>` selects a project, and `/data?view=rules` opens the
+[Rules view](#rules).
+
+## Project Inventory
+
+The default view lists every project in the archive with its session, machine,
+agent, and working-directory counts plus first and last activity timestamps. A
+summary strip totals the projects, sessions, and the sessions currently governed
+by classification rules.
+
+- The table is sortable by any column and filterable by project name.
+- Projects targeted by enabled rules carry a rule badge; projects recorded as a
+  rule's original label carry an original-label badge.
+- Sessions whose stored project label is empty are grouped under a single
+  "unknown" row.
+- Activity bounds come from session timestamps only; rows without any recorded
+  timestamps show a no-activity state.
+
+Selecting a row opens the project workspace. Unknown `project_key` deep links
+show the full inventory with a non-blocking notice.
+
+## Reclassify A Project
+
+The workspace embeds the reclassification editor, which works through the
+[worktree project mapping](/configuration/#worktree-project-mappings) system:
+
+- It lists the worktrees that produced the project's sessions across the entire
+  archive, grouped by machine and worktree evidence. A single group is
+  preselected; several groups require an explicit choice, because different
+  worktrees usually need different target projects.
+- The suggested **path prefix** covers the selected group's working directories.
+  You can edit it — for example, shorten it to cover sibling worktrees of the
+  same repository.
+- The **target project** typeahead suggests known projects and accepts a new
+  name. When the server normalizes the name (for example `sample-service`
+  becomes `sample_service`), the editor shows the stored form before you
+  apply.
+- The **full archive impact** preview is live and authoritative: it counts
+  matching sessions across all dates for that machine. A prefix that touches
+  more than one existing project shows a warning with per-project counts —
+  usually a sign the prefix is too broad. A prefix matching zero sessions
+  cannot be applied.
+
+**Apply** saves the rule and rewrites the matching sessions in one atomic step,
+then reloads the inventory. If the applied rule renamed the selected project,
+the selection follows the new name. If mappings changed between preview and
+apply, the apply is rejected and a fresh preview is required.
+
+## Rules
+
+The **Rules** toggle shows the worktree mapping rules for one machine at a time,
+with the same add, edit, apply, and delete controls that Settings previously
+offered — see
+[Worktree Project Mappings](/configuration/#worktree-project-mappings) for the
+full rule semantics. Each rule row also shows its **governed sessions** count
+(how many sessions the rule currently classifies) and the **original label**
+recorded when the rule was created through the reclassification editor. Rule
+targets link back to the corresponding inventory row.
+
+## Read-Only Servers
+
+On a read-only server (`pg serve` or `duckdb serve`) the inventory, the
+candidate evidence, and the Rules table remain fully readable, but the editor
+and rule mutations are replaced by a notice: classification rules are managed
+from the writable archive that ingests the machine's sessions.

docs/screenshots/extract-db.sh

@@ -290,6 +290,8 @@ DELETE FROM session_project_identity_snapshots;
 DELETE FROM project_identity_observation_changes;
 DELETE FROM session_project_identity_snapshot_changes;
 DELETE FROM worktree_project_mappings;
+-- The mapping delete above journals tombstones, so clear that journal last.
+DELETE FROM worktree_project_mapping_changes;
 
 -- Keep generated screenshots independent of the source machine's hostname.
 -- The PostgreSQL fixture relabels a subset as work-desktop after push so the

docs/screenshots/tests/screenshots.spec.ts

@@ -1116,24 +1116,20 @@ test.describe('Settings', () => {
   });
 
   test('worktree project mappings section', async ({ page }) => {
-    await openSettings(page);
-
-    // SettingsSection renders a heading with the title prop;
-    // match the section that contains the "Worktree mappings"
-    // header text, the same pattern used for Remote Access above.
-    const worktreeSection = page.locator(
-      '.settings-section:has-text("Worktree mappings")'
-    );
-    await expect(worktreeSection.first()).toBeVisible({
-      timeout: 5_000,
+    // Mapping rules moved from Settings to the Data page's Rules view.
+    await page.goto('/data?view=rules');
+
+    const rulesView = page.locator('section.rules-view');
+    await expect(rulesView).toBeVisible({ timeout: 5_000 });
+    await rulesView.scrollIntoViewIfNeeded();
+    const mappingPath = rulesView.getByRole('textbox', {
+      name: 'Path prefix',
     });
-    await worktreeSection.first().scrollIntoViewIfNeeded();
-    const mappingPath = worktreeSection.first().getByRole('textbox').first();
     await mappingPath.fill('~/code/project.worktrees');
     await expect(mappingPath).toHaveValue('~/code/project.worktrees');
     await page.waitForTimeout(500);
 
-    await snapEl(worktreeSection.first(), 'worktree-mappings');
+    await snapEl(rulesView, 'worktree-mappings');
   });
 });