Skip to the content
docs

Privacy policy

Cloudfield was named Aether until November 2026. The commands, paths and hostnames in this guide still use that name. View this guide on GitHub.

Browse guides / Privacy policy

Cloudfield is self-hosted software. Nothing about you reaches the people who publish it unless you sign in to the edge they run, at auth.onaether.dev and edge.onaether.dev (What an edge stores). This page is the privacy policy for the Cloudfield Android app (package io.aether.android), whether it came from a GitHub release or from Google Play, for the dashboard the app shows, and for that edge. Effective 2026-10-16.

Who publishes it

Cloudfield is published by 3xDevOps, https://github.com/3xDevOps. Questions about this policy go to https://github.com/3xDevOps/cloudfield/issues. Privacy requests about what the project's edge holds, such as a copy or a deletion, go to team@onaether.dev; deleting your own account needs no request (What an edge stores).

What the app stores on the phone

  • Which mode you chose and, in Tailscale mode, the server name you type on the first screen, in the app's private storage.

  • In Cloudfield Edge mode, the CLI's state, under the app's private files directory in .config/aether/: config.json (the servers you linked), edge-device-key (this phone's SSH private key, mode 0600), edge-tokens.json (the edge's sign-in token for this device, mode 0600) and edge.lock. Beside them, resolv.conf holds the DNS servers of the phone's current network, which the app reads (permission ACCESS_NETWORK_STATE) and rewrites when the network changes. Nothing else the app writes is its own.

  • With notifications on, the push registration, in the app's private storage: the distributor's address for this phone, the two Web Push keys, and the last error registering. The UnifiedPush connector library keeps the private key in its own database, encrypted (AES-GCM) with a key held in the Android Keystore. Showing notifications needs the POST_NOTIFICATIONS permission, which Android asks for when you turn them on; the connector adds WAKE_LOCK, to finish handling a message while the phone sleeps.

  • The WebView's ordinary cache of the dashboard's files (none in Edge mode, which turns it off), and the dashboard's own local record of how you use it. That record holds how the dashboard looks (theme, text size, sidebar width and whether it is collapsed, whether a session's Details panel is open, the embedded Environment terminal's height, terminal font size, line wrapping in Changes, whether single-key shortcuts are on); where you were (the workspace you last opened, whether the sidebar lists only your own sessions, and the view you last chose for each of your last 200 sessions, by session id); the mode you last launched each agent in; which update notices you dismissed, by version; and the onboarding wizard's progress. The dashboard writes these preferences in origin-local aether.ui storage: they are separate for each server origin, including its port. Nothing reads them but the dashboard, and they last until you uninstall the app. Both are private to the app.

  • The unfinished New session form, in localStorage under aether.launch-draft.v1:<encoded identity>. The identity includes the dashboard origin, server hostname and signed-in member. It holds the task, repository choices, agent, account and fallback choices, mode, model, effort, permission, subsession choice and resource limits. Changes save immediately. Clicking outside the desktop form or pressing Escape keeps the draft; X, Cancel or a successful launch deletes it. Edge-linked pages keep drafts in memory only because another app could serve script from the gateway's loopback port. Elsewhere, reopening the same dashboard in the same browser profile restores it collapsed. It is not synchronized to another browser, device or the desktop app. Clearing site data deletes it; private browsing usually deletes it when the private session ends. Storage errors are shown; the form still keeps its in-memory draft while the page remains open. If a saved draft cannot be read, the form waits for the user to start a fresh draft before replacing it.

  • The last snapshot the dashboard loaded, in localStorage under aether.snapshot.v1:<origin>, so the next launch paints at once, marked Saved state from ..., until the live state arrives. It holds:

    • the server info: version, your member (without git name or email) and the tailnet host name;
    • the workspace list (name, base branch, id; not the git origin URL);
    • every session the server listed, as the server sent it: task text, title, branch, status, pending question ids and wait conditions, but not the last tool the agent used;
    • the member list without git names and emails;
    • the gateway's capability list.

    It holds no token, key, environment variable, transcript, file or terminal output, and no disk usage. It is rewritten after a load, ten seconds after the last change and when the page is hidden, deleted when the dashboard sees a different member or server, or any refusal of access (a rejected token, a refused or removed member, a revoked or pending device); after a refusal nothing is saved again until a load succeeds. It is skipped above 1 MB. In Cloudfield Edge mode the dashboard never saves it and deletes any copy, because another app could serve script from the gateway's loopback port. localStorage itself stays on in the app's WebView there; the app turns off only its HTTP cache and service workers' network loads. It is keyed by origin, so two members who share one browser profile and one dashboard address see each other's saved state until the first live load replaces it; sign in with separate browser profiles. It is not sent anywhere. In a browser, Clear site data deletes it.

