TabHub

Local tab manager for several Chromium browsers with a REST, MCP, and web interface. The server listens only on 127.0.0.1.

Requirements

• Windows 10/11

• Node.js 22+

• Corepack (corepack enable)

Running

corepack pnpm install
Copy-Item .env.example .env
corepack pnpm dev

Personal-context local capability

The first-class context routes are fail-closed behind TABHUB_FEATURE_CONTEXT=true. Production /app navigation receives an opaque HttpOnly; SameSite=Strict local session. During Vite development, set a random server-only TABHUB_DEV_PROXY_SECRET; the Vite proxy must call POST /api/local/session/bootstrap and inject the matching x-tabhub-dev-proxy-secret header. Never use a VITE_ variable for this value or expose it to browser code. The bootstrap secret, bearer credentials, pairing codes, context bodies, raw search queries, and idempotency keys are excluded from request logs.

The command first builds the web interface, then starts the server. Open http://127.0.0.1:7717/app/.

The web interface is available in English and Russian. The language can be selected in the app header; the choice is saved in the browser. The popup and extension settings automatically use the browser interface language if it is English or Russian.

Server check:

Invoke-RestMethod http://127.0.0.1:7717/api/health

The currently expected response is:

{"status":"ok","database":"ok","schemaVersion":26}

The database is created by default at data/tabhub.sqlite relative to the repository root. The path can be changed via TABHUB_DB_PATH in the root .env.

TABHUB_FEATURE_LOGICAL_IMPORTANCE=false keeps the previous importance editor for an individual physical tab and disables the new logical-page endpoints. The value true enables a single canonical importance score for all copies of one URL page. Restart the server after changing the flag. For a safe rollback, return it to false: stored canonical data is not deleted, but the legacy interface neither reads nor modifies it.

For UI development with hot reload, start the server and Vite with a single command, then open the Vite address from the console:

corepack pnpm dev:web

TABHUB_FEATURE_RESOURCES=true enables the Resource backend and REST API: resource list/detail/pages/all-time activity, resource context, commands, user evaluation, and resource_id intersections for tab/instance selections. The Resource UI facet arrives in W30 and is not enabled by this server flag alone. Set the flag back to false and restart for a safe rollback: stored mappings, context, and evaluations remain isolated and are neither deleted nor exposed by resource routes.

The exact-copy capture and Drawer Short/Deep page-summary flow is independently fail-closed behind TABHUB_FEATURE_PAGE_SUMMARY_CAPTURE=true. It deliberately does not reuse the Resource research flag: a deep page summary still analyzes one captured page, while research has separate corpus, evidence, budget, and consent semantics. With this flag off (the default), /api/features reports pageSummaryCapture: false, the HTTP relay rejects only capture-tab-content before extension dispatch, and the exact-instance ingest route is absent. Ordinary content ingest, the existing Library short-summary action for already captured content, and activation/close/workspace MCP commands remain available. Restart the server after changing the flag; set it back to false for the schema-compatible rollback surface.

Captured-only Resource/page research is independently default-off behind TABHUB_FEATURE_RESEARCH=true. Schema 24 is installed unconditionally so existing research history and privacy redaction remain readable when the flag is returned to false; the disabled flag blocks only new preflight, run and research-cancel mutations. Execution additionally requires ANTHROPIC_API_KEY. Without a provider, preflight, history, job reads and privacy redaction remain available, while run/refine fail before writing with 503 RESEARCH_PROVIDER_UNAVAILABLE.

The provider uses ANTHROPIC_RESEARCH_MODEL, immutable startup prices from ANTHROPIC_RESEARCH_INPUT_USD_PER_MTOK and ANTHROPIC_RESEARCH_OUTPUT_USD_PER_MTOK, and an optional explicit ANTHROPIC_RESEARCH_PRICING_VERSION. When the version is blank, TabHub derives one from the effective prices. TABHUB_RESEARCH_MAX_OUTPUT_TOKENS is capped at 8192 and TABHUB_RESEARCH_TIMEOUT_MS bounds one call. The worker permits one concurrent call, ten attempts and USD 2 of reservation per UTC day, while every run must also fit its user-approved budget. Research consumes only the captured approved corpus: it never fetches, opens or navigates to a URL. Restart the server after changing any research flag or provider setting.

