Inspect an item
daimon why explains what Daimon can prove about one recalled item without
collapsing several kinds of evidence into a trust score.
The normal workflow is:
daimon recall retry policy
daimon why o-3f8a2c
daimon resolve o-3f8a2c --dry-run
daimon resolve o-3f8a2c --note "shipped in 0.27.0"
recall prints the exact item ID in brackets. why is project-scoped by
default, just like recall; use --project PATH or --slug SLUG to name a
different scope explicitly. It never guesses across projects.
Reading the evidence
The inspector reports independent axes because they can legitimately disagree:
| Axis | Values | Meaning |
|---|---|---|
| Capture | verified, not-verified, unknown | The deterministic capture-time quote result recorded in a durable receipt. |
| Provenance | bound, legacy-inferred, legacy-unbound | Whether the quote carries a self-contained source receipt or only older diagnostic metadata. |
| Locator | resolved, absent-local, unsupported, ambiguous, unreadable, remote-author | Whether the strict host resolver can identify exactly one readable local source. |
| Bytes | unchanged, changed, unknown | Whether current source bytes reproduce the receipt digest. |
| Current support | message-id-match, transcript-scan-match, not-reproduced, not-checked | Whether the stored quote can be reproduced now. |
| Verifier | same-version, different-version, unknown | Whether the current deterministic verifier matches the recorded verifier. |
| Lifecycle | active, resolved, forgotten, superseded | The latest append-only lifecycle state. |
Corroboration is shown separately as a count and source-session references. It does not modify any evidence axis.
preceding_tool_context is a separate audit section. Its observed state
maps each verified assistant quote source to up to 20 preceding tool-result
row IDs, ending at a recognized host user-input boundary. unavailable names
why the host capture could not establish that window, and not_recorded is
used for older checkpoints. An empty result list under observed means the
bounded window contained no tool results. These IDs describe recorded order
only and never prove that the model read or used a result; tool output and
arguments are never stored.
For example, these facts can coexist:
Now: capture verified; source changed; quote supported by its bound message
Bytes: changed
Current support: message-id-match
That does not mean the item is fabricated or invalid. It means the complete source file changed while the bound message still supports the quote. The axes preserve that distinction instead of inventing one result.
JSON
Use --json for automation:
daimon why o-3f8a2c --json
The V1 document has schema_version, stable values under axes, item metadata,
corroboration references, the durable receipt when one exists, a ranking
block, and no derived summary field. Scripts should inspect the axes they
actually care about.
Ranking
ranking publishes the ordering key Daimon itself uses, together with the
inputs that produced it:
{
"effective_weight": 0.448,
"computed_at": 1800000000.0,
"item_type": "recent_decision",
"rules": "recent_decision",
"inputs": {
"importance": 8,
"importance_source": "item",
"trust": "verbatim",
"trust_ceiling": 3.0,
"first_seen": "2026-08-01T00:00:00Z",
"age_days": 10.0
},
"factors": {
"base": 0.8,
"recency": 0.7,
"type_decay": 0.8,
"overdue_boost": 1.0,
"raw": 0.448
}
}
The weight is recomputed on every read and is never stored, because it decays
with age: a value written at capture time would be stale by the time anything
read it. computed_at is the epoch it was computed against, and the number
cannot be interpreted without it.
The point of publishing the inputs is that a consumer can redo the arithmetic
and land on the same number. raw is the product of the four factors, and
effective_weight is that product under the trust ceiling. The ceiling
saturates rather than truncating, so raw above the ceiling is normal and
still ordered.
Two values are deliberately not what they look like:
importance_source: "default"means the item carried no importance and 5 was substituted. An unscored item is not an importance-5 item.age_days: nullmeans no usablefirst_seen, which is not the same as a brand new item. Recency falls back to neutral rather than maximum.
rules names the type rules the computation actually applied, which differs
from item_type whenever the item's kind maps to no known type.
Exit codes describe command execution, not epistemic state:
0: the uniquely scoped item was rendered, including degraded evidence states;1: the item was not found in that project;2: invalid arguments or item-ID shape.
Source disclosure
Default output is metadata-only and prints no raw transcript excerpt. Add
--source deliberately:
daimon why o-3f8a2c --source
When validated message bindings are available, Daimon reads the raw source in memory, extracts at most three bound messages and 600 collapsed characters, then redacts once at the final display boundary. It never persists the excerpt or prints an absolute transcript path.
When exact bindings are unavailable, the inspector shows the already-redacted stored quote and states that the exact raw message span cannot be reconstructed safely. It does not redact stored evidence a second time.
not-reproduced is a current observation, not an accusation. Sources can be
edited, truncated, migrated, or parsed differently by a newer host adapter.
Use the other axes to understand which condition actually changed.
Which sets refuse the window
The window is drawn from the raw transcript, and redaction only catches known
secret shapes, never free text someone deliberately forgot or a person
quarantined. No key can scan a block of transcript for one value, so the
refusal is set-based rather than per item. --source is refused when any of
these holds, and the refusal names the reason and never a count:
reason | When |
|---|---|
closed | The trust ledger cannot be read, so nothing can be proven not quarantined. |
forgotten-set | Any forget tombstone exists on this machine, in any project, or a teammate published one. |
quarantine-set | This project holds an active quarantine. |
withheld-item | The item itself is withheld. |
The cost is stated plainly: once anything has been forgotten anywhere on the
machine, why --source is refused everywhere, for good, because tombstones
never expire. The item itself still prints; only the transcript excerpt is
withheld. A count would say how many values other tenants forgot, so none is
published.
A withheld id
An exact id the reader may not see still answers, with the marker in place of the value:
$ daimon why o-3f8a2c
Now: capture unknown; item withheld; lifecycle active
Item: [o-3f8a2c] [question] [withheld: quarantine tr-1a2b3c4d5e6f] (daimon trust show tr-1a2b3c4d5e6f)
Lifecycle: active
The marker is one of [withheld: quarantine tr-…] (a person quarantined the
value; daimon trust show has the record), [withheld: trust ledger unreadable] (nothing can be proven not quarantined; run daimon status) and
[withheld: forgotten]. In --json the item's text and quote are
{"state": "withheld", "reason": …} (plus quarantine_id for a quarantine),
ranking, receipt, source and preceding_tool_context are null, and
current_support is withheld. No value, key, quote, tool context or
transcript window is in the document. The evidence axes that rest on the
item's quote receipt (capture, provenance, locator, bytes, verifier) still
report: the view keeps a textless projection of the receipt when it withholds
a copy, so a quarantine or a teammate's forget does not blank how the item
was captured. The receipt, the source and the quote themselves are not
published. An id that is only a tombstone has no copy to project and reports
unknown.
Forgotten is announced only here: daimon why, daimon blame and the
viewer's why page say [withheld: forgotten] for the one exact id you asked
about. Every listing (daimon diff, recall, the briefing, status, the
viewer's tables) treats a forgotten value as absent: no row, no count, no edge.
Asking about an id that was never stored answers no item, so the one thing
an exact-id question can learn is that this id was stored and later forgotten,
which is the same fact a teammate already receives as a tombstone.
One exception, for rulings. A ruling enforces, and a silently shorter anchor
set would let a gate built on it fail open. So every ruling row a reader may
see carries as_ratified, always present, and it is false when one of its
enforcement values (its anchors, the anchors a guard matched, or its check's
match or body) is withheld for any reason. The bit is on ruling list --json
and ruling show --json, and their text output prints not as ratified: an enforcement value is withheld. The briefing's standing rulings tag the line
[not as ratified], and the viewer's rulings lane shows the same tag. The row still never names, counts or locates the value. Refutation rows
carry no such key. The armed-check manifest is built from the same checked rows, so a ruling that is not as ratified arms nothing, and check sync and hooks install say how many were skipped. refute guard matches the anchors and subjects a reader may see, so a withheld one never fires it. refute search likewise matches and ranks only values the reader may see.
An id whose copies are gone but whose lifecycle the ledger still names (a
resolved loop that left every retained checkpoint) prints Item: … (content unavailable) and its lifecycle; daimon blame answers the same id the same
way.
Where an id is looked up
A lookup is bounded by this project's bucket, never by the machine, and never rebuilds the recall index:
- the pointer window (
latest.jsonand theprev-N.jsonfiles kept byDAIMON_CHECKPOINT_HISTORY, three by default); the newestcreatedstamp wins when several copies differ; - the recall index, opened read-only, only to learn which session file holds an id the window no longer does; the value comes from that file through the same visibility rule as everything else;
- the forgotten-id and quarantine records;
- nothing.
An item answered from the index alone (a teammate's mirrored checkpoint with
no local file, or a legacy file with no project stamp) is checked at read time
like any other copy and is marked index_only in the JSON. A row whose local
file is torn, or is stamped for another project, is not used at all: the
answer is no item.
What this changes, each in the safe direction (it can under-announce, never leak):
- A quarantined item older than the pointer window, whose quarantine record
was opened without
--item-id, readsno item: the record names a value, not an id, and the value is no longer in any copy the lookup reads. The internal answer saysoutside_window, which is where it looked. - The same id can read
[withheld: quarantine …]while the index still holds its pre-quarantine row andno itemafter the next index rebuild, so the answer can change with the timing ofdaimon recallor any other call that warms the index. whyanswers for this project's own bucket. It no longer reaches the other slugs listed inDAIMON_EXTRA_READ_SLUGS.- An item serialized since the last index build is found through the pointer window only.
occurrences counts the distinct sessions the window and the index know to
hold the id, not every copy on disk.
Verbs that act on an id
daimon resolve, reverify, amend propose, anchor --attach and forget
choose their target through the same visibility rule as every read. None of them
prints, counts or writes a value the reader may not see.
A text query never guesses. resolve <text> and forget <text> bind only
when exactly one visible item matches and no withheld item also does. A visible
hit beside a withheld one is ambiguous, because binding it would be a guess
about a value you cannot see. The refusal says ambiguous and lists the
visible candidates, then one count line and the verb's own pointer:
o-3f8a2c [open_questions] the release pipeline needs a rollback step
1 withheld item(s) also match; use the exact id (daimon status --suppressed lists them)
resolve by exact id: daimon resolve <id>; daimon loops lists the open items
A miss prints no item matches '<query>' and the same pointer line, never a
list of everything. The count line is not printed while the trust ledger cannot
be read, since then every item is withheld and a number would only say which
queries matched. anchor --attach is stricter: it looks at visible items only
and prints no count, because a substring plus a count lets one find a hidden
value a character at a time.
By exact id:
| the id is | resolve, reverify | amend propose | forget |
|---|---|---|---|
| visible | binds | binds (open loops only) | binds |
| quarantined | a person binds it, no echo; an agent is refused (exit 2) | refused on every channel (exit 2) | a person binds it; an agent is refused (exit 2) |
| withheld because the trust ledger cannot be read | refused on every channel with daimon trust repair (exit 2) | refused on every channel (exit 2) | binds on every channel |
| forgotten | not found | not found | not found |
Item-id verbs exist on the CLI, the viewer and the in-process api; the MCP tools take no item id by design (pinned by test).
A forgotten id is never a write target for resolve, reverify or
amend propose: these bind through the same visibility rule as every read, which
reads a forgotten id as no match for a person and an agent alike. forget
does not take one either. Plaintext a forget left behind is finished by
daimon forget --resume (daimon ledger repair <name> for one ledger).
An exact id on forget does outrank an outage of the trust ledger, because the
id names no value.
What a forget writes, and the two verbs that finish or lift one
A forget appends three kinds of row to events.jsonl in one write: the id row
you named, a key row on a forgotten-key: ref of its own, and one row for every
sibling id that held the same value on any surface (a prev-N copy counts). The
id row names the content key in its status, so even a torn tail withholds the
value. The key ref is a random token and is derived from nothing, so it tells a
reader nothing about the value.
A reopen on the id replaces only the id row, so the value stays withheld. Only
daimon unforget lifts a forget:
daimon unforget <id>takes the exact id the forget receipt printed and lifts every standing ref that carries the key, in one append ofreopened:unforgetrows. It needs a person at a terminal and has no agent channel. The check is whether stdin is a terminal, as fortrust release, so a host that runs an agent's commands inside a pseudo-terminal passes it.- It restores nothing. The value was removed from every surface, so the lift only lets a new capture of the same claim back in.
- It proves the lift or exits 4. Exit 0 means no other project on this machine, no teammate's published row and no unproven ledger still withholds the value. Otherwise it says which class does: another project on this machine, a teammate's published row (they lift it), or a ledger it could not prove. It never names a project or an author.
- An agent channel, an unknown id and a forgotten id all get the same refusal, before any lookup, so the verb cannot be used to ask whether an id was forgotten.
daimon forget --resume takes no target and needs a person at a terminal. It
finishes every phase for every standing forget of the project: the key row, the
team publish, the value-keyed and id-keyed scrubs, the wholesale purges and the
derived caches. A surface it could not reach is listed as unreached: with its
cure and the run exits 4; run it again after fixing the cause. A forget made
before the key row existed is a single id row that a reopen still lifts.
--resume writes the missing key row and prints one line with the count, and
from then on only unforget lifts those too. --only <phase> runs one phase,
and --republish is the publish phase (--resume --only publish).
--dry-run previews a resume (how many forgets, how many
would get a key row, which phases, which ACTIVE rulings) and writes nothing.
A checkpoint copy or team mirror copy that cannot be parsed keeps forget at
exit 4 until a person fixes the file by hand; --resume reports it each run.
A published tombstone row has no retraction because tombstone rows carry no
version and no fail-closed hook; that gate exists for quarantine rows only. So
unforget lifts your machine and leaves the row you published, and a teammate
who already folded it keeps withholding the value until they remove it.
Nothing writes the value. The event resolve and reverify append holds
the id, the status and the note, never the item's text, and the serializer's
supersede candidate holds the two ids and nothing else. --dry-run prints
would resolve <id>: <text> for a visible target and the marker for a withheld
one. forget checks a ledger record on both the subject it prints and the
value your query matched, so a refutation whose evidence restates a
quarantined claim is counted, not listed.
anchor --attach keeps every other byte. It patches one item by its
position in the stored checkpoint and writes the rest back as it was, so a
quarantined item the briefing hides is still there afterwards. The topic is a
valid target.
Relations and the quote audit. daimon relations list and show, and the
viewer's relations panel, read each edge's endpoint text through one lookup: a
visible endpoint prints its text, a quarantined one (or any endpoint while the
trust ledger cannot be read) prints the marker, and an edge that touches a
forgotten item is left out and counted nowhere. daimon audit quotes audits the
copies a reader may see, so a quarantined or forgotten item is neither checked
nor printed.
Prose in the ledgers
The refutation, ruling, request, amendment and trust ledgers hold what people
and agents wrote, and a person's sentence can be exactly the value a
quarantine or a forget withholds. Every verb that prints a record (refute,
ruling, request, amend list, trust, decide, the request inbox tool
and the viewer's refutations lane), in text and in --json, checks each prose
column as a whole value: a forgotten value is blank, a quarantined one is
[withheld: quarantine tr-…], and a copy of an item's text is masked while the
trust ledger cannot be read. What a person wrote stays readable then, as the
standing rulings do in the briefing. A request is a join between two projects,
so it is checked by every project it names.
A ceremony does not ask for a signature on text the person cannot read:
ruling ratify, ruling revise, ruling propose --ratify and the refute
verbs that act on a record stop with exit 2 and write nothing when the record
(or the words just typed) has a withheld field. This holds on every channel,
a terminal included: a quarantine is a person's latch, so the record stays
frozen until daimon trust show <id> on a terminal and daimon trust release <id> lift it, which the refusal says. A forgotten field says the record
cannot be revised. The signature binds the stored record, never what was
displayed.
daimon trust show and daimon trust list give the evidence a quarantine cites
to a person at a terminal. Non-interactive callers see Evidence: [N withheld]
in the text and no evidence key in the JSON, and the quarantine's reason is
masked for everyone. A quarantine whose value was forgotten shows no value key.