Reports: TODO/DONE format instead of checkboxes, much broader reportability bar

Format: '** TODO <title>' unread, '** DONE <title>' read -- tick deletes
DONE entries at the start of its next run (previously [X]). This only
changes the Reports heading's own keyword; :chat: entries and Close
diwan session stay checkbox-based, unaffected.

Reportability: reversed last turn's narrow 'only real findings' bar.
The report is now explicitly meant to be the one place Marc checks for
everything new or needing attention -- so triage moves, new dispatches,
session closures, and inline answers are reportable again, alongside
findings/ambiguities/problems and anywhere a note was left for Marc to
read (even one the agent already marked [X] itself -- that's not the
same as Marc having seen it). Only two exclusions remain: a run where
nothing happened at all, and a bare nudge (no information yet on
whether anything came of it).

No code changes -- this is PROTOCOL.md/TICK.md/DO.md/DESIGN.md only.
Also cleaned up one stale 'did nothing' entry in diwan-dev-notes'
diwan.org that violated the rule even under the old wording.
This commit is contained in:
marc committed 2026-11-09 23:08:42 +01:00
1 parent 43215d6e0a
commit 19e6ae3a59
4 files changed
+18 -18

No files matched your search

+2 -2
View File
@@ -62,8 +62,8 @@ Note what's *not* here: `last_tick_commit` is deliberately **not** updated by th
**Agent half** (`TICK.md`), five steps, each its own commit:
1. Triage `inbox.org` only (other files changing is someone else's edit): events → `esdeveniments.org`, tasks → wherever they actually belong, `:diwan:` items get moved but not acted on yet, new topics only get a new file when nothing existing fits.
2. Tag consistency: any `:session:`/`:chat:` heading without a `:diwan:` tag on itself or an ancestor gets `:diwan:` added directly to it. Then resolve `:chat:` ownership: chats under a `:session:` ancestor are left for that heading's own session; orphan chats get answered inline if trivial, or escalated (see step 3's three-way decision) if not.
3. Handle every `:diwan:`-tagged heading without an open `:session:`: trivial ones get answered inline, no tag beyond `:diwan:` ever assigned. Non-trivial ones split two ways — self-contained within the heading's own subtree gets a `:session:` tag and `diwan do <file>:<line> --diwan-id <slug>` run *by the tick agent itself* (the tick agent is the only thing that ever originates a fresh `DIWAN_ID`); inherently cross-cutting work (spans multiple files/headings, can't be parallelized — archiving, bulk cleanup, moving things between files) is done by the tick agent *directly*, right there, no session at all, possibly spread across several tick runs if it needs Marc's input first. The same handling applies to any open item under `diwan.org`'s `Tasks` heading — diwan's own self-maintenance backlog, no tag needed there since the location already signals it (see PROTOCOL.md's `diwan.org` section). Already-open sessions (`:session:` tag + `DIWAN_ID` present, `Close diwan session` still `[ ]`) get their subtree's content left alone as always, but are checked for a nudge: if any commit in this tick's change range *not* authored by the diwan git identity touched a line inside that subtree (a hand-authored heading edit, a new unread `:chat:` entry, anything Marc did), the tick agent re-runs `diwan do <file>:<line> --diwan-id <id>` on the existing ID — a continuation dispatch into the session's own tab/agent, not a fresh one — purely to wake it up; no nudge at all if nothing hand-authored touched the subtree. This is the only mechanism that gets a change Marc makes to an active heading in front of its own idle agent — nothing watches the file otherwise. A session whose `Close diwan session` is already `[X]` gets retired for real: the tick agent looks up its `DIWAN_ID`'s herdr tab and actually closes it (`herdr tab close`), then removes the `:session:` tag from the heading — the `DIWAN_ID` property itself is left in place as a historical record. None of dispatch, nudge, or closure get a Reports entry on their own; see step 4.
4. Delete any already-`[X]` Reports subheadings first, then — only for things that actually clear the "real information" bar, not routine mechanical steps like a bare dispatch or a session closure Marc asked for — write one short, titled, checkbox subheading per reportable thing this run did into `diwan.org`'s Reports log (not one paragraph for the whole run), each with the title itself linking to the one heading it's about (plain text if there isn't one) and a 1-2 line signed body. Zero new entries is a normal outcome.
3. Handle every `:diwan:`-tagged heading without an open `:session:`: trivial ones get answered inline, no tag beyond `:diwan:` ever assigned. Non-trivial ones split two ways — self-contained within the heading's own subtree gets a `:session:` tag and `diwan do <file>:<line> --diwan-id <slug>` run *by the tick agent itself* (the tick agent is the only thing that ever originates a fresh `DIWAN_ID`); inherently cross-cutting work (spans multiple files/headings, can't be parallelized — archiving, bulk cleanup, moving things between files) is done by the tick agent *directly*, right there, no session at all, possibly spread across several tick runs if it needs Marc's input first. The same handling applies to any open item under `diwan.org`'s `Tasks` heading — diwan's own self-maintenance backlog, no tag needed there since the location already signals it (see PROTOCOL.md's `diwan.org` section). Already-open sessions (`:session:` tag + `DIWAN_ID` present, `Close diwan session` still `[ ]`) get their subtree's content left alone as always, but are checked for a nudge: if any commit in this tick's change range *not* authored by the diwan git identity touched a line inside that subtree (a hand-authored heading edit, a new unread `:chat:` entry, anything Marc did), the tick agent re-runs `diwan do <file>:<line> --diwan-id <id>` on the existing ID — a continuation dispatch into the session's own tab/agent, not a fresh one — purely to wake it up; no nudge at all if nothing hand-authored touched the subtree. This is the only mechanism that gets a change Marc makes to an active heading in front of its own idle agent — nothing watches the file otherwise. A session whose `Close diwan session` is already `[X]` gets retired for real: the tick agent looks up its `DIWAN_ID`'s herdr tab and actually closes it (`herdr tab close`), then removes the `:session:` tag from the heading — the `DIWAN_ID` property itself is left in place as a historical record. Dispatch and closure both get a Reports entry (new/changed state Marc hasn't seen); a bare nudge does not, not because it's unimportant but because there's no information yet on whether it did anything — see step 4.
4. Delete any already-`DONE` Reports subheadings first, then write one short, titled `TODO` subheading per reportable thing this run did into `diwan.org`'s Reports log (not one paragraph for the whole run) — the bar is deliberately broad (items moved, dispatches, closures, inline answers, findings, notes left for Marc to read), excluding only a run where nothing happened at all and a bare nudge (no information yet on whether it did anything) — each with the title itself linking to the one heading it's about (plain text if there isn't one) and a 1-2 line signed body.
5. Only if 1–4 all succeeded: update `state.json.last_tick_commit` to current `HEAD` and commit under the diwan identity.
**Verified live** (2026-11-08, herdr 0.9.5 + Claude Code, before both the 2026-11-09 tool/content split and the pi-only harness switch): dispatched for real, ran to completion with zero permission prompts, correctly left two already-open `:session:`-tagged sessions untouched (back when `:session:` was still spelled `:diwan:`, before the tag rename — see "Known gaps" for what's unverified post-rename), correctly found nothing to triage, wrote a proper signed report, and updated `state.json` correctly. A second immediate `diwan tick` correctly no-op'd. **Not yet re-verified with a real dispatched agent** against the current state of things (post-split two-repo layout, `pi` as the sole harness) — path resolution and `pi`'s own startup have each been tested separately (see below and "Known gaps"), but not yet together through a full live tick run. Do that before trusting it for real.
+1 -1
View File
@@ -20,7 +20,7 @@ Don't mark your own entries `[X]` — that's Marc acknowledging them. You may ma
## Reporting
When you finish a notable piece of work — answered a chat question with real content, completed a chunk of delegated research, did something worth telling Marc about after being resumed/nudged — append one short entry of your own to `diwan.org`'s Reports log, in the format PROTOCOL.md's Reports section describes (a `[ ]` subheading whose title is itself a link back to your own heading, a signed one-or-two-line body). This is the one explicit exception to staying inside your own subtree: you may append a new entry there, but never edit or delete an existing one — that's `tick`'s job only. Don't report every small step, just the things Marc would actually want to know happened without reading your heading in full. Nothing about resuming or being nudged is itself reportable on its own — only report once you've actually done something as a result.
When you finish a piece of work — answered a chat question with real content, completed a chunk of delegated research, moved something, left Marc a note he hasn't seen yet, did something worth telling him about after being resumed/nudged — append one short entry of your own to `diwan.org`'s Reports log, in the format PROTOCOL.md's Reports section describes (a `TODO` subheading whose title is itself a link back to your own heading, a signed one-or-two-line body). This is the one explicit exception to staying inside your own subtree: you may append a new entry there, but never edit or delete an existing one — that's `tick`'s job only. The bar is broad — this report is the one place Marc checks for what's new, so err on the side of reporting rather than staying quiet — but it's still per *result*, not per step: don't write five entries narrating your own process, write one once there's something to show. Nothing about resuming or being nudged is itself reportable on its own — only report once you've actually done something as a result.
## Committing
+5 -5
View File
@@ -71,19 +71,19 @@ diwan's own operational file, at the root of the content repo — not a place fo
### Reports
Only things containing *actual information the user would want to know* — a finding, a decision made on their behalf, an ambiguity flagged, a problem hit — get a short subheading under the top-level "Reports" heading in `diwan.org`. Routine mechanical steps that were always going to happen and say nothing interesting on their own — "dispatched a session", "nudged an idle session", "nothing needed triaging this run", "closed a session Marc asked to close" — are **not** reportable; skip the entry entirely rather than writing one just to have something to show. It is normal and expected for a tick run to add zero new Reports entries. When something *is* reportable, keep it to its own short subheading, not one giant paragraph per run: this is what keeps each entry short and the whole log skimmable with everything collapsed. **Whoever actually did the thing writes the entry** — `diwan tick` reports its own actions (triage moves, inline answers, promotions, new dispatches), and a `diwan do` session reports its *own* progress once it has something worth telling the user, not before. In particular: a tick merely nudging an idle active session (see the `:session:` section above) is not itself reportable — tick has no idea yet whether anything came of it, so it stays silent; if the nudge leads the session to actually do something, that session writes the entry once it has.
This is the one place the user checks for what's new — a shortcut to everything that needs their attention, not just a highlights reel — so the bar for getting a short subheading under the top-level "Reports" heading in `diwan.org` is deliberately broad: items moved (triage), a new session dispatched, a session closed, an inline answer, a finding, a flagged ambiguity, a problem hit, or anywhere a note was left for the user to read (even one already marked `[X]`/acted-on by whoever wrote it — that means *they've* acted on it, not that the user has seen it yet). The only things that don't get an entry: a run where genuinely nothing happened at all, and a bare nudge to an idle session (not because it's unimportant, but because whoever sent it has no idea yet whether anything came of it — see the `:session:` section above; if the nudge leads to real work, that work gets its own entry once there's something to report). Keep each entry to its own short subheading, not one giant paragraph per run: this is what keeps the whole log skimmable with everything collapsed. **Whoever actually did the thing writes the entry** — `diwan tick` reports its own actions, and a `diwan do` session reports its own progress once it has something to tell the user, not before.
Format: a `[ ]`/`[X]` checkbox right in the subheading title (same pattern as `Close diwan session`), a short title that *is itself the link* to the one heading the entry is most about (fuzzy heading link, or `id:` link for a note file with an `:ID:` drawer — just plain text with no link if there's no single heading to point at), and a signed one-or-two-line body, no more. No `:LINK:` property, no properties drawer at all — any further links belong inline in the body text:
Format: a `TODO`/`DONE` keyword on the subheading itself, a short title that *is itself the link* to the one heading the entry is most about (fuzzy heading link, or `id:` link for a note file with an `:ID:` drawer — just plain text with no link if there's no single heading to point at), and a signed one-or-two-line body, no more. No `:LINK:` property, no properties drawer at all — any further links belong inline in the body text:
```org
* Reports
** [ ] [[file:personal.org::*Plan the kitchen redecoration][Kitchen redecoration: flagged a budget conflict]]
** TODO [[file:personal.org::*Plan the kitchen redecoration][Kitchen redecoration: flagged a budget conflict]]
[diwan 2026-11-08] The heading asks for a 3000€ budget but its linked Pinterest board is all 8000€+ kitchens — asked which one is right in the heading's own :chat: before researching further.
** [X] Archived personal.org's Tasques backlog
** DONE Archived personal.org's Tasques backlog
[diwan 2026-11-07] 45 DONE tasks moved into archive/archive.org, oldest from 2023 — personal.org's active list was getting hard to scan.
```
Unread = `[ ]`, read = `[X]`, same semantics as `:chat:` — the user checks an entry off once they've seen it. Once an entry is `[X]`, the *next* `diwan tick` deletes the whole subheading, not just the checkbox — this is a disposable log, not a record, and only `tick` ever deletes from it (a `do` session only ever appends its own new entries, never touches an existing one). Questions for the user still go in the relevant heading's own `:chat:`, not here — a report entry may link there, but the report itself is one-way, no back-and-forth expected.
Unread = `TODO`, read = `DONE` — the user marks an entry `DONE` once they've seen it. Once an entry is `DONE`, the *next* `diwan tick` deletes the whole subheading, not just the keyword — this is a disposable log, not a record, and only `tick` ever deletes from it (a `do` session only ever appends its own new entries, never touches an existing one). Questions for the user still go in the relevant heading's own `:chat:`, not here — a report entry may link there, but the report itself is one-way, no back-and-forth expected.
### Tasks
+10 -10
View File
@@ -23,7 +23,7 @@ Then, chat resolution: find every `:chat:` heading anywhere in the tree with at
- If it has a `:session:`-tagged ancestor: skip it. That heading's `DIWAN_ID` session owns it.
- If it does not: for each unread entry, decide trivial vs non-trivial.
- Trivial (you can just answer or act right now, no multi-step delegated work): do it, write your reply as a new signed entry (`[diwan YYYY-MM-DD] ...`), mark the original `[X]`.
- Trivial (you can just answer or act right now, no multi-step delegated work): do it, write your reply as a new signed entry (`[diwan YYYY-MM-DD] ...`), mark the original `[X]`. Report this in step 4 — you've left Marc a note to read, and he hasn't seen it yet even though it's marked `[X]` (that just means *you've* acted on it).
- Non-trivial: this is the same three-way escalation decision step 3 makes for any `:diwan:`-tagged heading — self-contained work gets a `:session:` tag and a dispatch, cross-cutting work gets handled by you directly, both as part of step 3. Leave the chat entry unread until the work is actually done and its own agent (or you, on a later tick) answers it.
Commit: `tick: resolve chat ownership and tag consistency`.
@@ -32,23 +32,23 @@ Commit: `tick: resolve chat ownership and tag consistency`.
Find every `:diwan:`-tagged heading in the tree (including ones just tagged in step 2).
- No `:session:` tag yet, and the request is trivial (quick lookup, one-line answer you can produce yourself right now): do it inline, write the result into the heading, and leave it — no session, nothing further to track. This is the common case for small asks.
- No `:session:` tag yet, non-trivial, and self-contained within this heading's own subtree (independent delegated work, nothing that needs writes to other files or headings): add the `:session:` tag and run `diwan do <file>:<line> --diwan-id <short-slug>` yourself (pick a short, readable slug from the heading text — `diwan do` will write the `DIWAN_ID` property and the `Close diwan session` checkbox item for you; don't hand-edit those). The dispatch itself isn't reportable (see step 4) — it was always going to happen, there's nothing informative to say about it yet.
- No `:session:` tag yet, non-trivial, and inherently cross-cutting — touches multiple files or headings at once, or can't be meaningfully parallelized (archiving, bulk cleanup, moving files/folders between locations, repo-wide renames): do this yourself, directly, right now, in small separate commits per coherent chunk — the same way you'd do any other tick step. Don't add a `:session:` tag for this; a subtree-scoped `do` agent would just hit the same wall a human doing it alone would. If there's a real judgment call to make first (not just mechanical execution), ask in the heading's own `:chat:` and leave the rest for a future tick once Marc answers, rather than guessing or acting unsupervised at scale. It's fine for this kind of task to span several tick runs — pick up wherever the heading's own content (and its sub-TODOs, if any) says you left off.
- Already has a `:session:` tag and its `Close diwan session` item is still `[ ]`: it's an active session, already being worked by its own agent — you still have no business editing inside its subtree, but check whether it needs waking up. Look at this tick's change range for any commit *not* authored by the diwan git identity (`diwan <diwan@local>`) that touched a line inside that heading's subtree — a direct edit by Marc to the heading body, a new unread `:chat:` entry, anything hand-authored. The tick's own start-of-run manual-edit snapshot commit is the usual source of these. If you find one, nudge the session: run `diwan do <file>:<line> --diwan-id <id>` again (same existing `DIWAN_ID` — this reuses the session's own tab/agent, it does not create a new one) so it re-reads the heading and notices on its own. If nothing hand-authored touched the subtree, leave it alone entirely, no dispatch at all. A nudge is not itself something to report in step 4 — you have no idea yet whether anything comes of it; if it leads the session to do real work, that session reports it, not you.
- Already has a `:session:` tag and its `Close diwan session` item is `[X]`: this session is being retired, for real, right now. Find its herdr tab (the `diwan` workspace, tab label == this heading's `DIWAN_ID`) and close it with `herdr tab close <tab-id>` — if it's already gone (closed by hand, e.g.), there's nothing to do there, move on. Then remove the `:session:` tag from the heading itself (leave `:diwan:` and any other tags alone). Leave the `DIWAN_ID` property in place — don't delete it, it's the historical record of what ran there, in case it's ever worth revisiting. Leave `Close diwan session` checked as-is. This is routine follow-through on something Marc explicitly asked for by checking the box — not reportable on its own (see step 4), unless something about the teardown itself was unexpected (the tab held uncommitted work, say).
- No `:session:` tag yet, and the request is trivial (quick lookup, one-line answer you can produce yourself right now): do it inline, write the result into the heading, and leave it — no session, nothing further to track. This is the common case for small asks. Report it in step 4 — it's new, and Marc hasn't seen the result yet.
- No `:session:` tag yet, non-trivial, and self-contained within this heading's own subtree (independent delegated work, nothing that needs writes to other files or headings): add the `:session:` tag and run `diwan do <file>:<line> --diwan-id <short-slug>` yourself (pick a short, readable slug from the heading text — `diwan do` will write the `DIWAN_ID` property and the `Close diwan session` checkbox item for you; don't hand-edit those). Report the dispatch in step 4 — a new session is new information even before it has anything to show for itself yet.
- No `:session:` tag yet, non-trivial, and inherently cross-cutting — touches multiple files or headings at once, or can't be meaningfully parallelized (archiving, bulk cleanup, moving files/folders between locations, repo-wide renames): do this yourself, directly, right now, in small separate commits per coherent chunk — the same way you'd do any other tick step. Don't add a `:session:` tag for this; a subtree-scoped `do` agent would just hit the same wall a human doing it alone would. If there's a real judgment call to make first (not just mechanical execution), ask in the heading's own `:chat:` and leave the rest for a future tick once Marc answers, rather than guessing or acting unsupervised at scale. It's fine for this kind of task to span several tick runs — pick up wherever the heading's own content (and its sub-TODOs, if any) says you left off. Report what you actually moved/changed in step 4.
- Already has a `:session:` tag and its `Close diwan session` item is still `[ ]`: it's an active session, already being worked by its own agent — you still have no business editing inside its subtree, but check whether it needs waking up. Look at this tick's change range for any commit *not* authored by the diwan git identity (`diwan <diwan@local>`) that touched a line inside that heading's subtree — a direct edit by Marc to the heading body, a new unread `:chat:` entry, anything hand-authored. The tick's own start-of-run manual-edit snapshot commit is the usual source of these. If you find one, nudge the session: run `diwan do <file>:<line> --diwan-id <id>` again (same existing `DIWAN_ID` — this reuses the session's own tab/agent, it does not create a new one) so it re-reads the heading and notices on its own. If nothing hand-authored touched the subtree, leave it alone entirely, no dispatch at all. A nudge is not itself something to report in step 4 — not because it's unimportant, but because you genuinely have no information yet: you don't know if anything comes of it. If it leads the session to do real work, that session reports it, not you.
- Already has a `:session:` tag and its `Close diwan session` item is `[X]`: this session is being retired, for real, right now. Find its herdr tab (the `diwan` workspace, tab label == this heading's `DIWAN_ID`) and close it with `herdr tab close <tab-id>` — if it's already gone (closed by hand, e.g.), there's nothing to do there, move on. Then remove the `:session:` tag from the heading itself (leave `:diwan:` and any other tags alone). Leave the `DIWAN_ID` property in place — don't delete it, it's the historical record of what ran there, in case it's ever worth revisiting. Leave `Close diwan session` checked as-is. Report the closure in step 4 — the session going away is a real state change Marc should see confirmed, even though he's the one who asked for it.
Also check `diwan.org`'s `Tasks` heading for any open (not-yet-`DONE`) item — these are the same kind of cross-cutting work as above, already homed in the right spot with no tag needed (see PROTOCOL.md's `diwan.org` section). Pick one up and make progress on it (or finish it) directly, in its own commit(s), the same way as any other cross-cutting `:diwan:` request; mark it `DONE` once actually finished, or ask via a `:chat:` child first if it needs a real judgment call from Marc.
Also check `diwan.org`'s `Tasks` heading for any open (not-yet-`DONE`) item — these are the same kind of cross-cutting work as above, already homed in the right spot with no tag needed (see PROTOCOL.md's `diwan.org` section). Pick one up and make progress on it (or finish it) directly, in its own commit(s), the same way as any other cross-cutting `:diwan:` request; mark it `DONE` once actually finished, or ask via a `:chat:` child first if it needs a real judgment call from Marc. Report what you did in step 4.
Commit after each dispatch, cross-cutting chunk of work, batch of inline answers, or session closure: `tick: dispatch <slug>` / `tick: <what you did>` / `tick: answer <heading>` / `tick: close session <diwan_id>`. A nudge doesn't change any file content on its own, so there's nothing to commit for it either.
## 4. Write the report
In `diwan.org` at the repo root, under a top-level "Reports" heading (create the file and heading if this is the very first tick), first delete any existing report subheadings already marked `[X]` in their title — Marc has read those, they're disposable, don't let them pile up (this applies to every entry regardless of who wrote it, including ones a `do` session appended).
In `diwan.org` at the repo root, under a top-level "Reports" heading (create the file and heading if this is the very first tick), first delete any existing report subheadings already marked `DONE` in their title — Marc has read those, they're disposable, don't let them pile up (this applies to every entry regardless of who wrote it, including ones a `do` session appended).
Then, and only if there's something that actually clears the bar, add one new subheading per reportable thing *this tick itself* did. The bar: real information — a finding, a decision you made on Marc's behalf, an ambiguity you flagged, a problem you hit. Below the bar, write nothing: a plain dispatch with nothing to say about it yet, a routine session closure Marc already asked for, a pass where nothing needed triaging, a nudge you sent (that one's not yours to report regardless, see PROTOCOL.md) — none of these get an entry. A tick run that did real mechanical work (moved files, dispatched a session, closed another) but has nothing *informative* to add writes **zero** new Reports entries, full stop — don't manufacture one just to show you were active; `git log` and `diwan.org`'s other headings already show that. Never one giant entry covering the whole run either — one subheading per reportable thing, and don't report anything that happened inside an active `do` session's own subtree (that session reports its own work). Keep titles short enough that Marc can skim the whole log collapsed and know what happened without opening anything. Each entry:
Then add one new subheading per reportable thing *this tick itself* did. The bar is deliberately broad — this report is the one place Marc checks for what's new, a shortcut to everything that needs his attention, so err on the side of including something: items moved (triage), a new dispatch, a session closed, an inline answer, a finding, a flagged ambiguity, a problem hit, or anywhere you've left a note for him to read (even one you've already marked `[X]` yourself — that just means *you* acted on it, not that *he's* seen it). The only things that don't get an entry: a tick run where genuinely nothing happened (no triage, no dispatches, no chat activity, nothing — don't manufacture an entry just to show you were active), and a bare nudge (not because it's unimportant, but because you don't yet know if anything came of it — see PROTOCOL.md). Never one giant entry covering the whole run — one subheading per reportable thing, and don't report anything that happened inside an active `do` session's own subtree (that session reports its own work). Keep titles short enough that Marc can skim the whole log collapsed and know what happened without opening anything. Each entry:
** [ ] [[<fuzzy heading or id: link to the one heading this is about>][<short title>]]
** TODO [[<fuzzy heading or id: link to the one heading this is about>][<short title>]]
[diwan YYYY-MM-DD] <one or two lines, no more>
Make the title itself the link — no `:LINK:` property, no properties drawer. Leave the title as plain text (no link) when there's no single heading the entry is about. Anything needing Marc's actual input or a reply (as opposed to a passive FYI) belongs as a normal unread entry in the relevant heading's own `:chat:`, not in the report — the report entry's title or body may link there, but don't try to hold a conversation in it.