Schema-26 bounded live acquisition is independently default-off behind TABHUB_FEATURE_LIVE_ACQUISITION=true. When enabled, the accepted C90b coordinator exposes Resource-only preflight/start/status flows, uses the closed server-internal SafePublicHttpClient, materializes bounded public evidence, and hands an immutable captured/live corpus to the existing research workflow. It does not expose a generic fetch endpoint and never uses browser navigation, extension fetches, redirects, retries, scripts, subrequests, or tab/window mutation. Keep the flag false outside an explicitly reviewed rollout.

TABHUB_FEATURE_PRIVACY_PURGE=true enables creation of new durable privacy purges. Existing schema-26 purge status and retry/recovery remain available when the flag is off so disabling new work cannot strand an active purge.

Daily activity is controlled by two independent, fail-closed flags. Set TABHUB_FEATURE_ACTIVITY_DAILY_WRITER=true to collect accepted activity into UTC daily buckets and update gap/duplicate/out-of-order metrics. Set TABHUB_FEATURE_ACTIVITY_WINDOWS=true together with TABHUB_FEATURE_ACTIVITY_DAILY_WRITER=true and TABHUB_FEATURE_RESOURCES=true to advertise and expose 7d/30d page/resource windows and activity metrics to UI/adapters. Both activity flags default to false. Reader-only mode fails closed to G3 all-time activity because daily coverage would be incomplete; writer-only mode collects buckets without exposing the new readers and is valid for staged rollout.

The immutable migration availability epoch records when daily tracking became available. A separate persisted writer lifecycle epoch records only the current continuous period during which the server-side daily writer was enabled. It does not claim that the browser extension delivered every possible observation; gaps and delivery health remain separate telemetry concerns. Disabling and re-enabling the writer starts a new continuous epoch, and finite readers remain unavailable unless both activity flags are currently enabled.

Priority assessment rollout uses three independent default-off flags: TABHUB_FEATURE_PRIORITY_ASSESSMENT_WRITER permits staged assessment writes, TABHUB_FEATURE_PRIORITY_READERS permits schema-22 readers, and TABHUB_FEATURE_PRIORITY_SHADOW permits shadow presentation only when readers are also enabled. C50 only declares and validates these flags; it does not start collection or expose priority routes. A writer can be staged without readers or shadow, while every requested capability fails closed on a database older than schema 22.

Autostart in Windows

For a permanent local run, first build the production artifacts and verify them manually:

corepack pnpm install --frozen-lockfile
corepack pnpm build
corepack pnpm start

The server still accepts connections only on 127.0.0.1; any other TABHUB_HOST value is rejected because v1 has no authorization. For autostart, open Task Scheduler → Start Scheduler and set:

• trigger At log in;

• on the General tab, select “Run only when user is logged on”, because moving focus between browser windows requires an interactive desktop;

• action Launch a program;

• program — the absolute path from (Get-Command node).Source;

• arguments — the absolute path from (Resolve-Path packages/server/dist/main.js).Path, enclosed in quotes;

• working folder — the path from (Resolve-Path .).Path;

• on the Settings tab, disable “Stop the task if it runs longer than 3 days” and enable restart on failure, for example after 1 minute up to 3 times.

After saving, run the task manually and check Invoke-RestMethod http://127.0.0.1:7717/api/health. After updating TabHub, run corepack pnpm install --frozen-lockfile and corepack pnpm build again, then restart the running server (or the task in Task Scheduler) so new migrations are applied, and confirm the health endpoint shows schemaVersion: 26. Reload TabHub on the browser extensions page and refresh the app page so that a fresh snapshot is sent; no need to recreate the task.

Chromium extension

Build a single Manifest V3 build:

corepack pnpm --filter @tabhub/extension build

In each browser, open the extensions page, enable developer mode, and load the unpacked folder packages/extension/.output/chrome-mv3:

• Chrome: chrome://extensions

• Edge: edge://extensions

• Yandex Browser: browser://extensions

Open the TabHub settings and separately select the name of the current browser. This is required: the Chromium API cannot reliably distinguish Chrome from Yandex Browser, so until you explicitly make a choice, automatic and manual tab submission is disabled. After updating from an older version, the browser needs to be selected again: this prevents the previous automatic chrome value from incorrectly tagging Edge or Yandex. When an already configured value is changed, the extension first closes the old snapshot, then sends a full snapshot with the new identity. Each extension installation stores its own UUID, and the currently loaded extension session in the browser has a separate session UUID, and the native tabId is passed; therefore, two profiles of one browser and two physical tabs with the same URL no longer merge, and a stale tabId after a restart or extension reload is not used for switching.

