Add launch infrastructure: landing page, quickstart, demo, changelog

- docs/index.html: Landing page for GitHub Pages (governed memory positioning)
- docs/quickstart.md: 5-minute zero-to-governed-memory guide
- docs/before-after.md: Concrete ungoverned vs governed comparison
- examples/governed_memory_demo.py: Runnable demo script (verified working)
- CHANGELOG.md: v0.1.0 and v0.2.0 release notes
- RELEASE_CHECKLIST.md: Pre-release verification steps
- tests/test_docs_truth.py: 7 smoke tests ensuring README matches code
- 66 tests passing

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Thezenmonster

CHANGELOG.md

@@ -0,0 +1,47 @@
+# Changelog
+
+All notable changes to agentmem will be documented in this file.
+
+## [0.2.0] - 2026-03-30
+
+### Added
+- **Truth governance engine** — memory lifecycle states: `hypothesis -> active -> validated -> deprecated -> superseded`
+- **Provenance tracking** — `source_path`, `source_section`, `source_hash` fields on every memory
+- **Conflict detection** — finds contradictions between active memories, separates duplicates from real contradictions, sentence-level negation matching
+- **Staleness detection** — flags memories by age, missing source files, or hash drift (source content changed)
+- **Health check** — scores memory system 0-100 based on conflicts, stale %, orphaned references, validated count
+- **Trust-ranked recall** — validated memories rank above active, which rank above hypothesis; provenance-weighted (canonical > unprovenanced)
+- **Lifecycle methods** — `promote()`, `deprecate()`, `supersede()` on Memory class
+- **Session governance** — `save_session()` now properly supersedes previous sessions
+- **MCP governance tools** — `promote_memory`, `deprecate_memory`, `supersede_memory`, `memory_health`, `memory_conflicts`
+- **CLI governance commands** — `health`, `conflicts`, `stale`, `promote`, `deprecate`
+- **28 governance tests** — lifecycle, conflicts, staleness, hashing, search trust ranking
+- Schema v2 migration (backward-compatible from v1)
+
+### Changed
+- Search no longer bumps `access_count` on returned candidates (fixes self-reinforcing popularity bias)
+- Deprecated and superseded memories excluded from search results entirely
+- Recall ranking reweighted: FTS 25%, trust status 20%, provenance 20%, recency 15%, frequency 10%, confidence 10%
+- README rewritten around "governed memory for long-lived coding agents"
+- Package description updated
+
+### Fixed
+- Resurrected sections: if a canonical section is removed (deprecated) then restored, sync reactivates it
+- Source priority: provenance-tracked canonical memories now rank above unprovenanced imports
+- Session lifecycle: old sessions properly superseded, no more orphaned chains
+
+## [0.1.0] - 2026-03-21
+
+### Added
+- Core Memory class with CRUD operations
+- FTS5 full-text search with porter stemming
+- Context-budgeted `recall()` with token limits
+- Seven memory types: setting, bug, decision, procedure, context, feedback, session
+- Project scoping (multiple agents, one DB)
+- Session persistence (`save_session`, `load_session`)
+- Markdown importer with frontmatter and type inference
+- CLI with full CRUD, search, recall, import, stats
+- MCP server with 8 tools
+- SQLite + WAL mode, thread-safe
+- 31 tests across core, search, and importer
+- Published to PyPI as `quilmem`

RELEASE_CHECKLIST.md

@@ -0,0 +1,44 @@
+# Release Checklist
+
+Run this before every release. Every item must pass.
+
+## Code Truth
+
+- [ ] `python -m pytest tests/ -v` — all tests pass
+- [ ] Every CLI command named in README exists in `cli.py`
+- [ ] Every MCP tool named in README exists in `mcp_server.py`
+- [ ] Every Python method named in README exists in `core.py`
+- [ ] README ranking weights match `search.py` actual weights
+- [ ] README memory statuses match `models.py` MEMORY_STATUSES
+- [ ] README feature claims match implemented behavior (no aspirational claims)
+
+## Package
+
+- [ ] Version bumped in `pyproject.toml` and `__init__.py`
+- [ ] CHANGELOG.md updated with all changes
+- [ ] `python -m build` succeeds
+- [ ] Clean install test: `pip install dist/*.whl` in fresh venv, run demo
+
+## Smoke Tests
+
+- [ ] `agentmem add --type bug --title "test" "content"` works
+- [ ] `agentmem search "test"` returns the added memory
+- [ ] `agentmem health` runs without error
+- [ ] `agentmem conflicts` runs without error
+- [ ] `agentmem stale --days 1` runs without error
+- [ ] `agentmem promote <id>` works
+- [ ] `agentmem deprecate <id>` works
+- [ ] `python examples/governed_memory_demo.py` runs clean
+
+## MCP Smoke Test
+
+- [ ] `agentmem serve` starts without error (Ctrl+C to exit)
+- [ ] If MCP client available: `add_memory`, `search_memory`, `memory_health` work
+
+## Publish
+
+- [ ] `python -m twine upload dist/*` to PyPI
+- [ ] `git tag v{VERSION}`
+- [ ] `git push origin main --tags`
+- [ ] GitHub release created with notes from CHANGELOG
+- [ ] Verify `pip install quilmem=={VERSION}` pulls the new version

