lorekeep 0.4.0__tar.gz → 0.6.0__tar.gz

lorekeep-0.6.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.6.0"
+}

{lorekeep-0.4.0 → lorekeep-0.6.0}/AGENTS.md

@@ -25,12 +25,13 @@ uv run lorekeep <command>                    # run the CLI in dev mode
 | Command | Purpose |
 |---|---|
 | `init` | Bootstrap data home (config + schema + raw/graph dirs) |
-| `compile` | `raw/*.md` → `graph/facts.jsonl` + `manifest.json` (runs the LLM pipeline) |
+| `compile` | `raw/*.md` → `graph/facts.jsonl` + `manifest.json` + `wiki/` (runs the LLM pipeline, auto-generates wiki) |
 | `check` | Validate compiled graph loads, no dangling edges (exit 1 on failure) |
 | `eval` | Tier-1 construction P/R/F1 vs gold corpus + structure metrics |
+| `wiki` | Regenerate `wiki/` from `facts.jsonl` (Obsidian-compatible markdown) |
 | `serve [--transport stdio\|http]` | Run the MCP server (8 read + 5 write tools) |
 | `mcp add --agent claude\|cursor\|codex\|opencode --ns NS` | Write agent MCP config |
-| `import --from claude\|cursor` | Import agent sessions into `raw/` (claude: quick+deep; cursor: deep-only) |
+| `import --from claude\|cursor\|codex\|opencode` | Import agent sessions into `raw/` |
 | `doctor` | Verify install: graph loads, schema valid, a tool responds |
 | `backup [--init <remote-url>]` | Commit + push `.lorekeep/` to your private backup git repo |
 | `version` | Print version |
@@ -40,11 +41,11 @@ uv run lorekeep <command>                    # run the CLI in dev mode
 ## Architecture: two strictly separated phases
 
 ```
-COMPILE (offline, curator):  raw/<ns>/*.md → ingest → extract(LLM) → resolve → writer → facts.jsonl
+COMPILE (offline, curator):  raw/<ns>/*.md → ingest → extract(LLM) → resolve → writer → facts.jsonl → wiki/
 SERVE   (runtime, per device): facts.jsonl → GraphStore → ScopedGraph(ns) → MCP → agent
 ```
 
-`compile` mutates `facts.jsonl`; `serve` reads it and lazily reloads on mtime change. Write tools (propose_fact, link_facts, etc.) append to `pending/` journals; resolve merges them into the graph.
+`compile` mutates `facts.jsonl` and auto-generates `wiki/`; `resolve` regenerates wiki only on actual merge (gated on `merge_count > 0`); `serve` reads `facts.jsonl` and lazily reloads on mtime change. Write tools (propose_fact, link_facts, etc.) append to `pending/` journals; resolve merges them into the graph. Wiki regen is **best-effort** — never blocks `compile` or `resolve`. Wiki builds into a temp dir then `os.rename` swaps into place (atomic — never partially populated).
 
 ### Compile pipeline (`src/lorekeep/compile/`, orchestrated by `pipeline.py`)
 `ingest` chunks markdown with `path:line` provenance → `extract` calls the LLM provider for schema-constrained nodes/edges/aliases (per-chunk SHA-256 hash cache → unchanged chunks return cached output, giving byte-stable recompiles) → `resolve` collapses alias variants to canonical entities and quarantines invalid facts → `writer` emits **sorted** `facts.jsonl` + `manifest.json`. Failures are skip-and-log (partial compile is valid); errors/quarantine land in the manifest.
