feat: tell it when it's wrong, and see what it knows (#40)

Two things a person needs from a memory that learns on its own: a way to
see what it holds, and a way to correct it. Neither existed — the first
time memory kept a stale preference or a dropped project, the only
recourse was editing SurrealDB by hand.

**what-do-you-know** renders what memory actually holds, grouped by type,
with confidence — and surfaces the self-reinforcement tally where it is
non-zero, which is the "this may be me talking to myself" signal from the
provenance work. --about <topic> answers the same question on one subject.

**graph correct** records corrections as evidence rather than deletion. A
person saying "that's wrong" is the highest-authority signal the system
can receive, so it enters as contradiction at User provenance and the
posterior moves accordingly; before/after confidence and evidence weight
are both shown. --forget still deletes, but prints what will go and
requires confirmation, gated daemon-side so no client can skip it.

Subtle correctness point, caught during implementation: contradiction must
NOT touch last_reinforced. Reusing the reinforce path would have reset the
decay anchor, so telling the system a memory was wrong would have made it
MORE visible — an edge stored at 0.6 and decayed to 0.3 would return at
0.545. crud::contradict_relationship writes counts and mean while leaving
the anchor alone, so corrections are monotone. The extraction path has the
same latent wart; noted for a follow-up.

Ambiguity is refused rather than guessed: an entity with several live
edges lists them with confidence and exits without changing anything, and
an unknown name suggests the closest stored ones. Damaging the wrong
memory is worse than doing nothing.

MCP gains recall_overview (read-only) — an agent asking "what do I know"
is the same question. No correction tool, deliberately: a model calling it
would be recording its own judgement at the user's authority, which is the
loudest version of the failure provenance weighting exists to prevent.

Also: config show now prints [capture], [serve] and [extraction], which it
silently omitted.

728 tests, clippy -D warnings clean.

Author: dnacenta

README.md

@@ -41,12 +41,21 @@ On a LongMemEval subset it went from answering **0 of 9** questions correctly to
 When you *do* want to poke at it:
 
 ```bash
+recall-echo what-do-you-know            # everything it thinks it knows, and how sure it is
+recall-echo what-do-you-know --about D  # …on one subject
 recall-echo status                      # is it healthy, what has it got
 recall-echo search "deployment"         # grep your conversation history
 recall-echo graph query "auth flow"     # semantic search + related entities
 recall-echo graph traverse "recall-echo" # what's connected to what, with confidence
 ```
 
+And when it has something wrong — which it will — you tell it so:
+
+```bash
+recall-echo graph correct "D" "USES" "Vim" --wrong   # that claim is mistaken
+recall-echo graph correct "Vim" --forget             # that memory should not exist
+```
+
 And from inside your agent, once the MCP server is registered, it asks for itself:
 
 > **You:** why did we drop the websocket approach?
@@ -128,6 +137,11 @@ recall-echo graph search <query>                # Semantic search across entitie
 recall-echo graph query <query>                 # Hybrid: semantic + graph expansion + episodes
 recall-echo graph traverse <entity>             # Graph traversal from entity (shows confidence)
 
+# Reading and correcting it
+recall-echo what-do-you-know                    # What memory holds, and how sure it is
+recall-echo graph correct <from> <REL> <to> --wrong   # That claim is mistaken
+recall-echo graph correct <entity> --forget           # Remove it outright (asks first)
+
 # Data management
 recall-echo graph add-entity --name <n> --type <t> --abstract <a>   # Add entity manually
 recall-echo graph relate <from> --rel <type> --target <to>          # Create relationship
