Privacy policy

# Privacy policy for the hosted Dispatch team server

> **Draft for review.** Written from the server's code and design documents on
> 2026-11-12 for Wyat and a lawyer to review. It is not legal advice and is not
> in force. Every "Decide:" note marks a business or legal choice that is still
> open; `docs/legal/README.md` lists them all.

- **Who we are:** [LEGAL ENTITY NAME], [ADDRESS] ("we", "us").
- **Effective date:** [EFFECTIVE DATE]
- **Contact:** [CONTACT EMAIL]

> Decide: the legal entity name, its address, the contact email and the
> effective date.

This policy covers the hosted Dispatch team server at app.dispatch.foo (the
"service"). It does not cover a Dispatch server a team runs itself; whoever runs
that server is responsible for it. It does not cover the Dispatch desktop app or
the `dispatch-core` program on your machines, which do not send anything to us
except through the service described here.

> Decide: whether the desktop app, the website at dispatch.foo, or the
> marketing site need their own policy or a section here (for example if the
> app sends crash reports or update checks, or the site uses analytics).

## The short version

Your team's work is sealed on your own devices with a key we never have. We
store it and pass it between your devices, but we cannot read it. Your agents
run on your own machines with your own model subscriptions; we never see your
prompts, your code or what a model writes back.

We can see who is on your team, which devices they signed in, when those devices
connect, and how big the things they send are. This policy lists exactly what
that means.

## What we collect

### Your account

When you sign in with GitHub or Linear, we keep:

- the provider's numeric or opaque user id for you, so we know it is you next
  time;
- your login or display name from that provider, which becomes your handle on
  the service and is never given to anyone else;
- your name, if the provider has one for you;
- when your account was made.

We ask GitHub only for `read:user` and Linear only for `read`. We use the
access token once, to read who you are, and then drop it. We revoke Linear's
token straight away. We do not keep either token, and we do not read your
repositories, issues or anything else in those accounts.

We do not ask for or keep your email address.

> Decide: Linear's `read` scope technically lets the token read the workspace,
> even though we use it only for the viewer's id and name and revoke it at
> once. Confirm that this is the narrowest scope Linear offers and that the
> wording above is accurate enough.

When you sign in on the website we set a session cookie (`HttpOnly`, kept up to
30 days) and, during sign-in only, a short-lived cookie (10 minutes) that ties
the provider's answer to your browser. We store only a hash of each session.
The website has no JavaScript, no analytics and no advertising.

### Your teams

For each team we keep its name, when it was made and who made it, its members,
each member's role (admin or member) and when they joined. Membership invite
links are stored only as a hash, work once and expire after seven days; we keep
which account used each one.

Your teammates can see your handle, your name, your role and your devices on
the team's page.

### Your devices

When a device signs in to a team we keep:

- an id we make for it;
- the name the device's program sent when it signed in (it defaults to
  "a core"; you choose it with `--client`);
- which account and team it belongs to, and when it signed in;
- when it was last heard from;
- whether it has been signed out;
- a hash of its sign-in token (never the token itself);
- which of the team's key devices it proved it holds, so that removing a
  person also removes their devices from the team;
- the order an admin set for which device should lead the team, if any.

The short sign-in codes a device shows you are stored as a hash and expire
after 15 minutes.

### Connections, timing and sizes

The service sees for itself when each device connects, when it goes quiet (two
minutes without a message) and when it comes back. It writes these facts, in
the clear, into a per-team record that every device of the team reads, so a
silent machine's work can be handed on. That record also notes when a member is
removed, when a device is signed out, and which device the service suggested
should lead the team.

For every sealed item a device sends, we can see which device sent it, to which
team, when, and how large it is.

### Sealed content we cannot read

Everything your team shares through the service is sealed on your devices
before it leaves them: tasks, comments, findings, claims, session records and
status, run logs and diffs, messages, channels, docs and memory. We store the
sealed items, sealed snapshots and sealed run logs, and send them on to your
team's other devices. We do not have the key, so we cannot open them.