The popup provides a local server check, the number of unsynchronized physical tabs and operations, a manual snapshot, and content capture of the current or all available HTTP(S) tabs. A full snapshot without a hard limit on the number of tabs is also sent on startup, after tab changes with debounce, and every five minutes through chrome.alarms; the transport only checks the actual payload size. If the server is down, pending data is kept in chrome.storage.local: replaced snapshots and repeated content are compacted, and the queue is limited only by a safe size of 32 MiB with no limit on the number of operations. Persistent HTTP 4xx errors, except 408/425/429, go to a bounded log of 50 entries and do not block subsequent items; transient errors preserve order and are retried automatically.

The web interface opens Library by default, while Graph remains an alternative view of the same canonical pages. There is no separate main Open tabs tab anymore. Library preserves the original order of page appearance and the fixed browser order Chrome → Yandex → Edge → Other; tags, summary, and links are not duplicated between physical copies. In the Tab column, a closed page has no physical target, one open copy is shown as a compact browser tab, and two or more copies expand into a list with window, position, and native tabId. Activation and closing from this list are addressed by the full identity browser / installation / browserSession / browserTabId, so TabHub focuses or closes the selected tab in its own Chrome, Yandex Browser, Edge, or other Chromium profile and does not open a duplicate URL. The Multiple open copies filter leaves only canonical rows with openInstanceCount > 1; it is applied server-side before counting and pagination and deliberately differs from the exact-duplicate URL check. A fragment (#...) is part of the canonical page identity, and case-insensitive utm_* parameters are still stripped as tracking parameters.

Normally, the Library checkbox selects canonical pages for changing their status and topics. The separate Manage browser tabs button enables bulk selection of physical instances: the parent row’s checkbox selects all of its open copies, and the expanded list lets you keep only specific ones. The physical selection survives pagination but is cleared when Library filters change, when management is switched off, or when you leave for the Graph; going to the Graph also returns the normal page mode. The complete filtered set of physical tabs is resolved with a separate, unpaginated query, avoiding the SQLite limit of 999 bind parameters. In this mode you get Move, Close, Pin/Unpin, Mute/Unmute, Sleep, Reload, Workspaces, and the URL/Markdown/JSON export, along with the Extra exact copies, exact hostname, and age presets. An ordinary live command can only target a precise browser/install/session combination; a mixed, stale, or offline selection is blocked entirely. A separate explicit action, Close all matching duplicates, batches only the safe extra exact raw-URL copies across connected profiles, keeps a keeper in each group, performs a separate strict live preview for each profile, and shows the excluded profiles before the overall confirmation. Block close shows a per-profile receipt and the available Reopen closed tabs; an unknown result is not retried automatically. Middle-clicking a Library row closes the single physical copy directly, without a modal; with multiple copies, you first need to select the exact row in the expanded list. The TabHub tab remains protected, and live commands have no hidden target limit.

Inside the Library there are personal collections: For review and Trash. Only weak recommendations for Inbox pages with zero importance get into the review queue: the interface always shows reasons and warnings, but never deletes anything automatically. For any page — regardless of the site or topic — you can explicitly choose Keep, Later, or Close and forget. The last option requires confirmation, addresses each known physical copy in its own browser, requires a complete and exact close result, and only then hides the canonical page from the normal Library feed. If a copy is offline, modified, or unaddressable, the page is not forgotten; if a failure occurs while closing several browsers, the result reports how many copies were successfully closed, and the record remains in the Library for safe retry. A forgotten page stays in the reversible Trash for seven days; reopening or explicitly restoring it cancels the deletion, and expired closed records are purged by the server in the background.

In the Activity column of the Library, TabHub summarizes two historical measures for the canonical page across all tracked browser sessions. These values persist after the physical tab is closed and the browser is restarted; during navigation, intervals refer to the URL they were recorded on, so page times are not mixed. Even if a short transition ends before the debounced snapshot, the accepted activity interval itself creates a closed Library entry, and the subsequent snapshot opens and enrichizes it without duplication. On screen counts only the time when the tab is selected, its window is in the foreground, and the computer is neither idle nor locked. Active use is the subset of that time falling within 60 seconds after a confirmed mouse/movement or a click, keyboard, scroll, or touch event. The drawer separately shows historical Page activity / page activity and Open copies / open copies metrics for the specific physical tabs of the current browser session. The extension stores only intervals and sums, no pointer coordinates, keystrokes, or text. For protected browser pages where the content script is unavailable, only On screen is counted. After a full browser restart, physical tab counters start a new session so that a reused Chromium tabId does not receive another tab’s time, but historical page activity continues to accumulate. The exact historical aggregate starts with schema 15: previous physical sums without a stored URL are deliberately not mapped to arbitrary pages; schema 16 materializes the exact activity-only URLs that the snapshot did not manage to see.

Workspaces stores a named snapshot of all selected physical instances in SQLite, including duplicate URLs, in the current server order of browser/window/index. The lookup contains compact identifiers, and after a live command the extension first synchronizes the new order and flags; thus Save immediately after Move/Pin/Mute does not store stale state. Save & close first confirmedly saves the snapshot and only then opens the close preview. The entire saved set can be opened in the current or a new window, renamed, or deleted; restoration opens each saved item sequentially without hidden truncation. During restoration, a second run is blocked, and on an unknown timeout result the UI asks the user to check the browser first. Selected tabs can also be copied as URL, Markdown, or JSON lists.

Content is extracted only on request: Readability gets the article’s main text and HTML, and for pages without a suitable article, document.body.innerText is used. There is no automatic scanning of all tabs in v1.

After snapshots from several browsers, records appear in a shared table with a browser column. A new snapshot updates the existing normalized reference; a disappeared tab remains in the DB with isOpen=false.

REST check without the extension

$body = @{
  browser = 'chrome'
  tabs = @(@{
    url = 'https://example.com/?utm_source=test#section'
    title = 'Example'
    windowId = 1
    index = 0
  })
} | ConvertTo-Json -Depth 4

Invoke-RestMethod -Method Post -Uri http://127.0.0.1:7717/api/ingest/snapshot -ContentType application/json -Body $body
Invoke-RestMethod http://127.0.0.1:7717/api/tabs

GET /api/tabs supports global sorting before pagination: sort_by accepts title, topic, browser, activity, status, importance, state, or age, and sort_direction accepts asc or desc. Sorting by these columns is not combined with search_mode=semantic and similar_to, where the order is determined by relevance.

Full-text search

Search works by title and full URL even before content is captured, including the title and original URL of each physical tab appended to the canonical page; after capture, it also includes the cleaned text and summary. Partially entered words match by prefix, and literal fragments of titles and URLs match as case-insensitive Unicode substrings; punctuation from the user’s query is not interpreted as FTS syntax:

Invoke-RestMethod 'http://127.0.0.1:7717/api/tabs?q=local-first'

The same parameter is available in the web interface again above the table.

Semantic search and no cluster

Embeddings are created only on explicit request. By default, TabHub uses local Ollama at http://127.0.0.1:11434; before the first indexing, install the model:

ollama pull nomic-embed-text

For Voyage, set EMBEDDING_PROVIDER=voyage, VOYAGE_API_KEY, and optionally VOYAGE_EMBEDDING_MODEL in .env. EMBEDDING_PROVIDER=disabled disables the provider completely. Both options store 512-dimensional vectors in the local sqlite-vec table; captured text is truncated to 32,000 characters before sending, and processed in batches of 100 tabs.

Invoke-RestMethod -Method Post `
  -Uri http://127.0.0.1:7717/api/embeddings/reindex `
  -ContentType application/json `
  -Body '{"limit":100}'

Invoke-RestMethod 'http://127.0.0.1:7717/api/tabs?q=compiler&search_mode=semantic'
Invoke-RestMethod 'http://127.0.0.1:7717/api/tabs?similar_to=1'

Invoke-RestMethod -Method Post `
  -Uri http://127.0.0.1:7717/api/clusters/inbox `
  -ContentType application/json `
  -Body '{"maxClusters":8}'

Re-capturing text discards the obsolete vector. cluster_inbox indexes only yet uninboxed tabs with status inbox, then deterministically proposes named clusters; it does not create tags and does not change user markup.

On-demand summarisation

TabHub never summarizes tabs automatically. To enable manual requests from the UI or MCP, set ANTHROPIC_API_KEY in .env and restart the server. By default, short mode uses claude-haiku-4-5-20251001, deep mode uses claude-sonnet-5; models and estimated prices can be overridden using the ANTHROPIC_* variables from .env.example.

The request creates a durable SQLite job, and the background worker makes no more than one Anthropic call at the same time. Temporary errors are retried with backoff, unfinished jobs are resumed after a restart, and stale results are not overwritten over re-captured content. TABHUB_DAILY_SUMMARY_LIMIT limits the provider call attempts within a UTC day; token usage and estimated cost are kept for each attempt and written to the log of a successful job.

$job = Invoke-RestMethod -Method Post `
  -Uri http://127.0.0.1:7717/api/tabs/1/summarize `
  -ContentType application/json `
  -Body '{"depth":"short"}'

Invoke-RestMethod "http://127.0.0.1:7717/api/jobs/$($job.jobId)"

If no key is set, the endpoint returns 503 SUMMARY_PROVIDER_UNAVAILABLE and no job is created. In the table UI each tab with content captured has the ability to create or update existing summary / content; the queue state and errors are shown next to the action.

Organizing tags

The table supports multiple selection and batch changes of status or assignment of a hierarchical tag path, for example Research/AI/Agents. The theme field in the batch panel and tab card suggests existing paths with search, but remains editable for creating a new path; the system theme Uncategorized is not included in suggestions. The rows for the current page are virtualized with dynamic measurement of height, so expanded summaries remain correct without mounting the whole page into the DOM. The theme sidebar shows a tree of arbitrary depth with cumulative counters: you can create root and child themes, rename, move, assign a color, and after confirmation delete a theme without subtopics. An includes filter on a parent path includes tabs from all descendants. A row click opens a tab card with content, content, topics, relations, importance, and custom fields.

The protected theme Uncategorized automatically contains all tabs without a custom theme. When a user assigns the first regular theme, the association is cleared; when Uncategorized is deleted as the last regular theme, it is restored. Uncategorized can be used as a filter in the Library and Graph, but cannot be renamed, moved, deleted, or assigned manually. In the graph, the system theme and its structural link are not displayed: the filtered tabs appear as a normal directly with no explicit theme.

PATCH /api/tabs/:id accepts any non-empty combination of status, importance, and customFields. A string value creates or updates a field; null removes it. Batch importance is available in PATCH /api/tabs/importance. The CRUD for themes is /api/tags, assigning a path is POST /api/tags/assign. Universal relations tab-tab, tab-theme and theme-theme are under /api/relations; the old /api/links remains as a compatible projection of relations between tabs. Manual changes save the user origin, MCP changes the agent origin.

Graph of relations

The Graph section opens a three-dimensional WebGL graph where tabs and themes are separate types of nodes. You can rotate the scene with the mouse, pan across the plane, and zoom in and out. Clicking a node selects it, smooths the camera to it, and opens an inspector with metadata, a link to the existing browser tab, or a bridge to a selected library topic.

For the selected node, we set the focus depth from one to five steps: all nodes and edges within this undirected neighborhood remain displayed, and the rest of the scene becomes transparent. With the active filter, the server keeps direct cross-links beyond the selected subtree, but the further neighborhood of the selected node is loaded separately and limited by a dedicated query, no full global graph required for that. In the editor you can create directed semantic relations with any visible node, set the type and note, or remove an existing semantic relation. The hierarchy of themes and membership of pages are shown as structural edges, but do not duplicate the custom relation table.

A filter in the theme tree loads only the selected subtree. For dense graphs, the interface takes the time to simulate, simplifies geometry, and disables moving individual nodes; the 3D logic itself is loaded as a separate lazy chunk and does not burden the initial Library load. The canonical typed REST result is available separately, while the legacy endpoint is kept for compatibility:

Invoke-RestMethod http://127.0.0.1:7717/api/graph/v2
Invoke-RestMethod 'http://127.0.0.1:7717/api/graph/v2?root_topic_id=1'
Invoke-RestMethod 'http://127.0.0.1:7717/api/graph/v2?root_topic_id=1&focus_node_type=topic&focus_node_id=2&focus_depth=3'
Invoke-RestMethod http://127.0.0.1:7717/api/relations
Invoke-RestMethod http://127.0.0.1:7717/api/graph

MCP for Claude Desktop and Codex

First, build the stdio MCP server and keep the main TabHub server running on 127.0.0.1:7717:

corepack pnpm --filter @tabhub/mcp build
corepack pnpm dev

The MCP process uses TABHUB_API_URL and remains a thin adapter over the REST API. It provides the tools list_tabs, get_tab, search_tabs, summarize_tab, cluster_inbox, set_status, set_importance, tag_tabs, link_tabs, list_tags, get_stats, review_disposable_pages, set_page_retention, close_and_forget_page, list_retention_trash, restore_retention_page, and the resource tabhub://tab/{id}. list_tabs accepts the same filters as the REST list, including q, search_mode, and similar_to; search_tabs supports the fulltext and semantic modes. cluster_inbox explicitly indexes unprocessed tabs and returns suggestions with titles, keywords, and tab identifiers. The deprecated set_importance tool first reads /api/features: when logical importance is enabled, the server writes an agent entry on_behalf_of_user; when the flag is disabled or on an old schema-17 server, the previous scalar entry is used for only the selected tabs. An invalid feature contract does not result in a write. review_disposable_pages only shows personalized suggestions and warnings; set_page_retention saves the “keep” or “later” decisions. The destructive close_and_forget_page requires confirmed=true, closes all known physical instances only with a precisely confirmed result, and then moves the page to a seven-day trash; it can be viewed and undone via list_retention_trash and restore_retention_page. summarize_tab marks the request as agentic, places it in the same SQLite queue, and waits for completion for up to 55 seconds; if the job has not finished yet, a repeated call will continue waiting for the same active job. Content in MCP responses is limited to approximately 20,000 characters.

Claude Desktop

Open Settings → Developer → Edit Config, add the server to %APPDATA%\Claude\claude_desktop_config.json, and completely restart Claude Desktop:

{
  "mcpServers": {
    "tabhub": {
      "command": "C:\\Program Files\\nodejs\\node.exe",
      "args": ["D:\\VibeCoding\\TabHub\\packages\\mcp\\dist\\main.js"],
      "env": {
        "TABHUB_API_URL": "http://127.0.0.1:7717"
      }
    }
  }
}

If Node.js or the repository is located elsewhere, get the absolute paths with the commands (Get-Command node).Source and (Resolve-Path packages/mcp/dist/main.js).Path, and replace the values above.

Codex

Add the server via the CLI:

codex mcp add tabhub --env TABHUB_API_URL=http://127.0.0.1:7717 -- 'C:\Program Files\nodejs\node.exe' 'D:\VibeCoding\TabHub\packages\mcp\dist\main.js'
codex mcp list

The equivalent manual configuration in %USERPROFILE%\.codex\config.toml:

[mcp_servers.tabhub]
command = 'C:\Program Files\nodejs\node.exe'
args = ['D:\VibeCoding\TabHub\packages\mcp\dist\main.js']
cwd = 'D:\VibeCoding\TabHub'
startup_timeout_sec = 10
tool_timeout_sec = 60

[mcp_servers.tabhub.env]
TABHUB_API_URL = "http://127.0.0.1:7717"

After connecting, open /mcp in Codex and make sure tabhub and all the tools listed above are available.

Checks

corepack pnpm test
corepack pnpm typecheck
corepack pnpm build

Backup

With the server stopped or running, the SQLite online backup is created with the command:

corepack pnpm backup

The file will appear in the root folder backups/.

Implementation status

• Stage 0: monorepo scaffold, shared schemas, SQLite migration, and healthcheck — complete.

• Stage 1: snapshots from Chromium browsers, reliable extension queue, REST ingest, deduplication, and a shared table — complete.

• Stage 2: manual capture of Readability content, FTS5, and UI search — complete.

• Stage 3: REST management operations, hierarchical tags, statistics, and MCP tools for Claude Desktop/Codex — complete.

• Stage 4: explicit summarization through a reliable SQLite queue, sequential Anthropic worker, UI, and MCP — complete.

• Stage 5: topic tree, tab card, links, importance, custom fields, and bulk operations in UI/MCP — complete.

• Stage 6: sqlite-vec, explicit indexing via Ollama/Voyage, semantic search, related tabs, and named inbox clusters in REST/MCP — complete.

• Stage 7: typed 3D graph of tabs and topics with WebGL navigation, arbitrary cross-links, an inspector, and focus on the surroundings 1–5 steps deep — complete.