In Tailscale mode the app stores no account, password, token, cookie or key: there is no dashboard sign-in, and the phone's Tailscale login identifies it to your server (networking.md). In Edge mode the device key and token above are credentials, kept only on the phone. An app login in the remote development browser is separate server-side state, as described below. Uninstalling the app deletes everything stored on the phone, which in Edge mode includes the device key: the phone then signs in again as a new device and needs approval again where the server requires it. None of it is backed up: the app opts out of Google's cloud backup and of device-to-device transfer (allowBackup=false and data_extraction_rules.xml), so setting up a new phone starts again.

What leaves the phone

  • To your server. In Tailscale mode every request the dashboard makes goes over HTTPS to the server whose name you typed, which you or your team run; in Edge mode the dashboard talks to the gateway on the phone (127.0.0.1), which reaches the server over SSH through the edge (next items). That includes what you type into a terminal, the messages you send an agent, an image you pick from the phone to paste into a terminal, the contents of files you edit in the dashboard, approvals, and the session controls you use. The server keeps them as part of each session's record, on its own disk (install.md); who on your team can see them is in teams.md and security.md. The app refuses a plain http:// address, permits cleartext only for 127.0.0.1 (the Edge mode gateway), and refuses mixed content, so nothing leaves the phone unencrypted.
  • In Edge mode, to the edge and through it. The bundled CLI contacts the edge to sign in, list your servers and relay the SSH connection to the one you linked; the edge holds what What an edge stores lists and cannot read the stream, which is encrypted end to end between the phone and your server. The GitHub sign-in happens in the phone's browser, under GitHub's own policy. While the dashboard is open, the gateway also asks github.com for the newest release's tag, as the next item describes, reusing an answer for an hour, retrying a failed request after five minutes at the soonest, and asking again when it restarts. The CLI resolves host names with plain DNS over port 53 to the active network's DNS servers, bypassing Android Private DNS (DNS-over-TLS), so that network can see which names it looks up.
  • In both modes, to github.com for the newest release. When the app comes to the front, about once an hour, and when you tap Check for updates, the bundled CLI asks github.com for the tag of the newest Cloudfield release, so the app can say an update exists. GitHub sees the phone's IP address and that request, nothing about you or your server. The app downloads nothing itself: you install a release from Google Play, or download its APK in the browser.
  • In Tailscale mode, your identity reaches the server through Tailscale, not through the app. The server asks its own tailscaled which tailnet login owns the connecting device. The app sends no name, email, or identifier of its own. In Edge mode the phone's device key and your edge account identify you instead (edge.md).
  • Your server records you as a member on the app's first request. In Tailscale mode, from that answer it stores your tailnet login, which is an email address, and a display name taken from the part before the @, and writes one log line carrying that login and your device's Tailscale node ID. The record is how your administrator approves you and how your teammates see who did what (teams.md). It is kept by your own server, not by the publisher, and lasts until an administrator removes it.
  • Your teammates see when you are online and what you have open. The dashboard tells the server every 15 seconds that you are there and which workspace you have open, and an open session terminal adds you to that session's Watching list; the other members of that server see both (teams.md). It is not kept as history.
  • Optional GitHub authorization opens GitHub in your external browser. If an administrator chooses Connect GitHub during onboarding or in Settings, that browser visits GitHub to approve the native GitHub CLI's device authorization. GitHub receives the browser's requests under its own policy; the resulting token is kept in the member home on your server, not in the dashboard or Android shell.
  • No app analytics or advertising. The app has no analytics, no crash reporting, no advertising, and no third-party library that talks to a network. WebView Safe Browsing is turned off in the app, so no visited URL, and no hash of one, is sent to Google. A link that leaves the dashboard opens in the phone's browser, under that browser's own policy.