To store and order sealed items we also see a few fields in the clear: the
team, an opaque project id (not the project's name), an opaque run id, the
sending device's public key, which key generation was used, a number and time
we assign, and the size. We also store your team's signed list of devices
(their public keys and signatures) and the team keys sealed to each device,
none of which we can open.

### Billing

If your team pays for the service, Stripe collects and holds your payment
details. We never see your card number. We keep, per team: Stripe's customer
id, subscription id and subscription item id, the number of paid seats, the
subscription's status and since when, and since when the team has had more
members than seats.

### Request logs

The service writes one line per request or call. A line holds only words and
ids the server itself made and numbers: for website requests, the method, the
path (with the secret part of an invite link removed), the status and how long
it took; for device calls, the team id, the method name, the size in bytes, the
outcome and how long it took; and when a device connects or disconnects, the
team id and device id. Logs never hold a request's contents, a sealed item, a
token, a cookie, a query string or your IP address.

To limit abuse, the service counts requests per IP address in memory for the
sign-in, device, invite and payment paths. These counts are not written to disk
or to the logs.

> Decide: our hosting provider's edge (Railway) may record IP addresses and
> request details in its own logs. Find out what Railway keeps and for how long,
> and say so here.

## What we cannot see

- The contents of anything your team shares: tasks, comments, findings,
  claims, session records, run logs, diffs, messages, channels, docs and
  memory.
- Project and task names. Projects are opaque ids to us.
- Your prompts, your code, or what any model writes back. Your agents run on
  your own machines with your own model subscriptions, and talk to the model
  providers directly, not through us.
- The team key. The secret in a device invite link sits after the `#`, which
  browsers never send to a server. No code we serve ever handles a key.

The service cannot add a device of its own to your team: every device on the
list is signed in by a device already on it.

## How long we keep each thing

| What                                                   | How long                                                                                              |
| ------------------------------------------------------ | ----------------------------------------------------------------------------------------------------- |
| Account (handle, name, provider ids)                   | Until the account is deleted. See "Your choices".                                                     |
| Website session                                        | Up to 30 days, or until you sign out; deleted within an hour of expiring.                              |
| Sign-in flow cookie                                    | 10 minutes.                                                                                           |
| Device sign-in code                                    | Usable for 15 minutes; deleted within an hour of expiring.                                            |
| Membership invite                                      | Usable for 7 days or one use; the record of who used it stays with the team.                          |
| Team, members, roles                                   | Until the team is deleted. A removed member's row is deleted when they are removed.                   |
| Device records                                         | Until the team is deleted. A signed-out device's record is kept, marked signed out.                   |
| Sealed items, sealed snapshots, signed device list     | Until the team is deleted, including while the team is paused for payment.                            |
| Sealed run logs                                        | 30 days, then deleted by an hourly sweep.                                                             |
| Device invite payload (sealed team key)                | Until it is taken once, then deleted.                                                                 |
| Connection facts (connected, silent, removed, lead)    | Until the team is deleted.                                                                            |
| Which device is connected right now, willing to lead   | In memory only; gone when the service restarts.                                                       |
| Billing ids and status                                 | Until the team is deleted. Stripe keeps its own records under its own policy.                          |
| Request logs                                           | [LOG RETENTION]                                                                                       |
| Backups                                                | [BACKUP RETENTION]                                                                                    |

Deleted rows and expired run logs are overwritten in the database files
(SQLite's `secure_delete`). Old copies can survive briefly in the database's
write-ahead log until it is reused; everything in them is sealed or is account
data listed above.

> Decide: how long request logs are kept (the server writes them to standard
> error; the hosting platform keeps them).

> Decide: whether and how often the hosted service is backed up, where backups
> are stored, and how long they are kept. A deleted team stays in any backup
> taken before it was deleted until that backup expires.

> Decide: whether to keep connection facts, signed-out device records and used
> invites for the life of the team, or to sweep them after a set time. Today
> nothing removes them except deleting the team. (Expired website sessions and
> sign-in codes are already swept hourly.)

> Decide: how long a paused, unpaid team's sealed data is kept before we may
> delete it. Today the server never deletes it for not paying.

## Who we share with

We do not sell your data and we do not share it for advertising. We use these
service providers (subprocessors):

| Provider | What for                                       | What it receives                                                                    |
| -------- | ---------------------------------------------- | ----------------------------------------------------------------------------------- |
| Railway  | Hosting the service and its storage            | Everything the service stores, including sealed content it cannot read either.     |
| Stripe   | Taking payment                                 | Your payment details (collected by Stripe directly), our team id, the seat count.  |
| GitHub   | Sign-in, if you choose it                      | That you are signing in to Dispatch.                                                |
| Linear   | Sign-in, if you choose it                      | That you are signing in to Dispatch.                                                |

> Decide: whether this list is complete (for example a domain or DNS provider,
> an email provider for support, or error monitoring), and in which region
> Railway hosts the service's data.

We may disclose information if the law requires it. Because team content is
sealed with a key we do not have, we can only ever hand over what we can see:
the account, team, device, timing, size and billing data above, and sealed
items we cannot open.

> Decide: how we respond to legal requests, and whether we tell affected
> users when the law allows.

If the service or the company is sold or merged, the data above may pass to the
new owner under this policy.

> Decide: whether to keep this clause and how to word it.

## Your choices

- **Export.** A team admin can download all of the team's sealed data, the
  signed device list and the team's connection facts from the team's page, and
  load it onto another Dispatch server, including one you run yourself. The
  file stays sealed. Every member's own devices also hold the team's full,
  readable state.
- **Delete a team.** A team admin can delete a team from its page. That deletes
  the team's directory (all sealed data, run logs and connection facts) and its
  members, invites, devices, sign-in codes and billing record, and cancels
  the team's Stripe subscription at once. If Stripe cannot cancel it, nothing
  is deleted and the admin can try again.
- **Leave a team.** You can leave a team from its page (or from a signed-in
  device), unless you are its only admin: make another member an admin first,
  or delete the team. A team admin can also remove any member. Leaving or being
  removed signs out all of your devices on the team and releases your seat;
  your teammates' devices then start a new team key you never get. You keep
  what your devices already had.
- **Sign out a device.** You can sign out any of your devices, and an admin can
  sign out any device on the team. The device is cut off at once.
- **A copy of your account data.** You can download, from the website or a
  signed-in device, a JSON file of what we hold about you: your account,
  sign-in methods, teams and roles, devices, and the connection facts about
  your devices. It holds no one else's data, nothing sealed and no secret.
- **Delete your account.** You can delete your account from the website or a
  signed-in device, unless you are a team's only admin. You leave every team,
  and your devices, website sessions, sign-in codes, sign-in methods and
  account are deleted. Your handle and your GitHub or Linear ids are freed:
  someone else may take the handle, and signing in again makes a new account.
  Each device keeps only its id and its team, signed out and no longer tied to
  you, so its number is never given to another device. Facts already on a
  team's line that name your account id stay with that team until the team is
  deleted.

> Decide: which legal rights to list (for example access, correction,
> deletion, portability and objection under the GDPR or UK GDPR, and the
> rights under California law), the legal bases for processing, how to reach
> a supervisory authority, and whether we need an EU or UK representative.

## Security

Content is sealed end to end: on your devices, with keys only your team's
devices hold, using published constructions (Ed25519 signatures, HPKE with
X25519 and ChaCha20-Poly1305, XChaCha20-Poly1305 for content). Connections to
the service use TLS. Secrets we hand out (sessions, invites, device codes and
tokens) are stored only as hashes.

What end-to-end encryption does not protect:

- **Metadata.** We can see who is on a team, their devices, when they connect,
  and how much and how often each device sends.
- **A compromised device.** Anyone who controls a team member's device can read
  what that device can read.
- **Invite links.** A device invite link carries the key. Anyone who reads it
  before it is used can join in its place, so send it through a channel your
  team trusts.
- **What you sync elsewhere.** Tasks a team syncs to GitHub Issues or Linear
  are readable by those services.
- **Lost keys.** If every member loses every device and the recovery phrase,
  the team's data cannot be recovered, by us or anyone.
- **Service.** We can refuse, delay or drop what a device sends, or keep it,
  though we cannot read or change it undetected.

> Decide: whether to describe the encryption here, given that the design is
> still awaiting an outside security review (`dispatch-core`
> `docs/decisions/keys.md`), and how to report security issues.

## Children

The service is for people working in teams and is not directed at children. You
must be at least [MINIMUM AGE] to use it. If we learn that a child under that
age has an account, we will delete it.

> Decide: the minimum age (commonly 13, or 16 in parts of the EU).

## Changes to this policy

If we change this policy we will post the new version here with a new effective
date. If a change means we collect or can see more than this policy describes,
we will tell team admins [HOW AND HOW FAR IN ADVANCE] before it takes effect.

> Decide: how we notify and how much notice. We keep no email address, so the
> options today are the team page and what a core shows from the server.

## Contact

[LEGAL ENTITY NAME], [ADDRESS], [CONTACT EMAIL].