Self-improving "work memory": capture session outcomes/corrections + a `reflect` pass on top of the graph

[safishamsi]

Summary

Explore a self-improving "work memory" layer on top of graphify's knowledge graph — inspired by #1401 and Perplexity's "Brain" (a context graph of the agent's work that, on a schedule, reviews itself and "learns to do the work better": remembering what worked/failed, what corrections were made, and which sources were dead ends).

The interesting part: graphify already ships most of the substrate this needs. This issue proposes a concrete, scoped first slice so a contributor can pick it up. PR / design input welcome.

What graphify already has (the substrate)

Capability	Today in graphify
Context graph	the knowledge graph
Auto-loadable LLM wiki	graphify export wiki → wiki/index.md + per-community/per-node pages (the skill already tells agents to navigate it)
Provenance / "show your work"	every node & edge carries source_file / source_location
Incremental refresh	graphify update, watch, git hooks
Usage feedback loop	save_query_result / graphify save-result → graphify-out/memory/ re-ingested into the graph on the next build (graphify/ingest.py)

The gap (what "self-improving memory" adds)

1. Memory of the work, not just the corpus. graphify graphs your code/docs; this would also capture sessions, outcomes, and corrections — "this query/answer was useful," "this source was a dead end," "the user corrected X."
2. A scheduled reflection pass. A graphify reflect-style step (cron/overnight) that reviews the accumulated work-memory + graph and synthesizes durable lessons back into the wiki/graph — the actual "self-improving" piece.
3. A corrections/mistakes loop — reweight or prune memory from dead ends and corrections so future retrieval improves.

Layer split (why this is mostly thin glue + one new step)

graphify is the memory substrate (graph + wiki + provenance + feedback ingestion); the autonomous loop is largely agent orchestration on top. Much is feasible with today's primitives:

• Feasible now: record session outcomes/corrections as memory docs (extend save-result with an outcome/correction field), then cron a graphify update to fold them in.
• The novel piece worth building: a graphify reflect step that reads the work-memory + graph and writes a synthesized "lessons / preferred sources / known-dead-ends" wiki page the agent loads next session.

Proposed first slice (scoped for a PR)

• Extend save_query_result / save-result to record an optional outcome signal (useful / dead_end / corrected, plus the correction text) in the memory doc's frontmatter.
• Add a minimal graphify reflect command that scans graphify-out/memory/, aggregates outcomes by topic/community, and writes a wiki/_LESSONS.md (or a reflections/ doc) summarizing "what worked / preferred sources / dead ends" — deterministic first (no LLM), LLM-synthesis optional behind a backend flag.
• Tests + a worked example showing a second session benefiting from the first.

Out of scope (for the first slice)

• Fully autonomous overnight scheduling (leave to the user's cron / the agent host).
• Per-user preference memory (this is work memory, per the Brain framing).

Acceptance criteria

• save-result can persist an outcome/correction; it round-trips into the graph.
• graphify reflect produces a deterministic lessons artifact the agent can load.
• No change to existing default behavior; full suite + skillgen-check green.

---

Filed from the discussion in #1401. This is exploratory — happy to refine scope with whoever picks it up.

[safishamsi]

Shipped to v8 (ships next release). The first deterministic slice from this issue is in, plus hardening:

• graphify save-result --outcome useful|dead_end|corrected [--correction TEXT] records how a saved Q&A turned out (frontmatter + an ## Outcome body section, so it round-trips into the graph too).
• graphify reflect aggregates graphify-out/memory/ into a deterministic reflections/LESSONS.md: preferred sources, tentative, known dead ends, corrections, grouped by community.
• Scoring is signed and recency-decayed (--half-life-days, default 30), corroboration-gated (--min-corroboration, default 2), with a contested bucket for mixed signals. Citations whose node no longer exists in the graph are dropped, and repeated questions no longer duplicate dead-end/correction lines.
• Zero-config adoption: the skill tells the agent to run graphify reflect --if-stale and read LESSONS.md at the start of graph work, and the git hooks auto-refresh it after each rebuild. --if-stale skips when nothing changed.

Acceptance criteria from this issue are met (outcome persists and round-trips; reflect produces a deterministic artifact; existing default behavior unchanged; full suite + skillgen-check green).

The larger follow-ons mentioned as out of scope here (LLM-synthesized lessons, decoupling 'judge' from 'save', relevance-ranked retrieval, a persistent upvote/downvote ledger) remain for a v2. Closing this as the first slice is done.