Dashboard requests above go to the server you chose, not to an Cloudfield-operated analytics service. Optional GitHub authorization and the server-side connections described below are separate external requests. Nothing is sold.

Optional GitHub repository access

Connecting GitHub uses the native gh CLI in your member Environment on your own server. Your server contacts GitHub to verify the account, list repositories the account can access (including private collaborator and organization repositories), look up a selected repository, and fetch its selected source branch over HTTPS. GitHub receives these authenticated requests under its own policy. There is no new Cloudfield-operated authorization broker or analytics service, and this connection is separate from signing in to an edge and from an agent's model-provider account.

The native token is stored in homes/<member>/.config/gh/hosts.yml on your server. The server reads it for GitHub API requests and source fetches. A source mirror stores only the authorizing member and numeric GitHub account binding with its source metadata, not a copy of the token. Cloudfield does not send that token to the dashboard, the edge, or other members, or put it in workspace database records, on-disk Git configuration, URLs, or command arguments. It is used in server memory and the fetch child's temporary environment.

This is fetch-only source access, not a read-only token scope: native gh permissions can include broad repository access. Your own agents already have access to your native login in your member home. Imported code is deliberately shared with the workspace's authorized members and sessions; the token is not. Repository data remains on your server until the relevant workspace/session data is deleted; removing upstream access does not erase already imported code.

Logout, token expiry or revocation, member removal, or an account switch prevents further refresh with that binding without moving the accepted source revision. Disabling or deleting a source mirror does not delete the native login or revoke authorization at GitHub. To remove the native login and revoke GitHub authorization, see GitHub credentials and signing keys.

Push notifications

Off until you turn on Notify this device when a session needs me in the dashboard's Settings, in a browser, in the dashboard added to a home screen, or in the Android app (networking.md).

Turning it on makes that browser register with its vendor's push service - Google's for Chrome, Mozilla's for Firefox, Apple's for Safari, Microsoft's for Edge - and hand your server what the service issued: an address for that browser and two keys. Your server stores those three values with your member ID. It removes them when you turn the switch off on that device, when the push service reports the address gone, and when your member record is removed.

When one of your sessions starts needing you, or a session your assistant launched or messaged finishes, or needs you and is another member's, your server sends one HTTPS request per subscribed browser to that browser's address, and one more to each of those browsers when the session stops needing you. Nothing is sent for a member with no subscribed browser, and nothing is sent to the publisher. The push service receives:

  • The address, which is its own identifier for your browser, and your server's IP address.
  • The notification, encrypted on your server so that only that browser can read it (RFC 8291): the session's title or the first line of its task, one line saying why it needs you, and the session's ID. A digest or a burst's summary holds up to 5 such lines, each with its workspace's name. The push service sees its size, at most 4096 bytes, and when it was sent.
  • A signed token (RFC 8292): the public half of a key your server generated for this purpose, the push service's own address, an expiry, and the fixed contact https://github.com/3xDevOps/cloudfield. It names neither your server nor you.
  • Delivery settings: a 24-hour time to live, high urgency (normal for a reported success and for the message that clears a need), and a topic, which is a hash of the session's ID (of your member ID for a digest), so that a newer notification for a session replaces an undelivered older one.

The push service relays the message to your browser under its own policy.

In the Android app, turning it on registers the app with the UnifiedPush distributor app you installed, such as ntfy. The distributor's server issues the address; the app generates the two keys, keeps the private one on the phone, and sends the address and the public keys to your server, the same three values as above. The distributor and its server receive what a push service does, listed above, and relay it to the app; they cannot read the notification. ntfy's policy covers what ntfy.sh keeps. Turning it off tells your server to remove the values and the distributor to drop the registration. The app sends a declined assistant card's ID and the decision to your server, as the dashboard does. Send test notification sends the same request with the text Notifications work on this device. and no session.

While you use a dashboard, in any browser, the desktop app or the Android app, it tells your server so at most every 20 seconds. Your server keeps the time of the latest such report in memory, to hold your notifications while you are there. It is not stored, and no other member sees it.

Slack