@@ -302,6 +316,20 @@ Knowledge graph operations. See the Architecture section above for the full comm
 - `graph ingest-all` — Scan conversations/ and ingest all un-ingested archives.
 - `graph extract` — LLM-powered entity extraction. Supports `--log <N>` (single archive), `--all` (all un-extracted), `--dry-run`, `--model`, `--provider` (any name from [LLM providers](#llm-providers)), `--delay-ms`. The daemon runs this pass on its own once the machine is quiet (see [Background extraction](#background-extraction)); this command is how you run it *now*, or in `server` mode, or after changing the model.
 
+**Correction:**
+
+- `graph correct <entity> --wrong` — Record that what memory claims about an entity is mistaken. Claims live on relationships, so this contradicts the entity's relationship — and if it has several, it lists them and asks which rather than guessing. `--all-edges` contradicts every one of them deliberately.
+- `graph correct <from> <REL> <to> --wrong` — Contradict one specific claim. Direction does not have to match how the graph stored it.
+- `graph correct <name> --forget` — Remove an entity and its relationships, or with a `<from> <REL> <to>` triple, one relationship. Prints what would go and asks before doing it; `--yes` skips the prompt, and a non-interactive stdin is never taken as consent.
+
+A correction is *evidence*, not an override. `--wrong` records one contradicting
+observation at your authority ([`weight_user`](#configuration), 0.8 by default) and
+lets the Beta posterior move: a claim resting on twenty independent
+observations survives one correction with reduced confidence, a claim resting
+on one collapses. Say it twice and it counts twice. `--forget` is the escape
+hatch for memory that should not exist at all — it leaves no trace and cannot
+be re-weighed, so prefer `--wrong`.
+
 **Daemon:**
 
 - `graph daemon status` — Socket path, pid, version and uptime of the daemon serving this graph.
@@ -315,6 +343,27 @@ Knowledge graph operations. See the Architecture section above for the full comm
 - `graph pipeline stale` — List stale pipeline entities. Supports `--days` (threshold, default 7).
 - `graph vigil-sync` — Sync vigil-pulse metacognitive signals and caliber outcomes into the graph as Measurement and Outcome entities. Supports `--signals-path` and `--outcomes-path`.
 
+### `recall-echo what-do-you-know`
+
+What memory actually holds, written for a person rather than a program.
+
+```bash
+recall-echo what-do-you-know                 # everything, grouped by entity type
+recall-echo what-do-you-know --about "rust"  # one subject, with its relationships
+recall-echo what-do-you-know --limit 5       # entities listed per type (default 3)
+```
+
+Without `--about` it lists the strongest entities of each type, then how firmly
+the relationships between them are held, then the two things a confidence
+number cannot tell you on its own: which relationships it is least sure of, and
+which ones it believes largely because it kept repeating them (`self×N` — the
+coherence tally, deliberately kept out of confidence). With `--about` it runs
+the ordinary hybrid query and renders each hit with the claims it takes part in
+and how sure it is of each.
+
+Everything it prints ends in the same place: if a line is wrong, `graph correct`
+is how you say so.
+
 ### `recall-echo serve`
 
 Runs the graph daemon for a memory directory. You never need to run this by
@@ -367,14 +416,15 @@ Or, equivalently, in a project's `.mcp.json`:
 `--entity-root` defaults to the current directory, so it can be omitted when
 the client is launched from the entity root.
 
-**Tools.** All five are read-only; none can write to the graph.
+**Tools.** All six are read-only; none can write to the graph.
 
 | Tool | Answers |
 | --- | --- |
 | `recall_query` | The default lookup: semantic search + one hop of graph expansion + the conversation fragments behind it |
 | `recall_search` | Semantic entity search alone — names, types, abstracts, retrieval scores |
 | `recall_episodes` | The raw conversation fragments, for what was actually said |
 | `recall_traverse` | Relationships out of one named entity, as a tree with edge confidence |
+| `recall_overview` | What memory holds without being asked for anything in particular — the content, and where it is unsure |
 | `recall_status` | Entity, relationship and episode counts — tells an empty memory from a failed lookup |
 
 Every tool runs through the same graph daemon as the CLI, so it inherits the
@@ -387,6 +437,11 @@ entities and edges directly would route around exactly that mechanism. Memory
 is written on the ingest path, where every episode is stamped with its
 authorship.
 
+**So is correction.** `graph correct` enters a contradiction at *user*
+authority, which is only true while a human is the one typing it — a model
+calling a correction tool would be recording its own judgement as yours.
+Corrections stay on the CLI.
+
 ## Archive Format
 
 Conversation archives use YAML frontmatter with markdown content:

src/config_cli.rs

@@ -62,6 +62,10 @@ pub fn show(memory_dir: &Path) -> Result<(), RecallError> {
         );
     }
 
+    show_capture_section(&cfg.capture);
+    show_extraction_section(&cfg.extraction);
+    show_serve_section(&cfg.serve);
+
     // Pipeline
     if let Some(ref pipeline) = cfg.pipeline {
         eprintln!("\n{BOLD}[pipeline]{RESET}");
@@ -78,6 +82,61 @@ pub fn show(memory_dir: &Path) -> Result<(), RecallError> {
     Ok(())
 }
 
+/// Which agent CLIs the daemon sweeps transcripts from.
+///
+/// Shown even at its defaults: "sessions are being imported from every CLI on
+/// this machine" is a thing a user debugging their setup needs to know, and it
+/// is invisible in a config file that never mentions it.
+fn show_capture_section(capture: &config::CaptureSection) {
+    eprintln!("\n{BOLD}[capture]{RESET}");
+    eprintln!("  enabled     = {}", capture.enabled);
+    let sources = match &capture.sources {
+        Some(sources) if !sources.is_empty() => sources
+            .iter()
+            .map(ToString::to_string)
+            .collect::<Vec<_>>()
+            .join(", "),
+        _ => "(every CLI with sessions on this machine)".to_string(),
+    };
+    eprintln!("  sources     = {sources}");
+    eprintln!(
+        "  settle_secs = {} {DIM}(a transcript must be this quiet to count as finished){RESET}",
+        capture.settle_secs
+    );
+}
+
+/// Background entity extraction inside the graph daemon.
+fn show_extraction_section(extraction: &config::ExtractionSection) {
+    eprintln!("\n{BOLD}[extraction]{RESET}");
+    eprintln!("  background_enabled = {}", extraction.background_enabled);
+    eprintln!(
+        "  idle_after_secs    = {} {DIM}(quiet period before a batch starts){RESET}",
+        extraction.idle_after_secs
+    );
+    eprintln!(
+        "  batch_size         = {} {DIM}(archives per batch){RESET}",
+        extraction.batch_size
+    );
+}
+
+/// Where the graph daemon listens and how long it lives.
+fn show_serve_section(serve: &config::ServeSection) {
+    eprintln!("\n{BOLD}[serve]{RESET}");
+    let socket = serve
+        .socket_path
+        .as_deref()
+        .filter(|path| !path.trim().is_empty());
+    match socket {
+        Some(path) => eprintln!("  socket_path       = {path}"),
+        None => eprintln!("  socket_path       = {DIM}(derived from the memory directory){RESET}"),
+    }
+    let idle = match serve.idle_timeout_secs {
+        0 => "0 (never idle-shuts-down)".to_string(),
+        secs => format!("{secs}"),
+    };
+    eprintln!("  idle_timeout_secs = {idle}");
+}
+
 /// Show the resolved agent-CLI call, so a misconfigured vendor is visible
 /// before it is spawned rather than after it fails.
 fn show_cli_section(llm: &config::LlmSection) {