docs/before-after.md

@@ -0,0 +1,124 @@
+# Before/After: Why Governed Memory Matters
+
+A concrete example of what goes wrong without governance, and how agentmem fixes it.
+
+## The Scenario
+
+You're building a web app. Over 3 weeks, your AI assistant accumulates memories about your audio processing pipeline. Some are current. Some are outdated. Some contradict each other.
+
+## Before: Ungoverned Memory
+
+Your agent stores everything it learns. No status, no provenance, no lifecycle.
+
+```python
+from agentmem import Memory
+
+mem = Memory("./ungoverned.db")
+
+# Week 1: You discover a bug
+mem.add(type="bug", title="loudnorm breaks voice quality",
+        content="loudnorm on voice files lifts the noise floor. Audio sounds robotic.")
+
+# Week 1: You set a rule
+mem.add(type="decision", title="Audio normalization policy",
+        content="Always apply loudnorm to voice audio before mixing.")
+
+# Week 3: You fix the approach
+mem.add(type="decision", title="Updated audio policy",
+        content="Never apply loudnorm to voice audio. Use per-track volume instead.")
+```
+
+**What happens when the agent recalls "how to process audio"?**
+
+```python
+context = mem.recall("audio processing voice normalization", max_tokens=2000)
+```
+
+The agent gets back ALL THREE memories. The week 1 rule says "always apply loudnorm." The week 3 rule says "never apply loudnorm." The agent picks one at random — or worse, tries to follow both.
+
+**Your agent just repeated a bug you already fixed.**
+
+## After: Governed Memory
+
+Same scenario, but with lifecycle management.
+
+```python
+from agentmem import Memory
+
+mem = Memory("./governed.db")
+
+# Week 1: Store the bug
+bug = mem.add(type="bug", title="loudnorm breaks voice quality",
+              content="loudnorm on voice files lifts the noise floor.",
+              status="active")
+
+# Week 1: Set a rule (later proven wrong)
+old_rule = mem.add(type="decision", title="Audio normalization policy",
+                   content="Always apply loudnorm to voice audio before mixing.",
+                   status="active")
+
+# Week 3: You learn the right approach
+new_rule = mem.add(type="decision", title="Audio normalization policy v2",
+                   content="Never apply loudnorm to voice audio. Use per-track volume.",
+                   status="validated")
+
+# Supersede the old rule — it now points to the replacement
+mem.supersede(old_rule.id, new_rule.id)
+
+# Promote the bug to validated (confirmed real)
+mem.promote(bug.id)
+```
+
+**Now when the agent recalls "how to process audio":**
+
+```python
+context = mem.recall("audio processing voice normalization", max_tokens=2000)
+```
+
+It gets:
+1. The **validated** new rule (highest trust, ranked first)
+2. The **validated** bug report (confirmed real)
+3. The old rule is **superseded** — excluded from results entirely
+
+**No contradiction. No confusion. The agent only sees current truth.**
+
+## Check the Difference
+
+```bash
+# See the health of your governed memory
+agentmem --db ./governed.db health
+# Memory Health: 90/100
+# Total: 3
+# By status: validated: 2, superseded: 1
+# Conflicts: 0
+
+# Compare with the ungoverned version
+agentmem --db ./ungoverned.db health
+# Memory Health: 60/100
+# Total: 3
+# By status: active: 3
+# Conflicts: 1
+#   !! "Audio normalization policy" vs "Updated audio policy"
+#      Contradiction on shared topic (audio, loudnorm, voice)
+```
+
+## The Pattern
+
+| Without governance | With governance |
+|---|---|
+| Old and new rules both active | Old rule superseded, points to replacement |
+| Agent picks randomly between contradictions | Agent only sees validated truth |
+| Stale rules accumulate silently | Staleness detection flags outdated memories |
+| No way to audit what the agent "knows" | Health check scores system 0-100 |
+| Flat confidence: all memories equal | Trust ranking: validated > active > hypothesis |
+
+## Real-World Impact
+
+This isn't theoretical. agentmem was built during 2+ months of daily production work:
+
+- **65+ YouTube videos** produced with zero repeated production bugs
+- **330+ memories** governing voice generation, video assembly, image prompting
+- **7 real contradictions** detected and resolved by the governance engine
+- **104 stale duplicates** identified and superseded in one migration
+
+Every bug was caught once, fixed once, and never repeated — because the memory system knows what's current and what's not.