Off until an admin runs sudo aether-server slack setup (slack.md) and a member links a Slack account. For each linked member the server sends Slack the titles of the sessions that need them, the need lines (which can quote an agent's reason), the text and options of pending requests, session IDs and the dashboard's address, and, in the link confirmation, the member's Cloudfield display name and the server's host name. Replies and button presses pass through Slack to the server. Nothing is sent to Slack for members who never linked.

Slack keeps the messages under the workspace's retention settings. Unlinking or removing the bot does not delete messages already sent. The tokens stay in 0600 files under <data-dir>/slack on the server.

What an edge stores

An edge is the relay and sign-in service that lets a computer running aether reach a server over SSH without Tailscale (edge.md). The Android app uses it only in Edge mode. Whoever runs an edge, the publisher for auth.onaether.dev and edge.onaether.dev, holds the following. The edge cannot read terminal, agent, file or dashboard content you reach over SSH, which is encrypted end to end between your computer and your server. An MCP connector's traffic is different: TLS ends at the edge, which decrypts each request, answer and token in memory to relay it (edge.md) and keeps none of them. Its journal logs requests it refuses before relaying, with the path and, from outside its trusted proxies, the client address, and internal relay failures; the nginx in front of it logs every request's client address, path, status and user agent.

What Why Kept
Your GitHub account: an account id the edge assigns, GitHub's user id, your login, verified primary email and display name, and when you last signed in with GitHub To sign you in and to match invitations Until you delete it on the edge's Account page, or its operator deletes it with aether-edge accounts delete
Each signed-in device: its label (the machine's host name unless you chose one), its public key, a hash of its token, when it signed in and was last used To let that device connect Until you revoke it with aether logout or the edge's Devices page
Browser sign-ins at the edge: a hash of the cookie To keep you signed in there 30 days after last use
A pending sign-in from aether login: the device label, public key and the IP address it started from To show you on the confirmation page where the sign-in came from Until the device collects its token or is denied; an expired one (after 10 minutes) until the next sign-in starts
Each server you claim: its id, its host name, the access policy it announces, you as its owner To route connections and show you your servers Until the owner removes it, or the edge's operator removes or blocks it. Deleting your account removes you as its owner
Each server the edge let your account connect to: its id and your GitHub user id To tell every server that may hold your identity when you delete your account Until you delete your account
A deletion owed to a server that was offline when you deleted your account: that server's id and your GitHub user id To tell that server to remove your identity Until it is sent, when the server next connects; at most 1000 per server
Each server's directory: the GitHub user id, login, email and role of its members and open invitations To refuse strangers before they reach the server Replaced every time the server sends it
Bytes relayed per month, not per person To enforce the operator's bandwidth budget Indefinitely
A server id the operator blocked, and when To refuse that server Until the operator unblocks it
An account the operator blocked: its GitHub user id, and when To refuse its sign-ins and claims Until the operator unblocks it, also after the account is deleted
The edge's log: server ids, error messages, and the IP addresses of refused connections and failed TLS handshakes To operate and defend the edge For the retention period its operator sets

Rate limits count requests per IP address, or per /64 for IPv6, in memory only; nothing is written. While you are connected, the edge also sees your IP address, which server you reach, when, and how many bytes flow. Your server logs the client address of a relayed connection whose grant it refuses (edge: refused relayed connection ... client=<address>). It logs accepted connections only at debug level, which the server does not emit.

Revoking your devices removes them from the edge; the account record stays. To delete it yourself, open the edge's Account page, https://auth.onaether.dev/account for the project's edge; aether logout --delete-account prints that address. The page asks you to sign in with GitHub in that browser within the last 5 minutes and to type your login (edge.md). The edge then deletes the account, its devices and sessions, and tells each server it reached to remove your identity there; what a server holds is its administrator's. You can also ask the edge's operator, team@onaether.dev for the project's edge, who runs aether-edge accounts delete.

Remote-development data

An enhanced session, and a background session over ACP, records its agent session on your server in <data-dir>/transcripts/<run_id>.items.jsonl: the prompts members send, the agent's messages and thoughts, tool call inputs, command output and diffs, permission requests and their answers. Whatever the agent or a tool prints, a secret included, can land there. Anyone with View on the session can read it through the dashboard; answering or messaging the agent needs the steer permission and the session's control lease. The log and terminal recordings persist until the session is explicitly deleted, including through workspace deletion. Checkout cleanup and archiving do not remove them. Standard sessions keep their terminal recording; older servers may already have trimmed history.

Files selected or pasted into chat are uploaded to the session's persistent member home before sending. So is the picture of each page element annotated in a session's Browser, when its note is sent; the note's text names that file and carries the element's markup and visible text as the page had them. Sending an Enhanced prompt passes image bytes to the agent and its configured model provider; any other file reaches the agent as its path, which the agent can read and pass on. Room records and the session item log retain small attachment references and file paths, not copies of the bytes. Members with View can fetch images attached to that session's retained messages. Removing a draft thumbnail or deleting a session does not remove the member-home file; see image retention.

The shared app browser runs on your server, not in the phone's WebView. Browser input, app-terminal input, observations, frames, and explicit capture requests travel through your Cloudfield server. A page opened there makes its own network requests from the session's network namespace; those app endpoints and any third parties the page contacts receive the usual browser requests under their own policies. This is separate from the Android shell's lack of analytics or third-party reporting.

The app browser can contain test-account cookies, tokens, personal data, page URLs, or secrets printed by an app or terminal. Reading the live session, streaming it, or taking a transient capture requires the steer permission and access to the backing account, not merely permission to view a session. Deliberately retained copies instead use capture access and expiry; review what you retain for that audience. Human members and the session agent have distinct per-surface control identities; taking over a shared app surface does not isolate that session's other processes or credentials from it.

The companion has no member-home or source-checkout mount. Its browser context/profile is transient companion state, outside source control. Resetting the browser context removes its pages and session state; a lost browser process does not silently restore an authenticated session. Private control sockets and lifecycle journals live below <data-dir>/scheduler/browser/, not in the checkout or the session's visible coordination files. See security.md.

Captures are explicit PNG files, not continuous recording. Each session can keep at most 64 captures, 128 MiB of PNG bytes in total, and 8 MiB per image. Reaching either aggregate limit refuses a new capture with session capture limit reached; delete captures before taking another; it does not silently evict old captures. Files and their metadata are stored below <data-dir>/coord/<run-id>/captures/, exposed read-only to the session as /run/aether/captures/<random-id>.png. Metadata identifies the session, terminal or page, session/revision, capture time, dimensions, and page URL where applicable. Optional Git HEAD and dirty-state fields describe only what was actually observed at capture time; absent fields mean unknown, not a clean checkout or the packet's later retained revision.

These captures remain transient session-owned files until explicit deletion or cleanup of that session's coordination mount. A retained Standard session keeps its mount and captures until expiry or deletion. The live browser's frame stream is not automatically archived. Browser diagnostics are bounded observations, not a full traffic recording: the companion retains up to 100 console warning/error entries and 100 failed/error-response request entries per page. URLs and logged messages can still reveal sensitive information.

To preserve a reviewed capture before cleanup, open Captures… from the session's More menu or a terminal's Tools, select it under Select transient captures to retain, optionally enter verification notes, and choose Retain selected captures. An agent with the advertised capability uses aether-internal artifact retain with selected artifact_ids, optional verification_notes, and an idempotency_key. This copies only the selected PNGs into the existing retained packet storage and returns a packet_id; it does not verify the application or report an outcome. Agents can pass that packet ID to the existing report --evidence-ref. Retain before a success/failure report, capture deletion, or other cleanup can remove the transient originals. A capture handle or live frame alone is not a durable record.

Retained copies remain readable after development processes stop, subject to capture access and expiry. Each session's retained copies are separately bounded to 64 captures, 128 MiB total, and 8 MiB per PNG across packets; deleting transient captures does not reclaim retained-copy space. Verification notes are bounded to 4096 UTF-8 bytes. Original source, capture time, session, geometry, URL and any observed Git boundary travel with the copy. The packet's later retained Git revision does not rewrite or attest to an earlier screenshot's Git boundary. Missing, truncated and expired captures are not a successful verification result.

Nothing is retained automatically. Resetting the browser does not delete already-written PNGs, and retaining an image does not upload it to a public pull request. There is no credential-entry recording. Do not capture credentials or publish app logins, cookies, tokens, or customer data; Cloudfield cannot reliably redact secrets an app renders in pixels or text, or those you include in verification notes. A member who explicitly downloads, exports or publishes a capture creates a separate copy under that destination's access and retention rules.

Messages one agent sends another stay on your server as workspace history until the sending or receiving session is deleted. Every member of the workspace can read their bodies, the same audience the Activity page has. Do not ask agents to pass credentials to each other.

The assistant

Your assistant keeps its conversation on your server under <data-dir>/assistant/<member>/:

  • items.jsonl is the transcript the panel shows: your prompts, the agent's replies, its tool calls and their results, and the action cards.
  • home/ is the agent's home: the sign-in you made for the assistant (.claude/.credentials.json or .codex/auth.json) and the conversation's session files (.claude/projects/ or .codex/sessions/). History, todos, file history, shell snapshots and debug logs exist only while a session runs; each start deletes them.
  • signin/ records the account of the sign-in you made: the Claude account and organization ids, the ChatGPT account id, or a SHA-256 hash of a Codex API key.

On every assistant start the server sends the sign-in's refresh token to the vendor's sign-in service and the new access token to its profile endpoint (Claude Code), to learn which account the sign-in belongs to.

  • install/ holds each agent's installed adapter, and install/<agent>.installed its version.
  • instructions/ holds the instructions the server gives it, and tools/ its tool socket.

Only the server process and your assistant's container read or write them; no session, environment or other member can, including members you share your account with. Anyone with access to the server's data directory, such as its administrator, can read them. Your prompts and the files the agent reads go to the agent's vendor under the account you signed the assistant in to.

New conversation deletes items.jsonl and everything in home/ but the sign-in. The output of a sign-in terminal, which shows the sign-in URL and, for Codex, a one-time code, is recorded like any terminal in <data-dir>/transcripts/assistant-login-<member>-<agent>.cast and deleted when the sign-in exits; if the dashboard was not attached then, at the next start or sign-in. Removing a member deletes the whole directory. Assistant state from before the assistant had its own container is in your home; assistant.md says how to delete it.

Team memory

Team memory is a store of short notes per workspace, kept in <data-dir>/aether.db (tables memory and its full-text index memory_fts). A note holds its text, its kind (decision, convention, gotcha, preference or outcome), up to 20 file paths it cites, the member it is attributed to, the session, agent and commit it came from, and who pinned it and when. Notes reach the store three ways:

  • An agent writes one with aether-internal memory add, or a member with aether memory add: at most 1024 bytes of text.
  • When a session's agent reports success or failure, the server writes one outcome note for that session: the report's summary and next action, with the files and HEAD commit of the session's latest snapshot. A later report rewrites it and clears its pin. Nothing is written while the session's owner is a viewer.

Every member of the server, viewers included, can read every note, and every session in the workspace can search them. The first line of each pinned note also goes into the brief each new session in the workspace receives at launch; a note a member pinned for themselves goes only into their own sessions' briefs. That limits whose briefs carry the note, not who reads it: team memory is never private. Only the note's owner or an admin may change a member note, and only an admin may read another member's brief.

Team memory never reads transcripts, terminal recordings, messages between sessions, session-room chat, the files in a checkout, or an agent's own memory files such as those under ~/.claude or ~/.codex. Nothing leaves your server: there is no embedding service and no model call.

Notes are scanned with gitleaks. A note an agent or member writes is refused when gitleaks finds a secret, with the rule and the line:col it matched. A report or answer with a secret is still recorded, with its text replaced by (withheld: gitleaks rule <rule> at <line:col>). gitleaks only finds the secrets it has rules for, so keep credentials out of reports and answers.

Notes do not expire. A collaborator or admin deletes one with aether memory rm <id>, or every note attributed to a session with aether memory rm --run <session>. Deleting a session deletes its unpinned notes; pinned notes stay until removed. Deleting the workspace deletes all of its notes. A replaced note stays, hidden from search unless asked for with --all, until it is removed. Removing a member keeps the notes attributed to them.

Before a release migrates the schema, aether-server update and Update now copy the database to <data-dir>/aether.db.pre-update and delete that copy once the new release has started. A note deleted while the copy exists is still in it, and a rollback restores it.

Assistant preferences

Preferences you ask the assistant to remember are kept in <data-dir>/aether.db (table member_preferences): the text, the workspace it applies to, whether it is on, where it came from (the assistant or Settings) with the id of the message it was quoted from, and when it was created, changed and last read.

Only you can read, change or delete your preferences. Teammates and admins cannot through Cloudfield, nor can your sessions or connected apps. Server operators with access to the database file can read it.

Forgetting a preference deletes its row. SQLite overwrites the deleted text (secure_delete) and the server checkpoints and truncates the write-ahead log; while another connection is reading, the forget still succeeds and the server retries the checkpoint in the background. The server also appends the preference's id, never its text, to <data-dir>/preference-tombstones before the delete commits, and does the same for an edit of its text, recording when the replaced row was last changed. When the server starts it deletes again every preference recorded as deleted, and every row no newer than one a committed edit replaced, so restoring an older database does not bring it back. If a forget's database commit fails after its tombstone was written, the next server start still deletes the preference. The file gains one short line per forget or edit and is never compacted. Forgetting does not remove:

  • the aether.db.pre-update copy an update keeps until the new release starts;
  • backups an operator made of the data directory;
  • sessions already launched with the text in their task;
  • the assistant transcript (<data-dir>/assistant/<member>/items.jsonl) and the agent's session files in home/ until you start a New conversation, which deletes both but the sign-in, as it does for a temporary conversation;
  • copies a connected app or an agent made elsewhere.

The dashboard keeps, in the browser's localStorage under aether.preferences.undone.<member>, the ids and versions of the last 200 changes whose Undo you used, so a card still reads Undone after a reload. It holds no preference text and is not sent to the server.

Removing a member deletes their preferences in the same transaction and records each as deleted in the same file before it commits. Merging two members moves all of them to the member that remains, even past the 200 limit; new saves are then refused until enough are forgotten.

Dictation

With dictation installed, the dashboard sends each clip you record to your server, never to the publisher or another service. The clip lives only in the server's memory while it is transcribed: the server does not write it to disk, log it, put it in audit entries or error messages, or keep it after the request, and the speech-to-text engine runs on the server with its log file set to /dev/null and no Docker logs. The server does not keep the transcript either; it returns to your browser, which puts it in the box you were typing in. Nothing is stored that you would need to delete.

Permissions

INTERNET lets the app reach your server, or in Edge mode the edge. ACCESS_NETWORK_STATE lets Edge mode read the active network's DNS servers, because Go's resolver finds no /etc/resolv.conf on Android; the app reads no other network state. RECORD_AUDIO lets the dashboard's mic button record for dictation. The app asks for it only the first time the page requests the microphone, grants it only to the dashboard's origin, and records only while you use the button. The app does not store the audio; the server's handling is under Dictation. The androidx library adds one signature-level permission the app defines for its own receivers, which no other app can hold and which grants nothing.

Deleting your data

  • On the phone: uninstall the app, or clear its storage. In Edge mode, also revoke the device at the edge (What an edge stores), since the edge keeps its record of the device until you do.
  • At an edge: see What an edge stores.
  • On the server: the server's administrator owns the data directory and can delete a session, a member home, or the whole directory (install.md). aether member remove removes your environment, deletes your member record and erases your member home. It refuses while anything still points at you - a session you launched, a schedule you own, or an agent profile you pushed - so an administrator deletes those first; what a session wrote stays in the data directory until it is deleted too (teams.md). The publisher holds no copy and cannot delete anything on your behalf.
  • Evidence: deleting a session, or the packet's 30-day expiry, removes its evidence packets at once. The Git objects they retained stay in the workspace repository until one background git gc runs there, 30 seconds after the last such removal in that workspace. A gc that fails or sessions past 5 minutes logs gitengine: evidence prune failed and is retried at the next hourly evidence sweep or server start.

Children

The app is not directed at children and has no age-specific content or features.

Licence and open source notices

The app and the dashboard are under the GPL-3.0, and the libraries they use are listed with their licences in notices.md. The app's first screen links to both that page and the licence text.

Changes

Changes to this policy are commits to this file; its history is public at https://github.com/3xDevOps/cloudfield/commits/main/docs/privacy.md.