Skip to main content

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:

AxisValuesMeaning
Captureverified, not-verified, unknownThe deterministic capture-time quote result recorded in a durable receipt.
Provenancebound, legacy-inferred, legacy-unboundWhether the quote carries a self-contained source receipt or only older diagnostic metadata.
Locatorresolved, absent-local, unsupported, ambiguous, unreadable, remote-authorWhether the strict host resolver can identify exactly one readable local source.
Bytesunchanged, changed, unknownWhether current source bytes reproduce the receipt digest.
Current supportmessage-id-match, transcript-scan-match, not-reproduced, not-checkedWhether the stored quote can be reproduced now.
Verifiersame-version, different-version, unknownWhether the current deterministic verifier matches the recorded verifier.
Lifecycleactive, resolved, forgotten, supersededThe 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: null means no usable first_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:

reasonWhen
closedThe trust ledger cannot be read, so nothing can be proven not quarantined.
forgotten-setAny forget tombstone exists on this machine, in any project, or a teammate published one.
quarantine-setThis project holds an active quarantine.
withheld-itemThe 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:

  1. the pointer window (latest.json and the prev-N.json files kept by DAIMON_CHECKPOINT_HISTORY, three by default); the newest created stamp wins when several copies differ;
  2. 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;
  3. the forgotten-id and quarantine records;
  4. 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, reads no item: the record names a value, not an id, and the value is no longer in any copy the lookup reads. The internal answer says outside_window, which is where it looked.
  • The same id can read [withheld: quarantine …] while the index still holds its pre-quarantine row and no item after the next index rebuild, so the answer can change with the timing of daimon recall or any other call that warms the index.
  • why answers for this project's own bucket. It no longer reaches the other slugs listed in DAIMON_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 isresolve, reverifyamend proposeforget
visiblebindsbinds (open loops only)binds
quarantineda 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 readrefused on every channel with daimon trust repair (exit 2)refused on every channel (exit 2)binds on every channel
forgottennot foundnot foundnot 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 of reopened:unforget rows. It needs a person at a terminal and has no agent channel. The check is whether stdin is a terminal, as for trust 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.