Configuration
Daimon is configured entirely through environment variables. Every variable
resolves in the same order: the process environment wins, and anything not
set there falls back to the env file at ~/.daimon/env. Override the file's
location with DAIMON_ENV_FILE.
The env file exists because hooks run in whatever environment the host process
happened to inherit, a GUI-launched agent has no shell profile, so shell
exports are not a reliable channel. Its format is KEY=VALUE lines; a leading
export , surrounding quotes, blank lines, and # comments are tolerated.
Keep it chmod 600, it can hold API keys.
daimon configure manages the LLM backend knobs (see LLM backend)
and writes them to ~/.daimon/env. Everything else you set by editing that file
or exporting the variable.
Boolean variables accept 1, true, yes, or on as truthy (matched
case-insensitively where noted). A handful use different conventions, kill
switches that are on unless set to 0, or presence-based flags, and those are
called out in the "What it does" column.
Core
| Variable | Default | What it does |
|---|---|---|
DAIMON_DISABLE | off | Kill switch. When truthy, every hook becomes a no-op, no capture, no briefing. |
DAIMON_ENV_FILE | ~/.daimon/env | Path to the env file that backs every other variable. Read from the process env only (it names the file, so it can't live inside it). |
DAIMON_PROJECT_DIR | unset | Working directory of the session being briefed or serialized, used to route per-project checkpoints. Hooks pass the host's cwd through it; unset means daimon uses the working directory. A host with no project identity at all (the Hermes in-process hook) gets no briefing: an unknown project reads nothing. |
DAIMON_MODEL_CROSS_PROJECT | off | When truthy, the MCP tools may read outside this project's own scope: daimon_recall and daimon_brief accept slug, all_projects and a project path, daimon_status and requests_inbox accept a project path, and daimon_projects lists every bucket. Off, any request that leaves the own bucket is refused out loud with a message naming this setting, and daimon_projects lists only the own bucket; the tool descriptions then do not offer those arguments. A project that resolves to the own bucket is always answered. Read at process start from the process env or the env file, never from prompt content. Under DAIMON_TENANT_SCOPED it has no effect and the tenant refusal stands. The CLI is not governed by this setting: off tenant scope a shell can always choose its own directory. DAIMON_TENANT_SCOPED closes that for the CLI verbs. |
DAIMON_CAPTURE_HOST | unset | Host-set hint naming which agent produced a capture (claude-code, codex, windsurf, kimi, gemini, hermes, manual), forwarded by installed capture hooks (#594). Not something you set by hand: a hook wires it into the environment it hands to the CLI, for the cases a bare transcript path can't resolve on its own. |
DAIMON_SESSION_SPEAKER | unset | The one person this session belongs to, declared by the host. Fills an item's stated_by when the transcript carries no per-message said_by, and only for items bound entirely to user messages; anything citing an assistant or tool message stays unattributed. A pure label, never a key, so it does not touch DAIMON_AUTHOR's namespacing. Set it only where one session is one person for its whole life. A host that serves several people through a single session must leave it unset. |
DAIMON_SPEAKER_LINE | unset | The delimiter a host writes around its own speaker line at the head of each user message, for a host that serves several people through one session but does not author the transcript. Literal character(s) or the U+E000 spelling. When set, a user row that starts with <delim>from=<id> name="<name>"...<delim> gets said_by as name (id) and the line is cut from the content before anything reads it; only position zero counts, and only user rows. The value is host-declared, the same honesty as a row's own said_by. The host must strip the delimiter from user text before prepending its line, or a user can forge one. Unset means content is never read for attribution. |
DAIMON_MIN_MESSAGES | 10 | Minimum message count before a session is worth serializing. Shorter sessions are skipped. |
DAIMON_TIMEOUT | 420 | Total serialize budget in seconds, shared across retry attempts (per-attempt socket timeouts are capped to the remaining budget). Real serialize/merge calls on gateway and CLI backends run 74s–25min; keep ≥420 or slow calls and retries cannot fit. |
DAIMON_HUNG_AFTER | 1800 | Seconds past which a serialize spawn that produced no result line is treated as hung/killed rather than still running. Default 30 min sits safely beyond a slow run (production serializes take 4–25 min). |
Checkpoint store & GC
| Variable | Default | What it does |
|---|---|---|
DAIMON_CHECKPOINT_DIR | ~/.daimon/checkpoints | Root of the per-session checkpoint store. |
DAIMON_CHECKPOINT_KEEP | 100 | How many per-session checkpoint files to retain (newest-N). Older files are garbage-collected after a successful write. 0 disables GC entirely (keep forever). |
DAIMON_CHECKPOINT_HISTORY | 3 | How many checkpoint pointers to retain per directory (latest.json plus prev-1 … prev-(N-1)), so a failed serialize can fall back to a prior pointer. Minimum 1 (latest only). |
DAIMON_GC_PIN_IMPORTANCE | 9 | Item-importance threshold that pins a checkpoint file against GC: a file whose max item importance reaches this survives outside the newest-N window. 0 disables pinning (pure recency window); values above 10 are clamped to 10. |
Upgrading across 0.42.0, and what to run after any upgrade, is in the upgrade guide.
Carry
Deterministic cross-session carry-over of unresolved items.
| Variable | Default | What it does |
|---|---|---|
DAIMON_CARRY | on | Master switch for carry. On unless set to exactly 0 (any other value keeps it on). |
DAIMON_CARRY_FLOOR | 0.05 | Minimum effective weight for a carried item to keep carrying. At the default, decisions expire in ~5–6 weeks (importance-graded) and escalated open questions live ~3–4 months. |
DAIMON_CARRY_MAX | 24 | Cap on carried items per kind (native items never count against it or drop). Minimum 1. |
Briefing
| Variable | Default | What it does |
|---|---|---|
DAIMON_BRIEF_MAX_TOKENS | 3000 | Token budget for the injected briefing, estimated at 4 bytes per token (no tokenizer dependency). It is folded into one byte budget, min(DAIMON_BRIEF_MAX_BYTES, DAIMON_BRIEF_MAX_TOKENS * 4), that every block of daimon brief shares. 0 = unbounded. |
DAIMON_BRIEF_MAX_BYTES | 9728 | The byte budget for the WHOLE stdout of daimon brief, in UTF-8 bytes. UTF-8 bytes are never fewer than the characters or UTF-16 units a host counts, so a byte budget is the safe side of every host limit (table below). The --label line, the fallback and in-flight warnings, the handoff baton, the rulings, the request and decision panels, the cognitive body, the code-drift block, the teammates section and the withheld-items note all count against it. When it runs short the briefing drops whole items in one fixed order (stale carried items first, background sections before actionable ones, carried before this session's own) and each section says what it hid. The greeting, standing rulings, the handoff and the newest decisions are never dropped; if those alone exceed the budget the brief says by how much. 0 = unbounded. |
DAIMON_MAX_BRIEFING_DECISIONS | 10 | Cap on decisions shown in the briefing (render-time view only, the checkpoint keeps all of them). The Decisions note counts what the cap cut. The newest min(3, cap) decisions from the last session are always shown. 0 = unbounded. |
DAIMON_BRIEF_GLOBAL_FALLBACK | header-only | Controls the cross-project global-pointer fallback when a project has no checkpoint of its own. Default shows a header only; set to full (or 1) to inject the full foreign body. A project with no identity never reads the global pointer, and on a DAIMON_TENANT_SCOPED home this setting and brief --global-fallback have no effect (the flag is refused). |
DAIMON_STALE_DAYS | 7.0 | Age threshold (days) past which a carried item's effective last-verified stamp (its last_verified, else the latest resolutions.jsonl event, else first_seen) is stale enough for brief to warn about it. 0 warns on every carried item. Past the threshold, the item itself renders as [? unverified] with its stored tag and age in a trailing suffix, instead of the stored trust tag (render-time only; daimon reverify restores the tag on the next brief). |
DAIMON_REQUEST_OVERDUE_DAYS | 7.0 | Days without any movement (opened, revised, accepted, needs-info, replied to, or claimed done) before a request its sender still has open reads overdue in daimon request list and in the sender's brief. Wall-clock, derived on read, independent of recipient sessions. 0 marks every open request overdue; a malformed value falls back to 7.0. |
DAIMON_PLAIN | off | When truthy (case-insensitive), forces plain-text output, disables the rich tables/panels in status, brief, and --help. |
NO_COLOR | unset | Presence-based, per the NO_COLOR convention: if the variable is set to any value (even empty), rich output is disabled. |
Host output limits behind the DAIMON_BRIEF_MAX_BYTES default
A session-start hook captures the whole stdout of daimon brief --label. These are the limits measured on each host, which is why the default is 9728 (9.5 KiB) and not higher.
| Host | Measured limit | What happens past it |
|---|---|---|
| Claude Code 2.1.314 | 10,000 UTF-16 units, after the output is trimmed | The output is spilled to a file and replaced by a 2 KB preview. The largest briefing seen unspilled was 8,920 characters, the smallest spilled one 10,508. |
| Codex 0.157.0 | About 10,000 characters (the unit is not confirmed; the banner mentions tokens) | About 10,000 characters are delivered with a "Warning: truncated output" banner and a "Full hook output saved to" trailer. |
| Kimi Code 0.43.1 | No cut seen, hook results complete up to 25,728 characters | None observed. |
| Gemini | Not measured | Unknown. |
| Windsurf | No briefing injection (the briefing is read from a terminal) | Not applicable. |
Raising DAIMON_BRIEF_MAX_BYTES above 9728 can push the briefing past the Claude Code and Codex limits.
Worldcheck
Opt-in (#365): a brief-time spot-check of carried PR/issue-state claims
against reality, via read-only gh probes. Default off, daimon brief runs
on the SessionStart hook's latency-critical injection path (an 8s subprocess
budget inside a 10s hook budget), so even budget-bounded network probes there
must be deliberately opted into. Flag off, no probe runs and nothing is
written. The render still reads each carried note's text, and one that names a
PR, branch, file or dependency gets a (noted <date>, re-check before acting)
suffix, so the output is not byte-identical to a build without worldcheck.
| Variable | Default | What it does |
|---|---|---|
DAIMON_WORLDCHECK | off | When truthy, spot-check carried PR/issue-state claims against reality via read-only gh probes at brief time. |
With worldcheck enabled, contradictions from file-existence, branch-existence, and PR/issue-state probes also demote the item in recall search and suggestions. The item stays visible. A later confirmation clears only the same claim's contradiction; a valid receipt cannot clear a missing-file finding. Skipped or unavailable probes neither invalidate nor clear anything. Dependency-version checks still annotate the briefing only. Evidence is recorded by whichever briefing path ran the check (the CLI, the MCP tool, the host API or the Hermes hook), through one shared commit; the renderer itself writes nothing.
| Surface | World-evidence collection with DAIMON_WORLDCHECK=1 |
|---|---|
| Claude Code, Codex, Gemini CLI, Kimi Code | Supported through each host's existing daimon brief hook. |
| Windsurf | Supported when the agent runs daimon brief --team; no automatic session-start injection. |
MCP daimon_brief (own project, not a read by slug), Hermes in-process briefing hook, host API render_briefing | Supported. These paths run the same checks and record the same evidence as the CLI. The cost is about 3 s worst case per brief with the flag on: file and branch checks are disk reads, PR checks run gh under a 0.8 s deadline, and git remote -v has a 2 s timeout. The MCP loop is single-threaded, so that brief blocks the host's other MCP calls for that long, the same bound the CLI hook already pays. A daimon_brief call by slug never runs worldcheck, because a slug names a bucket and not a repository path. |
| CLI and MCP recall, proactive suggestions | Consume recorded evidence through the shared recall index. |
Recall
| Variable | Default | What it does |
|---|---|---|
DAIMON_RECALL_DB | per store (see right) | Test-only: pins one explicit recall index file and skips the per-store naming. Leave it unset. The derived recall index (SQLite FTS) is never a source of truth, so it is safe to delete at any time. The default store keeps ~/.daimon/recall.db; any other store (DAIMON_CHECKPOINT_DIR, --data-dir) gets its own ~/.daimon/recall/<hash>.db. daimon heal removes per-store indexes whose store is gone or that went 30 days unused. |
DAIMON_RECALL_SEEN_DIR | ~/.daimon/recall_seen | Per-session suggestion-cooldown state so a repeated topic never re-injects. Disposable, deleting it only resets cooldowns. |
Tenant scope
For a host that runs one daimon home with one project directory per person. A single person's machine never needs either variable. Both are read at process start, from the process env or the env file, never from prompt content, so a model cannot set them.
| Variable | Default | What it does |
|---|---|---|
DAIMON_TENANT_SCOPED | off | When truthy, a caller may not choose a scope. --slug and --all-projects on recall, brief, why and decide, --all on audit privacy, --global-fallback on brief, and a --project that names another bucket on any verb are refused with a plain error, and DAIMON_BRIEF_GLOBAL_FALLBACK is ignored. daimon decide shows no counts of other projects, daimon status shows no global pointer, and a read never falls back to another project's checkpoint. The MCP tools refuse any slug, all_projects or project path outside the caller's own bucket the same way (DAIMON_MODEL_CROSS_PROJECT cannot lift it), and daimon projects lists only the caller's own bucket. Refused, never silently narrowed: a caller who asked for a scope and got their own instead would read the answer as complete. |
DAIMON_GIT_POSTURE | ambient | How daimon asks git about a project directory. ambient lets git answer as it always has. sealed is for hosts whose project directories are written by a less trusted party: daimon finds the checkout itself below a ceiling (home by default), pins the git directory, reads only the checkout's own config file with includes off, takes the branch from HEAD, never asks git for user.name, and refuses a .git that is a file, a symlink or a pointer to another directory. A checkout whose config holds anything outside a short allowlist of keys (no include, filter, diff, merge, alias, core.sshCommand and the like), or that has a config.worktree or an objects/info/alternates file, is refused before git runs on it. A host can state a project's slug and origin URL itself with declare instead of letting daimon derive them; the declared root still passes the checks above. A refused project is listed by daimon status and its path-based briefing, and writes to it are rejected. |
DAIMON_EXTRA_READ_SLUGS | unset | Comma-separated slugs this session may read beside its own, ambiently, with no caller argument involved. Reaches recall, why and the proactive suggestion path alike. Read only: no write path takes a slug and a session never writes to a listed scope. A hit from a listed scope names its origin project. Meant for a shared scope whose contents were already visible to everyone in it; set it only where one session is one person. |
DAIMON_MODEL_CROSS_PROJECT, the MCP-side counterpart, is listed in the Core table above.
Team memory
Opt-in shared-memory mirror. See team memory for the model and set up team memory for the steps. The daimon-team.toml format is in team configuration.
| Variable | Default | What it does |
|---|---|---|
DAIMON_TEAM | off | When truthy, mirror each checkpoint into the shared team dir so brief --team can surface teammates. Gates writes only, reads of the team dir are always allowed. A synced remote additionally requires the project to be in its scope allowlist (see team.md); out-of-scope projects mirror to the local dir only. |
DAIMON_AUTHOR | git user.name, then OS user | Team author identity used to namespace your checkpoints. Falls back to git config user.name, then the OS username, then unknown. |
DAIMON_TEAM_DIR | ~/.daimon/team | Root of the shared team-memory mirror. |
DAIMON_TEAM_PROJECT | unset | Explicit logical project path for this machine's sessions (relative, e.g. core/api-gateway). Overrides the sidecar's daimon-team.toml mapping and the origin-derived fallback when routing checkpoints under projects/. |
DAIMON_TEAM_RETENTION_DAYS | 365 | Read-time age window: teammates' checkpoints older than this many days are skipped when reading. 0 = keep all. Never physically deletes from the shared append-only branch. |
DAIMON_TEAM_APPLY_FORGET | off | Standing consent for a TEAMMATE's published forget tombstone to rewrite this machine's own checkpoints. NOT sufficient alone, the apply also requires the typed daimon team sync --apply-forget, because a bare daimon team sync is spawned detached at SessionStart. Default off: a foreign tombstone always suppresses the value on read and in the index, but deleting local belief state from someone else's hash is a decision to make knowingly, the shared branch is append-only, so there is no undo. Without it, daimon team sync --apply-forget refuses at exit code 2 before syncing anything. When set, daimon team status and the team line of daimon status report it as armed. |
DAIMON_LIVE_DELIVERY | off | When truthy, an undecided request addressed to this project is delivered to a session that was already running when it arrived, at that session's next turn boundary, instead of waiting for its next SessionStart briefing. Render surface only: the ledger stays store-and-forward, the delivered nudge is the same pull-only record the next briefing would have shown, and the verbs that decide stay human-only. Once per session per revision; a request revise re-delivers the sharpened ask. Same daimon home only. Default off, briefing-only is the right posture for short sessions, so an always-on consumer turns this on deliberately. |
Receipts
Opt-in signed provenance receipts (#204). When enabled, each checkpoint is
paired with a vitni local-binding
receipt: an Ed25519-signed statement that binds the checkpoint's exact on-disk
bytes (outputs_hash) to its source transcript (inputs_hash), written to a
<session>.receipt sidecar. This makes a post-hoc edit to a checkpoint file
detectable. Receipts are fully valid offline, nothing leaves the machine.
Every step is fail-open: a missing CLI, missing openssl, timeout, or bad
output logs one line to serialize.log and proceeds without a receipt, a
receipts failure never blocks or fails a serialize or a briefing. Verify a
checkpoint on demand with daimon verify-receipt [session]; at briefing time a
receipt-era checkpoint whose receipt is missing or no longer matches its bytes
has its ✓ verbatim labels degraded with a visible note.
Public-key derivation prefers the vitni CLI's keygen command (vitni 0.5.0+) and
falls back to openssl on older CLIs or a failed probe, so on macOS, where Apple's
LibreSSL has no Ed25519 in openssl pkey, receipts work once vitni ≥ 0.5.0 is
installed, with no openssl-with-Ed25519 required.
| Variable | Default | What it does |
|---|---|---|
DAIMON_RECEIPTS | off | When truthy, mint a signed receipt beside each checkpoint. Default off, a new subprocess per serialize is opt-in. |
DAIMON_VITNI_CLI | vitni-verify (on PATH) | The vitni verifier CLI used to sign/verify. A path or a name resolved on PATH. Contract: <cli> <command> with one JSON object on stdin and one JSON line on stdout. |
DAIMON_KEYS_DIR | ~/.daimon/keys | Where the Ed25519 signing seed (signing.seed, mode 0600, auto-created on first mint) and cached public key (signing.pub.json) live. |
Host hooks
Serialize-throttle knobs for hosts that lack a clean session-end event. See docs/hosts/ for per-host setup.
| Variable | Default | What it does |
|---|---|---|
DAIMON_CODEX_SERIALIZE_ON_STOP | on | Whether the Codex Stop hook serializes at all. On unless set to 0, false, no, or off (case-insensitive). |
DAIMON_CODEX_SERIALIZE_ON_SESSION_END | on | Whether the Codex SessionEnd hook serializes at all, the real end of a session, fired once on graceful teardown with the complete transcript, deliberately unthrottled. On unless set to 0, false, no, or off (case-insensitive). Does not replace Stop, which stays as crash insurance for a SIGKILL or a closed terminal that never reaches SessionEnd. |
DAIMON_CODEX_MIN_SERIALIZE_INTERVAL | 300 | Minimum seconds between Codex serialize spawns. 0 serializes on every Stop. |
DAIMON_KIMI_SERIALIZE_ON_STOP | on | Whether the Kimi Stop hook serializes at all. On unless set to 0, false, no, or off (case-insensitive). Stop is the capture path for kimi -p print mode, which never fires SessionEnd, so turning it off leaves print-mode sessions uncaptured. |
DAIMON_KIMI_SERIALIZE_ON_SESSION_END | on | Whether the Kimi SessionEnd hook serializes at all. On unless set to 0, false, no, or off (case-insensitive). |
DAIMON_KIMI_MIN_SERIALIZE_INTERVAL | 300 | Minimum seconds between Kimi Stop serialize spawns for one session. 0 serializes on every Stop. |
DAIMON_ACTION_RECALL | on | Whether the pre-action recall hook may add one prior-work line before a shell command. On unless set to 0, false, no, or off. Read from the process environment or ~/.daimon/env, so a host launched from a desktop session sees it too. |
DAIMON_MCP_TOOL_AVAILABLE | off | Set by the hook entry that registered the read-only MCP server for its host, never by hand. When on, the per-prompt recall hint tells the model to call the MCP tool instead of printing the daimon recall shell command. |
DAIMON_MCP_TOOL_NAME | daimon_recall | Set by the same hook, next to DAIMON_MCP_TOOL_AVAILABLE: the name this host shows for the recall tool, which differs between hosts. A value that is not 1 to 128 letters, digits or underscores is ignored and the default is used. |
DAIMON_WINDSURF_MIN_SERIALIZE_INTERVAL | 300 | Minimum seconds between Windsurf serialize spawns (Windsurf has no session-end event, so capture runs on this throttle). 0 serializes every turn. |
DAIMON_WINDSURF_FINALIZER_QUIET_SECONDS | 600 | Quiet period after the last Windsurf activity before a debounced finalizer serializes the trajectory's final transcript state, covers sessions whose last turns land inside the throttle window. Fractional values accepted; 0 disables the finalizer. |
DAIMON_WINDSURF_DIR | ~/.daimon/windsurf | Where the Windsurf adapter keeps the transcripts it accumulates. Read by both the hook that writes them and the forget/heal paths that delete them, change it in one place only, or the writer and the deleter stop agreeing. |
DAIMON_WINDSURF_STATE_DAYS | 7 | Age window for daimon-authored Windsurf transcripts and unparsed payload dumps, reaped by daimon heal. A privacy bound: a forgotten value cannot be located inside prose, so this limits how long the source conversation lingers between forget runs. Clamped to at least 1, unlike the other Windsurf knobs, 0 does not disable it. |
The sealed git surface that embedding hosts use is described in the Python API.
Scar harvest
Opt-in negative-knowledge drafting (#76). At session end, daimon scans the
transcript for scar-shaped lessons, dead ends ("we tried X, it broke"),
intentional-looking weirdness worth fencing, non-obvious couplings, and
drafts candidate files into <project_root>/.scars/candidates/. The scan
is zero-LLM (pure-stdlib marker matching, English and Spanish) and
path-anchored: a hit that names no real file or directory in its own
sentence is dropped. Precision over recall, a scar system dies from noise,
not from a missed lesson.
The boundary with the Scar project,
stated plainly: daimon only drafts candidates. Linting, pre-edit
injection, and promotion to active scars are Scar's job, install it in the
target repo to make the candidates useful. daimon never writes into
.scars/ itself, never overwrites an existing candidate (a human may have
edited it), and caps how many candidates one session can emit.
Honest limits: candidates are heuristic drafts and require human review
before promotion. The harvest only runs in repos that have opted in by
having a .scars/ directory, without one it is a silent no-op even with
the flag on. Candidate text passes through the same secret redaction as
checkpoints, so candidate files are committable.
| Variable | Default | What it does |
|---|---|---|
DAIMON_SCAR_HARVEST | off | When truthy, draft scar (negative-knowledge) candidates at session end into .scars/candidates/, repos with a .scars/ directory only. |
Heal escalation
Opt-in (#360): daimon heal's default retry re-runs the same extraction
shape that already failed. Escalation re-serializes from several distinct
perspectives instead, merged by the ordinary merge pass, multiplying the LLM
token cost roughly by the perspective count on your own backend, which is why
it ships off by default. Gates the heal path only: the session-end default
serialize never escalates, flag or no flag.
| Variable | Default | What it does |
|---|---|---|
DAIMON_HEAL_ESCALATION | off | When truthy, daimon heal re-serializes from multiple perspectives instead of retrying the same extraction shape. Heal-path only. |
Capture while a ledger cannot be read
When a project's events.jsonl cannot be read (a conflict marker, a bad byte,
an OS error), daimon will not write a checkpoint for it: the forget gate would
have to guess, and a forgotten value could come back. The session is refused
before the model is called, which costs nothing. The refusal is an ordinary
failed serialize. daimon status counts it from the whole log and names the
cure, the project's next briefing says how many sessions are waiting, and
daimon heal retries them one per session start once the ledger reads again,
without spending the single retry. A refusal is lost only when its transcript
is gone.
| Host | Refused capture |
|---|---|
| Claude Code, Codex, Gemini CLI, Kimi Code | Supported: counted, briefed and retried by daimon heal while the host keeps the transcript. |
| Windsurf | Supported, with one limit: daimon's own 7-day reap of Windsurf transcripts (DAIMON_WINDSURF_STATE_DAYS) still applies, so a session refused for longer than that is lost and counted as unrecoverable. |
| Hermes in-process capture | Supported only when the host passes a transcript path that exists. Without one it is counted as unrecoverable and cannot be retried. |
Scene traces
Opt-in experiment (#317): the serializer asks for a per-item scene, one to
two sentences of episodic context, alongside the rest of the extraction.
Gated on the LongMemEval harness clearing it as a net win before it can
become default.
| Variable | Default | What it does |
|---|---|---|
DAIMON_SCENE_TRACES | off | When truthy, ask the serializer to also produce each item's scene field. |
Ops & diagnostics
| Variable | Default | What it does |
|---|---|---|
DAIMON_LOG_DIR | ~/.daimon/logs | Log directory. The hooks resolve it exactly as the CLI does (process env, then this file), so serialize.log, the heartbeats and serialize-crash.log move together: what a hook writes under a redirected directory is what daimon status, daimon heal and daimon forget read and purge there, and nothing lands under the default. |
DAIMON_CLAUDE_PROJECTS_DIR | ~/.claude/projects | Where host transcripts live (<slug>/<session>.jsonl). Read-only, the quote-reverification audit reads them to re-check stored quotes against their source. |
DAIMON_LOG_STDOUT | off | When truthy, serialize result lines also reach stdout, the stream a container runtime collects. The session-end hook lets the detached serialize child inherit stdout instead of discarding it, and the CLI mirrors its error: lines there too, so success, skip and error all land on one surface. Intended for container hosts, where a line written only to serialize.log on a volume is invisible to the platform. Off by default: on a terminal host these lines arrive in your shell minutes after the session ended. It does not touch stderr, which stays reserved for serialize-crash.log. |
LLM backend
Serialization needs an LLM endpoint. daimon configure is the intended way to
set these, and daimon configure --init runs the guided wizard: backend,
timeout, an immediate backend test, an optional team-memory walk (author +
remote, wired through daimon team init), ending with the daimon status
summary. Every prompt has a flag escape hatch (--backend, --timeout,
--author, --team-remote) so scripts and CI can run it non-interactively.
The URL, key, and model each fall back to a LITELLM_* variable if
the DAIMON_* form is unset. The litellm backend needs both
DAIMON_LLM_MODEL and DAIMON_LLM_API_KEY; while either is missing,
daimon configure reports backend: litellm — missing: ... naming exactly
what is absent, that line means the config is incomplete, not that the
endpoint is down.
| Variable | Default | What it does |
|---|---|---|
DAIMON_LLM_BACKEND | auto | Transport: auto (litellm if credentials exist, else a named command CLI if one resolves), litellm, command, or claude-cli. claude-cli is the zero-config option: it runs a claude found on PATH with a built-in preset and needs nothing else set. command requires DAIMON_LLM_COMMAND. |
DAIMON_LLM_BASE_URL | http://localhost:4000 | OpenAI-compatible endpoint URL (trailing slash trimmed). Falls back to LITELLM_BASE_URL. |
DAIMON_LLM_API_KEY | unset | API key for the endpoint. Required for the litellm backend. Falls back to LITELLM_API_KEY. |
DAIMON_LLM_MODEL | unset | Model name to send. Required for the litellm backend. Falls back to LITELLM_MODEL. |
DAIMON_LLM_TEMPERATURE | 0.0 | Sampling temperature for every chat call. 0.0 for deterministic extraction; some upstreams reject anything but a fixed value. |
DAIMON_LLM_FALLBACK | on | When the primary backend fails, auto-fall-back to the rescue command (DAIMON_LLM_COMMAND_FALLBACK). Applies to both a litellm and a command primary. Set to 0 to disable. |
DAIMON_FALLBACK_MIN_SECONDS | DAIMON_TIMEOUT | Minimum budget the rescue command is guaranteed on entry. The primary may have drained the shared serialize deadline retrying the very failure the rescue exists to fix, which would kill the rescue on arrival; a healthy remaining budget is never shrunk. |
DAIMON_RESAMPLE_MIN_SECONDS | DAIMON_TIMEOUT | #553: minimum budget the validation resample is guaranteed on entry, the same failure #341 fixed for the command fallback, one path over. The shared deadline can be drained by the attempt whose output just got rejected, which would hand the resample nothing to work with. Defaults to timeout_seconds() for the same reason DAIMON_FALLBACK_MIN_SECONDS does. |
DAIMON_LLM_STREAM | on | Stream the litellm response so the socket timeout bounds the inter-frame gap rather than the whole completion. Without it, a long completion trips the timeout and retries from scratch. Set to 0 to disable. |
DAIMON_LLM_NO_CACHE | off | When truthy, bypass gateway response caching per request, needed when a cached bad response pins a failure or runs must be statistically independent. |
DAIMON_LLM_BRIEFING | off | When truthy, render the briefing via the LLM instead of the deterministic template. |
DAIMON_LLM_COMMAND | unset | Full CLI invocation for the command backend (binary + model + flags). Required for command, and required for a claude on PATH to be used by any backend other than claude-cli. |
DAIMON_LLM_COMMAND_OUTPUT | unset | How to extract assistant text from the command's stdout: text (raw stdout) or json:<key> (parse JSON, read <key>). |
DAIMON_LLM_COMMAND_INPUT | stdin | How the prompt reaches the command backend: stdin (piped), arg (appended as the final argv element), or file:<flag> (written to a tempfile, then <flag> <path> appended). An unrecognized value logs a warning and falls back to stdin. arg is capped at 100,000 bytes by the operating system. For the primary this is a hard cap on every prompt: a larger one fails before any backend call, naming this variable. daimon configure names a backend in arg mode. |
DAIMON_LLM_COMMAND_FALLBACK | unset | The one rescue CLI, used when the primary backend fails. Works for both a litellm primary and a command primary, which previously had no rescue direction at all. One fallback, never a chain: if the primary and this both fail the cause is almost always environmental, and a third CLI spends budget reaching the same error while making the install look better protected than it is. When unset, a litellm primary still falls back to DAIMON_LLM_COMMAND as before. |
DAIMON_LLM_COMMAND_FALLBACK_OUTPUT | unset | Output spec for the rescue CLI, same grammar as DAIMON_LLM_COMMAND_OUTPUT. Carried separately because the rescue is a different binary. |
DAIMON_LLM_COMMAND_FALLBACK_INPUT | stdin | Input spec for the rescue CLI, same grammar as DAIMON_LLM_COMMAND_INPUT. The 100,000-byte arg cap applies to the rescue too, but only as a soft limit: merges are sized to it (a deeper merge tree), and a larger chunk or perspective prompt runs on the primary without a rescue, with a warning that names this variable. |
A claude binary merely present on PATH is not adopted automatically. Serializing sends the full session transcript to whichever CLI is configured, so that CLI has to be named: either DAIMON_LLM_COMMAND, or DAIMON_LLM_BACKEND=claude-cli to opt into the built-in preset.
Previously an unset DAIMON_LLM_COMMAND plus a claude anywhere on PATH was enough for auto installs and for the litellm rescue path. If you relied on that, set one of the two variables above. daimon configure names the resolved binary and its path so you can see exactly which one is in use.
The claude-cli preset runs its claude -p child with --strict-mcp-config, so it loads no MCP servers. Without that flag, the child's own launcher exits early under the isolation env the serializer sets, and Claude Code caches that as a connection failure, so every new session on the machine skips daimon's MCP server for the next 15 minutes (#1077). If you point a DAIMON_LLM_COMMAND at claude yourself, add --strict-mcp-config to it too: the serializer only turns text into JSON and never needs an MCP tool.
The preset also passes --no-session-persistence when your claude lists it in claude --help (checked once per process), so a model call leaves no session in Claude Code's store; daimon configure warns if your claude is too old for it. Calls made before this are saved under ~/.claude/projects/ in directories whose name contains daimon-cli-; deleting them is up to you.
Serializer chunking
Long sessions are serialized in overlapping chunks whose partial checkpoints are merged hierarchically. The defaults come from field measurements; they only matter if your sessions routinely run very long.
| Variable | Default | What it does |
|---|---|---|
DAIMON_CHUNK_LINES | 1200 | Rendered-transcript line count above which serialization switches to chunked mode. |
DAIMON_CHUNK_OVERLAP | 100 | Lines of overlap between adjacent chunks, so an item straddling a boundary is seen whole by at least one chunk. |
DAIMON_CHUNK_CONCURRENCY | 4 | Parallel chunk-serialize LLM calls. Minimum 1 (sequential). |
DAIMON_MERGE_GROUP_SIZE | 3 | Max partial checkpoints merged per hierarchical merge call. Minimum 2. A group is split further when its request would exceed the arg-mode input limit of the primary or the rescue. Lower to 2 if merge calls die on a gateway with a server-side request ceiling (reasoning models generating 3-way merges can exceed it; raising DAIMON_TIMEOUT won't help, the kill is server-side). |
DAIMON_CHUNK_CACHE | on | #48: content-addressed cache of chunk-extraction output, keyed on the chunk's own bytes, so a re-run of a heal or retry re-pays a call only when the chunk source actually changed. Kill switch, on unless set to 0. |
DAIMON_CHUNK_CACHE_DAYS | 3 | Rotation window for the chunk cache, in days. Cached output is pre-redaction (the #125 quote-verification ordering forces this), so the window is a privacy bound as much as a disk bound, 3 days covers the heal/retry window while keeping exposure short. |