---
title: "Introducing the Dash: the mind seen from above"
summary: "A member-only control panel assembled from small UI kit pages, with the host retaining authority over every connection."
created: "2026-11-15"
updated: "2026-11-18"
revision: "5"
previous: "3fb685bc6dbcf317a113a56f325310310668253d"
reviewedThrough: "499865e6c07a5cc1c6a715609915ce4b57177046"
sourceDigest: "0201a73d048a7eeabe8be2c00e6924614bf5e4784f59d1d26ee2eea71ce15984"
---

With this, your mind can give members one place to start an agent, return to ongoing work, inspect contexts and manage integrations. The Dash is a page in the mind’s config, not a separate service with a second copy of its data. Its member socket can reach the whole mind, so this is a privileged control panel rather than a public status page.

## Start with work, keep the raw view nearby

`apps/dash/public/app.js` imports `Dash` and its panels from `@iterate-com/ui`. A single `pages` list defines their names, icons, order and components. Home now starts with the agent composer; Agents is an embedded panel, not only a link to another host. The sidebar lists recently active agents above the panels, and command search prefers agents unless a member asks for a raw context path. Contexts remains available for inspecting the durable log beneath a conversation.


```js
const pages = [
  { id: "home", name: "Home", component: DashHome },
  { id: "agents", name: "Agents", component: DashAgents, presence: true },
  { id: "contexts", name: "Contexts", component: DashContexts }
];
// Other panels can be added as rows with their own components.

```

The URL names the selection with paths. `index.html` sets `data-addresses="paths"`; the pinned UI kit maps a panel to `/<id>`, an agent to its `/agents/...` path, and a raw context to `/contexts/...`. For example, an invented `/agents/project-helper` address selects that existing conversation; it does not create it. The kit reads old `?page=<id>` and `?agent=<path>` links and rewrites them in place. Local links use `pageHref`, `linkTo` and `usePageParam` instead of hand-building queries. The host serves the app shell for deep paths that name no asset, so a copied link can survive a reload.

Components receive the member connection and page context, including the catalog’s agents. Keep the address as navigation state, never permission to read a context. Larger panels load when first needed; the home composer need not load every repository or analytics view.

## Share a conversation without confusing its speakers

Several members can open the same durable agent thread. In the Agents page row, `presence: true` enables the pinned chat’s present-member and typing display. That is separate from message history and from the catalog’s working status. A face means a page has the context open, not that its owner approved an action or that the agent is working.

The UI kit derives open-page participants from that context’s subscription rows and live RPC stub references. A page sends transient status, not its chosen identity:

```js
{
  type: "presence/status",
  ephemeral: true,
  payload: { subscription: "sample-page", away: false, typing: true }
}
```

This is an invented event shape, not a stored record. The receiver associates status with the event source’s principal and an observed subscription. Visibility changes update away status, and typing indicators expire. Presence events are not durable chat messages. Durable sender labels instead come from message-event provenance, including supported script-on-behalf-of provenance, rather than a name typed into message text. Keep these identities inside the member boundary and avoid exporting participant lists into public status pages.

## Paint first, reconnect without throwing the page away

`index.html` draws a wordless loading frame before modules arrive, starts the member socket in the head, and preconnects to the pinned UI package host. The frame follows the saved sidebar preference and whether the URL selects an agent; none of that cached presentation grants access. `public/app.js` marks its Agents wrapper `staysOverReconnect` so the shell can preserve that page over a renewed connection instead of remounting it. This is UI continuity, not durable message storage or proof that cached information is current. The components still have to obtain the renewed member connection and refresh their observations.

The shared page-error capture is served by the guarded host and records failures privately. Keep a usable loading and error state when modules, identity lookup or the socket fail. Verify cold and warm loads, collapsed navigation, reconnects and revoked sessions; a faster initial frame is not a measured latency guarantee.

## Keep host authority on the server

`apps/dash/app.ts` serves `index.html`, `public/`, the shared theme and shared live-reload files. `worker.ts` first applies `this.auth.require(request)`; then `host.auth.memberPage(request)` handles the member socket and shell endpoints. The page uses `memberItx()` and `mindOfHost()` from the UI kit. A signed-in-person guard is not sufficient: an ordinary signed-in visitor is not necessarily a member.

Only explicitly allowlisted icons and app manifests bypass the member guard. Preserve that small exception without exposing chat actions, repo contents or the socket. Pin the browser package, React entry points and styles together in the import map. The dashboard itself needs no new vendor account or credential.

## Integrations reflect the vault

The Integrations panel reads the integrations facet and secret inventory, not a browser-maintained list. `cloud-accounts.ts` keeps connected accounts and available connection actions aligned with the real vault. A guarded `/connect/<app>` route begins OAuth through the configured iterate Cloud, using `cloud-scopes.ts`. The vault shows the member the proposed secret and permitted destinations before consent; tokens never pass through page JavaScript. Reconnecting can replace only a secret for that app, not an arbitrary secret named in a link. Connection failures return an explicit error.

## Link to observations, not guesses

For a computer pane whose captured Claude or Codex conversation is known, `public/native-navigation.js` can offer a link to that conversation. It matches the observed provider, session and computer against an existing catalog row, and removes the link when newer observations invalidate it. The label deliberately says “last identified”: a historical capture is not proof of the pane’s current session. This is local navigation, not permission to control another computer.

## Rebuild and verify

Copy the host, assets and navigation helper, mount behind member authentication, and supply a tested UI-kit version with the home and agent-kind components. Existing integrations need their own accounts; OAuth buttons require a configured Cloud client. Keep passkey, session and membership management on platform pages instead of copying credential forms. Test direct socket requests by nonmembers, unknown panel ids, fresh loads of path-based agent and context links, migration of old query links, disconnected sessions and stale pane observations. Open one conversation in two member sessions and verify sender labels, typing expiry, hidden-tab status and departure after closing a page. Presence must neither start an agent turn nor become durable chat history. Check narrow and desktop navigation and a first opening of onboarding. [Agents](/introducing/agents) describes the separate workbench; [Docs](/introducing/docs) describes repo editing.
