Privacy and Stored Data
What Daintree keeps and what leaves your machine: where data is stored on each platform, what telemetry does and does not send and how to turn it off, and how macOS folder access permissions work.
Data storage
Owner-only on POSIX
Persisted runtime data is written owner-only on macOS and Linux: files at 0600 and directories at 0700, to reduce accidental exposure through the default umask on a shared machine. This is best-effort (a failure to tighten permissions does not fail the write) and it is a no-op on Windows, which uses a different model.
Forge tokens
Forge credentials (a GitHub or GitLab personal access token, a token imported from the gh CLI, or the credential of a forge a plugin adds) are stored in Daintree's electron-store config file as plain text. That is the same security model as ~/.gitconfig or a .env file, not OS keychain encryption. The file itself is owner-only per the section above, and the token is used only in the main process: the renderer learns whether a credential is saved and a fingerprint of it, never the value.
Plugin settings declared as secret are the exception: those are encrypted through Electron safeStorage with an OS-backed key. Where no OS keychain is available, such as on a headless Linux host, the secret is not saved at all rather than stored in plaintext, and the plugin's settings form says so. On Linux, Chromium's basic_text fallback does not count as a keychain, and a fixed-key result from an unavailable keyring is refused too. A project-scoped secret is kept in this machine's local settings for the project, never in the repository's .daintree/ folder.
If the keyring gives Daintree no key for the current session, secret fields say Keyring not available this session and ask you to restart Daintree to try again. Reads and writes use Electron's asynchronous secure-storage API with a one-minute timeout, so an unanswered password prompt fails the operation. Existing encrypted values are kept when a write fails.
Project environment variables
Sensitive project environment values (the ones whose names contain KEY, SECRET, TOKEN, PASSWORD, CREDENTIAL or PASSPHRASE as a word) are stored in electron-store, separate from the plaintext project settings file. They are still plain text: this is file-level isolation, equivalent to a .env file. Standard variables stay in the project's own settings.
Clipboard
Clipboard writes are capped before any native call: 8 MiB of text and 20 MiB for an image. Binary payloads skip the IPC byte-budget gate, so these handler-level caps are the actual backstop against a runaway renderer exhausting the main-process heap. Clipboard image files are written to a temp directory bounded at 20 files and a 24-hour age. Daintree checks that the directory is its own and tightens it to owner-only before each save, refusing a planted symlink or a directory another user owns, and creates each image owner-only without following a link.
Image decoding happens in the main process out of necessity rather than preference: a renderer-side binary clipboard write crashes on Linux. Plugin clipboard reads are text-only by design: there is no image, HTML or file read for plugins, because the read side is where richer payload types would let a plugin pull out more than it declared.
Local data and cleanup
App-managed settings, project state, and session history live locally in Daintree's app data directory. Shared recipes, presets, lifecycle configuration, and project plugins can instead live in the repository's .daintree/ directory. Agent CLIs maintain their own configuration and session files as well. A project on a remote host keeps its backend settings and state on the host. The machine you work from keeps its device settings, browser session data and the records it needs to reopen remote windows, and nothing is synced between machines automatically. Two maintenance behaviors are worth knowing:
- Database maintenance never overwrites a good backup with a corrupt one. The backup is only replaced once the new copy verifies, so a corrupted primary cannot take the recovery path down with it. See Crash recovery.
- V8 heap snapshots are pruned automatically. V8 is configured to dump a heap snapshot when a process approaches its memory limit, which can help diagnose memory problems and may contain sensitive runtime data. A count-based prune keeps the ten newest and deletes the rest, strictly filtered by extension so ordinary logs and crash reports are never touched.
- Native crash dumps are pruned too. On macOS and Linux, Daintree prunes the local Crashpad dumps itself: anything older than 30 days, beyond 20 dumps or past 100 MiB in total goes, and the newest dump is always kept. On Windows they are left in place. Uploading them is disabled; see Telemetry content boundaries.
Linux packages disable Electron's cookie-encryption fuse so a locked or missing keyring doesn't hold up startup. Browser cookies therefore don't get that at-rest encryption. The fuse stays on in macOS and Windows packages. Plugin secrets use the separate OS-backed storage described above; disabling cookie encryption doesn't allow secret settings to be saved without a keychain. See the Linux release change for this platform-specific exception.
The Data & storage subtab of Settings > Privacy & data holds the local controls: Data folder opens the app data folder; Log retention (below); Clear cache clears the HTTP disk and code caches for the app, browser panels and dev previews, leaving sign-ins, site data and settings alone; Session history sets how long resumable agent sessions are kept and can clear them, keeping bookmarked sessions; and Reset all app data deletes every setting, API key, recorded session and log on this machine and restarts with factory defaults. A reset does not touch your repositories or their .daintree/ folders.
Telemetry is only one source of network traffic. Features you use can contact forge APIs, update and plugin services, documentation search and images, avatar services, websites opened in browser panels, and voice providers. Agent CLIs also communicate with their providers under their own configuration, and the Daintree Assistant is one of them: Claude Code, Codex or Antigravity on your own account. During an Assistant session the CLI also connects to Daintree's documentation search at https://daintree.org/api/mcp and, while Follow runbooks is on (the default), to the runbook search at https://assistant.daintree.org/v1/daintree/mcp, which receives a one-sentence summary of each task. The privacy policy sets out what each receives. Canopy reads agent terminals on your machine and sends none of them; while it is on, it checks Hugging Face once a launch for a newer model. With Remote Hosts, Daintree also connects to the hosts you add over your own ssh, with no Daintree relay in between; discovery reads Tailscale's local status and Bonjour on your network, and a machine in Host mode advertises itself over Bonjour unless you turn that off. A host can download a Daintree release from the release feed when you install or update it there. See What Crosses the Network. Separately, if you turn on Decisions and connect a relay, Daintree sends your agents' questions and your answers, end-to-end encrypted, to a relay in your own Cloudflare account so they can reach your phone, with no Daintree server involved; Decisions Privacy and Data sets out what that relay and Cloudflare can see, including optional dictation on the phone, which is not end-to-end encrypted. Turning telemetry off does not turn those features into offline tools.
Telemetry and privacy
Telemetry is off by default and stays off until you explicitly pick a level.
| Level | What is sent |
|---|---|
| Off (default) | Nothing. No crash reports, no analytics, no requests to the telemetry service at all. |
| Errors only | Crash reports and error details, sent to Sentry. No usage analytics. |
| Full usage | Crash reports plus a set of anonymous usage events, each carrying its name, a timestamp and event-specific properties. |
A change applies at once. Choosing Off stops uploads mid-session, including reports already queued for retry, and turning a level on starts reporting without a restart. Nothing is sampled: at a level that sends, every report is sent. Below the levels, What's collected at each level lists the fields each level sends and names every analytics event.
Preview outbound telemetry (Open preview) opens the Diagnostics Dock's Telemetry tab with a session-only mirror of every sanitized payload Daintree would send. The preview is held in memory and transmits nothing.
On the separate Data & storage subtab, Log retention (7, 30 or 90 days, or Keep forever) governs how long local log files survive. It defaults to 30 days; older files are pruned at startup, so a change takes effect on the next launch. It is unrelated to telemetry and applies whether or not anything is being sent anywhere.
Telemetry content boundaries
Daintree's telemetry is designed for diagnostics and a limited set of usage events, not repository or conversation collection. Error reports are scrubbed for known paths and secrets, and native minidump upload is disabled because binary crash memory cannot be sanitized by the JavaScript hook. Free-form error data still deserves review: pattern matching cannot establish that arbitrary content contains no personal information. Inspect the preview and review any diagnostics bundle before sharing it.
See the telemetry initialization and sanitizer for the fields and limits actually enforced.
No agent provider probes
Earlier versions pinged Anthropic, OpenAI and Google on a timer and on every window focus to show provider reachability, regardless of which agents you actually used. Those probes were removed in v0.31. Daintree no longer makes periodic outbound requests to model providers. This says nothing about traffic you initiate through an assistant, voice input, a browser page, or an agent CLI.
Path and PII scrubbing
Before any report leaves the process, a scrubbing pass runs over paths and then over secret shapes. Both passes are idempotent. The path scrubber replaces the account segment with a placeholder and covers more forms than the obvious ones:
- macOS and Linux home paths, including the case where the path ends at the username with no trailing segment.
- Windows user paths on any drive letter, not just
C:, in backslash, JSON-doubled-backslash and forward-slash forms. - WSL UNC paths: both
\\wsl$\<distro>\home\<user>and\\wsl.localhost\.... The distro name is kept as useful signal; only the username is redacted. - Git remotes, where the organization and repository segments name private projects. The host is kept; the path is redacted, including nested group hierarchies.
- Tilde-relative paths, temp directories and macOS per-session folders, which carry usernames and session tokens.
Crash report titles and Windows argument paths were both closed as PII leaks in v0.22: a title is a surface that is easy to forget, because it is assembled separately from the body it summarizes.
Crash report environment suppression
Node's diagnostic report includes a top-level environmentVariables field by default. Even after path stripping and secret scrubbing, that field is a known PII vector: it carries arbitrary user-set variables that no pattern set will catch in full.
Daintree handles it two ways. The utility processes it forks are launched with --report-exclude-env, so the field never reaches the payload from those processes at all. The main Electron process cannot take that flag, since its execArgv is owned by Electron's bootstrap, so the diagnostics collector rebuilds the report from a field allowlist instead, dropping the environment at construction time. Different mechanism, same outcome.
Pre-consent buffering and first-run consent
During first launch, before you make a telemetry choice, up to 100 usage events are buffered in memory and sent nowhere. Choosing Full usage flushes the buffer; choosing Errors only or Off discards it permanently.
The first-run setup offers a single switch, Help improve Daintree by sharing anonymous crash reports: on means Errors only, and it starts off. Full usage is only selectable in Settings afterwards, so a first-run choice always discards the pre-consent buffer.
To change your level later, open Settings > Privacy & data.
Canopy
Canopy is the app's inbox of every agent you run, ordered by what each one needs from you. To build it, Canopy reads each agent's terminal on your computer, with a small model that ships inside Daintree. It is on by default, including after an update, and it is separate from telemetry: turning telemetry off does not stop Canopy, and Canopy's setting does not change telemetry. Turn it off with Read agent terminals in Settings > Canopy.
Nothing Canopy reads leaves this computer. While Read agent terminals is on, the only request Canopy makes is to Hugging Face, once a launch, to ask whether a newer revision of its model has been published; one that has is downloaded in the background and checked against the published hashes before Canopy reads with it. With reading off, nothing is checked or downloaded.
Turning Read agent terminals off stops reading and deletes the readings Canopy holds on this machine. Turning Show Canopy off removes its toolbar button, shortcut and command palette entry and stops reading too. A remote host keeps its own Canopy setting. The privacy policy covers the model check.
macOS folder access
This section is macOS only. The first time a CLI agent running inside Daintree reads or writes files in certain protected folders, macOS shows a dialog along the lines of "Daintree" would like to access files in your Documents folder. The request may come from a CLI agent or from Daintree's own file operations. macOS can attribute a child process's request to the app that launched it. Granting access authorizes that folder access under macOS's privacy controls.
Which folders trigger a prompt
macOS gates a specific set of user folders and volumes behind Files and Folders permissions: Desktop, Documents and Downloads; removable volumes; network volumes; and iCloud Drive plus third-party cloud storage served through the File Provider API.
Keeping projects outside protected locations reduces these prompts. An agent reaching into a protected location can still trigger one. The exception is a project that lives in a protected location: a repository cloned into ~/Documents, ~/Desktop or iCloud Drive prompts during ordinary in-project work. Cloud-synced folders cause git and terminal problems on top of the prompts; see the cloud-synced folder warning.
Why Daintree's name appears
Daintree runs CLI agents inside its own process tree: the main Electron process, a separate PTY host, node-pty, your shell, and finally the agent. macOS traces a file access request back to the root signed app bundle in that chain, and every child inherits that identity for permission purposes. That is standard behavior for any app that spawns sub-processes, not a Daintree design choice, and an Electron app has no way to re-attribute the request to the child.
Granting and revoking access
The simplest path is to click Allow when the dialog appears: that grants per-folder access on demand, which keeps the surface as tight as it can be, and macOS remembers the choice.
To review or revoke later, open System Settings > Privacy & Security > Files and Folders and toggle individual folders. You can also reset from the command line using Daintree's bundle identifier:
# Reset a single folder (Documents shown here)
tccutil reset SystemPolicyDocumentsFolder org.daintree.app
# Or other protected folders
tccutil reset SystemPolicyDesktopFolder org.daintree.app
tccutil reset SystemPolicyDownloadsFolder org.daintree.app
# Reset every TCC privacy grant for Daintree at once. This also clears
# microphone and camera approvals, so Voice Input will re-prompt.
tccutil reset All org.daintree.app After a reset, the next agent access to that folder triggers the dialog again. Prefer the per-service commands unless you want to wipe every grant.