@@ -59,8 +60,11 @@ Pydantic, all `frozen=True`, `extra="forbid"`. `Node` / `Edge` are the two `kind
 ### Serve (`mcp_server.py`)
 `FastMCP` with 8 read tools (`search`, `get_node`, `neighbors`, `at_time`, `history`, `changes`, `list_namespaces`, `schema`) and 5 write tools (`propose_fact`, `link_facts`, `flag_contradiction`, `update_fact`, `suggest_improvement`). Module-global `ScopedGraph` is set by `configure()`; `_require()` lazy-reloads when `facts.jsonl` mtime changes (so `compile` is visible without reconnecting). Tools are plain functions registered with `@mcp.tool()` but stay directly callable — **tests invoke them directly, no MCP transport**. The writer uses atomic `os.replace` so lazy-reload never reads a half-written file.
 
+### Wiki (`wiki.py`)
+Pure JSONL → markdown transform (no LLM). `generate_wiki(graph_dir, wiki_dir)` reads `facts.jsonl` via `GraphStore` → entity pages (`entities/<type>/<slug>.md` with YAML frontmatter, wikilinks, props table), `index.md` (catalog), `overview.md` (stats dashboard), `log.md` (append-only, preserved across regen). Builds into `.wiki-build.tmp` then `os.rename` swaps into place (atomic). `_slug()` replaces `:`/`/` with `-`; collisions raise `ValueError`. YAML scalars quoted via `json.dumps` so IDs like `svc:payments-api` parse correctly. Props table escapes `\|`, collapses newlines, serializes non-strings. Regenerates on every `facts.jsonl` mutation: `compile` (single regen — `_do_auto_resolve` returns bool, compile skips if resolve already regend), `resolve` (gated on merge/flag), daemon auto-resolve (on actual merge). Best-effort — never blocks compile or resolve.
+
 ### Path resolution (`paths.py`)
-Pure (no I/O), 4-tier precedence high→low: explicit `LOREKEEP_RAW/OUT/CACHE/SCHEMA/CONFIG` env → `LOREKEEP_HOME` → **dev mode** (`.lorekeep/` present in CWD, or `LOREKEEP_DEV=1`; auto-detected in a source checkout) — all data lives under `cwd/.lorekeep/` (`config.yaml`, `schema.json`, `raw/`, `graph/`, `cache.json`), mirroring the `LOREKEEP_HOME` layout → XDG (`platformdirs`). Running `uv run lorekeep …` from the repo uses the repo's own `.lorekeep/` data home with zero migration.
+Pure (no I/O), 4-tier precedence high→low: explicit `LOREKEEP_RAW/OUT/CACHE/SCHEMA/CONFIG/WIKI` env → `LOREKEEP_HOME` → **dev mode** (`.lorekeep/` present in CWD, or `LOREKEEP_DEV=1`; auto-detected in a source checkout) — all data lives under `cwd/.lorekeep/` (`config.yaml`, `schema.json`, `raw/`, `graph/`, `wiki/`, `pending/`, `cache.json`), mirroring the `LOREKEEP_HOME` layout → XDG (`platformdirs`). Running `uv run lorekeep …` from the repo uses the repo's own `.lorekeep/` data home with zero migration.
 
 ### Provider pluggability (`compile/providers.py`)
 `LiteLLMProvider` (OpenAI / Anthropic / DashScope/Qwen / Ollama via litellm model strings) and `FakeProvider` (tests/offline). Model is set in `config.yaml` as a litellm string.
@@ -79,11 +83,11 @@ Pure (no I/O), 4-tier precedence high→low: explicit `LOREKEEP_RAW/OUT/CACHE/SC
 - **Conventional Commits are enforced** — a `commit-msg` pre-commit hook (`scripts/check-conventional-commit.py`) plus CI (`lint-commits.yml`, checking both commit messages and PR title). Types: `build|chore|ci|docs|feat|fix|perf|refactor|revert|style|test`. Merge commits are exempt.
 - **Releases are automated** — `release-please` runs on every push to `main` (`feat`=minor, `fix`=patch, `!`=major), opens an auto-merging Release PR, tags a GitHub Release on merge, and publishes to PyPI via OIDC trusted publishing (inline publish job). Do not version-bump by hand.
 - **Determinism is a hard requirement** — recompiling unchanged input must be byte-identical (kept green by `test_determinism.py`). Preserve the sorted-output / cache behavior in `writer.py` and `extract.py` when changing the pipeline.
-- **`graph/facts.jsonl` and `graph/manifest.json` are gitignored** (regenerated by `compile`); `.lorekeep/schema.json` is committed.
+- **`graph/facts.jsonl`, `graph/manifest.json`, and `wiki/` are gitignored** (regenerated by `compile`); `.lorekeep/schema.json` is committed.
 
 ## Tests
 
-`~140` tests, no network. Gold corpus in `tests/fixtures/gold/`, raw fixtures in `tests/fixtures/raw/`. Compile/serve/import tests inject `FakeProvider` via `patch_make_provider` / `patch_make_import_provider` conftest fixtures to pin paths and avoid the LLM — follow this pattern for any new CLI test rather than hitting a real provider.
+`~300` tests, no network. Gold corpus in `tests/fixtures/gold/`, raw fixtures in `tests/fixtures/raw/`. Compile/serve/import tests inject `FakeProvider` via `patch_make_provider` / `patch_make_import_provider` conftest fixtures to pin paths and avoid the LLM — follow this pattern for any new CLI test rather than hitting a real provider.
 
 ## Cursor Cloud specific instructions
 

{lorekeep-0.4.0 → lorekeep-0.6.0}/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.6.0](https://github.com/manhhailua/lorekeep/compare/v0.5.0...v0.6.0) (2026-06-29)
+
+
+### Features
+
+* add Obsidian-compatible wiki output from compiled graph ([#68](https://github.com/manhhailua/lorekeep/issues/68)) ([e3e53f2](https://github.com/manhhailua/lorekeep/commit/e3e53f26f8f97c947bafe4a19485410f4deb14f6))
+
+## [0.5.0](https://github.com/manhhailua/lorekeep/compare/v0.4.0...v0.5.0) (2026-06-28)
+
+
+### Features
+
+* add import --from codex and --from opencode + hooks for all 4 agents ([#66](https://github.com/manhhailua/lorekeep/issues/66)) ([8a1e364](https://github.com/manhhailua/lorekeep/commit/8a1e364e19cf1b45944cea2ed89d9d7468fec9c6))
+
 ## [0.4.0](https://github.com/manhhailua/lorekeep/compare/v0.3.1...v0.4.0) (2026-06-28)
 
 

{lorekeep-0.4.0 → lorekeep-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lorekeep
-Version: 0.4.0
+Version: 0.6.0
 Summary: Temporal knowledge graph for AI agents via MCP
 Project-URL: Homepage, https://github.com/manhhailua/lorekeep
 Project-URL: Repository, https://github.com/manhhailua/lorekeep
@@ -269,7 +269,8 @@ src/lorekeep/
   store/{graph,fts}.py                          GraphStore + optional FTS cache
   perm/ns.py                                    ScopedGraph permission chokepoint
   mcp_server.py                                 FastMCP + 8 read + 5 write tools
-  integrations/{claude_code,cursor,codex,common}.py
+  wiki.py                                        Obsidian-compatible wiki generator
+  integrations/{claude_code,cursor,codex,opencode,common}.py
   pipeline.py, cli.py
   eval/{gold,construction,retrieval}.py
 tests/                 ~140 tests
@@ -278,9 +279,9 @@ docs/                  README.md index, architecture/, guides/
 
 ## Status
 
-**v1 (implemented)** — compile pipeline + serve (store/permission/MCP read/integrations) + import + agent daemon (watch/ingest/lint/suggest/status) + journal + resolve + data-home + dev mode + lazy-reload + backup + eval. Published to PyPI as `lorekeep`.
+**v1 (implemented)** — compile pipeline + serve (store/permission/MCP read+write/4-agent integrations) + import (Claude/Cursor/Codex/opencode) + session-end hooks + agent daemon (watch/ingest/lint/suggest/status) + journal + resolve + data-home + dev mode + lazy-reload + backup + eval + **wiki** (Obsidian-compatible markdown output). Published to PyPI as `lorekeep`.
 
-**Phase 2 (planned)** — `wiki.md` views (Obsidian-compatible markdown output), streamable-HTTP team server, OIDC/SSO, embeddings/hybrid search, scheduled nightly lint/suggest in daemon, schema evolve, full Tier-2 benchmark datasets (HotpotQA/CronQuestions) and the bespoke Tier-3 Lorekeep-Reason eval.
+**Phase 2 (planned)** — streamable-HTTP team server, OIDC/SSO, embeddings/hybrid search, scheduled nightly lint/suggest in daemon, schema evolve, full Tier-2 benchmark datasets (HotpotQA/CronQuestions) and the bespoke Tier-3 Lorekeep-Reason eval.
 
 ## Documentation
 
@@ -291,6 +292,7 @@ The [`docs/`](docs/README.md) index is the entry point.
 - [Importing agent sessions](docs/guides/import.md)
 - [Compiling the knowledge graph](docs/guides/compile.md)
 - [Serving the graph to coding agents](docs/guides/serve.md)
+- [Browsing the wiki](docs/guides/wiki.md)
 - [Data home & path resolution](docs/guides/data-home.md)
 - [Backing up the data home](docs/guides/backup.md)
 

{lorekeep-0.4.0 → lorekeep-0.6.0}/README.md

@@ -247,7 +247,8 @@ src/lorekeep/
   store/{graph,fts}.py                          GraphStore + optional FTS cache
   perm/ns.py                                    ScopedGraph permission chokepoint
   mcp_server.py                                 FastMCP + 8 read + 5 write tools
-  integrations/{claude_code,cursor,codex,common}.py
+  wiki.py                                        Obsidian-compatible wiki generator
+  integrations/{claude_code,cursor,codex,opencode,common}.py
   pipeline.py, cli.py
   eval/{gold,construction,retrieval}.py
 tests/                 ~140 tests
@@ -256,9 +257,9 @@ docs/                  README.md index, architecture/, guides/
 
 ## Status
 
-**v1 (implemented)** — compile pipeline + serve (store/permission/MCP read/integrations) + import + agent daemon (watch/ingest/lint/suggest/status) + journal + resolve + data-home + dev mode + lazy-reload + backup + eval. Published to PyPI as `lorekeep`.
+**v1 (implemented)** — compile pipeline + serve (store/permission/MCP read+write/4-agent integrations) + import (Claude/Cursor/Codex/opencode) + session-end hooks + agent daemon (watch/ingest/lint/suggest/status) + journal + resolve + data-home + dev mode + lazy-reload + backup + eval + **wiki** (Obsidian-compatible markdown output). Published to PyPI as `lorekeep`.
 
-**Phase 2 (planned)** — `wiki.md` views (Obsidian-compatible markdown output), streamable-HTTP team server, OIDC/SSO, embeddings/hybrid search, scheduled nightly lint/suggest in daemon, schema evolve, full Tier-2 benchmark datasets (HotpotQA/CronQuestions) and the bespoke Tier-3 Lorekeep-Reason eval.
+**Phase 2 (planned)** — streamable-HTTP team server, OIDC/SSO, embeddings/hybrid search, scheduled nightly lint/suggest in daemon, schema evolve, full Tier-2 benchmark datasets (HotpotQA/CronQuestions) and the bespoke Tier-3 Lorekeep-Reason eval.
 
 ## Documentation
 
@@ -269,6 +270,7 @@ The [`docs/`](docs/README.md) index is the entry point.
 - [Importing agent sessions](docs/guides/import.md)
 - [Compiling the knowledge graph](docs/guides/compile.md)
 - [Serving the graph to coding agents](docs/guides/serve.md)
+- [Browsing the wiki](docs/guides/wiki.md)
 - [Data home & path resolution](docs/guides/data-home.md)
 - [Backing up the data home](docs/guides/backup.md)
 

{lorekeep-0.4.0 → lorekeep-0.6.0}/docs/README.md

@@ -24,8 +24,9 @@ Concepts and design — how the system fits together.
 How to use it.
 
 - [**Getting started**](guides/getting-started.md) — install → compile → serve → backup in 10 minutes. Start here.
-- [Importing agent sessions](guides/import.md) — Claude Code + Cursor → `raw/`.
+- [Importing agent sessions](guides/import.md) — Claude Code + Cursor + Codex + opencode → `raw/`.
 - [Compiling the knowledge graph](guides/compile.md) — `raw/*.md` → `facts.jsonl` + resolve pending.
-- [Serving the graph to coding agents](guides/serve.md) — wire Claude Code / Cursor / Codex over MCP, write tools, daemon.
+- [Serving the graph to coding agents](guides/serve.md) — wire Claude Code / Cursor / Codex / opencode over MCP, write tools, daemon.
+- [Browsing the wiki](guides/wiki.md) — human-readable Obsidian-compatible markdown view of the graph.
 - [Data home & path resolution](guides/data-home.md) — env / `LOREKEEP_HOME` / dev mode / XDG.
 - [Backing up the data home](guides/backup.md) — `lorekeep backup` to a private git repo: setup, restore, multi-device conflicts.

{lorekeep-0.4.0 → lorekeep-0.6.0}/docs/architecture/overview.md

@@ -46,6 +46,10 @@ Lorekeep exists to let an agent reason about a domain **systematically and with
                     │
                     ▼
               facts.jsonl                       THE store (sorted, byte-stable)
+                    │
+                    ├──► wiki/*.md               human view (Obsidian-compatible)
+                    │     atomic swap, regen on
+                    │     every facts mutation
                     │
                     ▼  (git / S3 sync)
     ┌───────────────────────────────────────────┐

{lorekeep-0.4.0 → lorekeep-0.6.0}/docs/guides/compile.md

@@ -35,12 +35,17 @@ provider:
 uv run lorekeep compile
 ```
 
-Produces `graph/facts.jsonl` + `graph/manifest.json`. Re-running is idempotent:
-unchanged input yields a byte-identical file (extraction is cached under
-`.lorekeep/cache.json`).
+Produces `graph/facts.jsonl` + `graph/manifest.json` + auto-generates `wiki/`
+(Obsidian-compatible markdown, regenerated atomically). If `pending/`
+journals exist, compile also merges them via `_do_auto_resolve` — in that
+case wiki regenerates once from the resolved facts (never double).
+Re-running is idempotent: unchanged input yields byte-identical files
+(extraction is cached under `.lorekeep/cache.json`).
 
 **What compile does not do:** compile processes only `raw/`. Agent-proposed
 facts in `pending/` journals are merged by `resolve` (see step 5).
+Compile does re-merge pending journals as a convenience, but standalone
+`resolve` is needed if you add journals after compile.
 
 ## 4. Resolve pending facts (manual)
 
@@ -50,7 +55,8 @@ uv run lorekeep resolve
 
 Merges all pending agent-proposed facts from `pending/` journals into `facts.jsonl`.
 Facts are gated by confidence: high (≥0.8) auto-merge, medium (0.5-0.8) merge
-with review flag, low (<0.5) quarantine.
+with review flag, low (<0.5) quarantine. Wiki regenerates only if facts
+actually changed (`merge_count > 0` or `flagged_count > 0`).
 
 Resolve also runs automatically: the daemon (`lorekeep agent watch`) detects
 new pending entries on every poll cycle (default 60s interval).
@@ -95,7 +101,8 @@ the next resolve.
 
 ## Next: serve to agents
 
-See [serve.md](serve.md) to expose the graph to Claude Code / Cursor / Codex over MCP.
+See [serve.md](serve.md) to expose the graph to Claude Code / Cursor / Codex over MCP,
+or [wiki.md](wiki.md) to browse the graph as Obsidian markdown.
 
 ## Data home
 

{lorekeep-0.4.0 → lorekeep-0.6.0}/docs/guides/serve.md

@@ -101,13 +101,20 @@ rebuilt automatically. So the workflow is:
 
 ```bash
 <edit raw/.../*.md>
-uvx lorekeep compile          # rebuilds facts.jsonl
+uvx lorekeep compile          # rebuilds facts.jsonl + regenerates wiki/
 # OR: agent ingest + resolve  # propose facts interactively, merge journals
 # OR: lorekeep agent watch    # daemon does compile + resolve automatically
 # next query from the agent sees the new graph — NO reconnect needed
+# wiki/ pages also regenerated automatically
 ```
 
 Connect the MCP server **once**; graph updates via `compile`, `resolve`, or
 the daemon are visible immediately. Reconnect is only needed for **code**
 changes (rare; the serve path is stable) or **scope** changes (`.mcp.json`
 `LOREKEEP_NS`).
+
+## Human view: wiki
+
+The same `facts.jsonl` is also projected to **Obsidian-compatible markdown**
+in `wiki/` — one page per node, `[[wikilinks]]` for edges, YAML frontmatter
+for Dataview. See [wiki.md](wiki.md).

lorekeep-0.6.0/docs/guides/wiki.md

@@ -0,0 +1,179 @@
+# Browsing the wiki (human view)
+
+The compiled graph (`facts.jsonl`) is machine-readable — consumed by agents over MCP. The **wiki** is its human-readable projection: Obsidian-compatible markdown pages with wikilinks, YAML frontmatter, and graph view.
+
+## Quick start
+
+```bash
+uvx lorekeep compile      # auto-generates wiki/ after compile
+# OR
+uvx lorekeep wiki         # regenerate wiki/ from existing facts.jsonl
+```
+
+Open the `wiki/` directory in Obsidian:
+
+```bash
+# In your data home (default XDG):
+open ~/.local/share/lorekeep/wiki
+
+# Or dev mode (repo co-located):
+open .lorekeep/wiki
+```
+
+In Obsidian: **File → Open vault** → select the `wiki/` directory.
+
+## Lifecycle
+
+The wiki is a **derived artifact** — fully regenerable from `facts.jsonl`, never the reverse:
+
+```
+raw/*.md → compile → facts.jsonl → wiki/*.md
+                          ↑                ↓
+                     agent queries     human browses
+                     (MCP tools)      (Obsidian)
+```
+
+| Consumer | Reads | Format |
+|---|---|---|
+| Agent (MCP) | `facts.jsonl` | JSONL — structured queries, temporal, ns-scoped |
+| Human (Obsidian) | `wiki/` | Markdown — browsable, searchable, graph view |
+
+### When wiki regenerates
+
+Wiki regenerates on **every `facts.jsonl` mutation**:
+
+| Trigger | Who | Wiki regen? |
+|---|---|---|
+| `compile` (raw → facts.jsonl) | Curator | Yes — single regen at end |
+| `compile` + pending resolve | Curator | Yes — `_do_auto_resolve` regens if merge happened; otherwise compile's own regen covers it. **Never double.** |
+| `resolve` (manual, merge happened) | Curator | Yes — gated on `merge_count > 0` or `flagged_count > 0` |
+| `resolve` (quarantine-only, no merge) | Curator | No — facts.jsonl unchanged |
+| Daemon auto-resolve (merge) | Daemon | Yes — `_do_auto_resolve` regens on actual merge |
+| `lorekeep wiki` (manual) | Human | Yes — force regen |
+
+### Atomic swap
+
+Wiki pages build into a temp sibling directory (`.wiki-build.tmp`), then `os.rename` swaps it into place. The wiki directory is **never partially populated** — Obsidian always sees either the old or the new version, never a mix. This is safe even with the vault open during regeneration.
+
+## Output structure
+
+```
+wiki/
+├── index.md                     # catalog of all entities, grouped by type
+├── log.md                       # append-only generation log
+├── overview.md                  # graph stats dashboard
+└── entities/
+    └── <type>/
+        └── <slug>.md            # one page per node
+```
+
+### Entity pages
+
+Each node becomes a markdown page with:
+
+- **YAML frontmatter** — `id`, `type`, `ns`, `valid_from`, `valid_to`, `sources`, `tags` (Obsidian Dataview compatible). All scalars are quoted so IDs containing colons (`svc:payments-api`) parse correctly.
+
+Example entity page (`entities/service/svc-payments-api.md`):
+
+```markdown
+---
+id: "svc:payments-api"
+type: "service"
+ns: ["backend"]
+valid_from: "2024-01-15"
+valid_to: ""
+sources:
+  - "raw/backend/payments.md:3"
+tags: ["service", "backend", "entity"]
+---
+
+# payments-api
+
+> ID: `svc:payments-api`
+
+## Properties
+
+| Key | Value |
+|---|---|
+| name | payments-api |
+| lang | go |
+
+## Relationships
+
+### depends_on →
+
+- [[svc-auth]] (2024-01-15 → 2025-03-01)
+
+## Timeline
+
+- **2024-01-15**: Valid from
+```
+
+### Properties table
+
+Pipe characters in values are escaped (`\|`), newlines collapsed to spaces, and non-string values (integers, booleans, lists) serialized via `json.dumps` — preventing table corruption.
+
+### Slug naming
+
+Node IDs are sanitized to filename-safe slugs for wikilinks (`:` → `-`, `/` → `-`). If two distinct node IDs collide to the same slug, `generate_wiki` raises `ValueError` rather than silently overwriting.
+
+### index.md
+
+Catalog of all entities, grouped by node type (`## Services`, `## Teams`, `## Decisions`). Each entry is a `[[wikilink]]` with a one-line summary.
+
+### overview.md
+
+Graph-level dashboard: node/edge counts by type, temporal range, namespace breakdown, and compile metadata (run ID, facts hash).
+
+### log.md
+
+Append-only log of wiki generation events. **Preserved across regenerations** — prior entries survive verbatim. Counts come from the live `GraphStore`, not the (potentially stale) manifest:
+
+```
+## [2026-06-29T21:53:00Z] wiki | run_id=abc123, 4 nodes, 2 edges
+```
+
+## Obsidian tips
+
+- **Graph view** — all `[[wikilinks]]` render as a force-directed graph. This is the entity-relationship graph visualized.
+- **Backlinks** — Obsidian automatically shows inbound references at the bottom of each page (equivalent to incoming edges).
+- **Dataview** — the YAML frontmatter enables structured queries. Example: list all services written in Go:
+  ```dataview
+  LIST FROM #service WHERE lang = "go"
+  ```
+- **Tags** — each page is tagged with `[<type>, <ns>, "entity"]`, enabling filtered views.
+
+## CLI
+
+```bash
+lorekeep wiki          # regenerate wiki/ from facts.jsonl (force)
+```
+
+Wiki generation also runs automatically after every `facts.jsonl` mutation:
+
+- **`compile`** — always regens (unless `_do_auto_resolve` already regend after merging pending journals; never double).
+- **`resolve`** — regens only if facts actually changed (`merge_count > 0` or `flagged_count > 0`). Quarantine-only resolves skip wiki regen.
+- **Daemon auto-resolve** — regens on actual merge (`_do_auto_resolve` returns `True`).
+
+You never need to run `lorekeep wiki` manually unless you want to force a refresh.
+
+## Determinism
+
+Re-generating the wiki from unchanged `facts.jsonl` yields **byte-identical** pages (entity pages, index, overview). The only exception is `log.md`, which is append-only by design.
+
+Wiki generation is **best-effort** — if it fails (e.g. slug collision, disk error), the triggering command (`compile`, `resolve`) still succeeds. `facts.jsonl` is never blocked by a wiki failure.
+
+## Path resolution
+
+The wiki lives at `<data-home>/wiki/` (same level as `raw/` and `graph/`). Override with:
+
+```bash
+LOREKEEP_WIKI=/path/to/wiki uvx lorekeep wiki
+```
+
+See [data-home.md](data-home.md) for the full 4-tier path resolution.
+
+## Next
+
+- [Compile guide](compile.md) — how `facts.jsonl` is produced.
+- [Serve guide](serve.md) — how agents consume the same graph over MCP.

{lorekeep-0.4.0 → lorekeep-0.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lorekeep"
-version = "0.4.0"
+version = "0.6.0"
 description = "Temporal knowledge graph for AI agents via MCP"
 readme = "README.md"
 license = {text = "MIT"}

{lorekeep-0.4.0 → lorekeep-0.6.0}/src/lorekeep/__init__.py

@@ -1,3 +1,3 @@
 """Lorekeep — temporal knowledge graph for AI agents via MCP."""
 
-__version__ = "0.4.0"
+__version__ = "0.6.0"