io.github.cdeust/hypermnesia-mcp

Blame path resolver: turn the ⟦rcpt:N⟧ markers visible in the current context into presence-in-context evidence — which memories each injection channel (recall, session_start, auto_recall, agent_briefing) put into the context, when, at which persisted rank and score. This is evidence of PRESENCE, never causality. Protocol: collect the ⟦rcpt:N⟧ markers that were in context BEFORE the answer being questioned; EXCLUDE the marker injected alongside the current prompt's own memory block (self-pollution guard) — then pass the ids here. To correct a wrong memory surfaced by the evidence, store a superseding memory with remember. Deterministic entry point: the /why slash command. Distinct from `get_causal_chain` (entity-graph traversal over inferred relations) and `recall` (similarity retrieval): why replays RECORDED injection receipts only.

Create a numbered ADR (Architecture Decision Record) from structured Context/Decision/Consequences fields. Atomically: computes the next free ADR number, renders the standard template, writes wiki/adr/<NNNN>-<slug>.md under the wiki root, and registers a protected pointer memory tagged `wiki`+`adr` so the decision surfaces in `recall`. Use this whenever a non-trivial architectural choice is made — the resulting page is the single citable source of truth. Distinct from `wiki_write` (raw markdown, no auto-numbering, no template), and from `remember` (memory only, no .md file). Mutates the wiki/ tree and the memories table; refuses if the target file already exists. Latency ~50ms. Returns {path, number, title, status, created, bytes_written, root} or {error}.

Fetch a draft + its source claims + the kind contract so the caller (LLM) can refine it, or list the pending drafts. Phase 2.3 (Path B): `wiki_synthesize` fills wiki.drafts from routed claims, this hands one to the caller, and `wiki_refine_draft` takes the prose back. Read-only.

Add a bidirectional link between two wiki pages: write the forward relation into the `## Related` section of the source page and the inverse relation into the target page, in one idempotent operation. Use this to record dependencies, derivations, supersession chains, or free-form `see also` connections between knowledge artefacts. Distinct from `wiki_write` (authors a page, doesn't link), `wiki_compile` (publishes drafts, doesn't link), and graph-relationship tools (this writes markdown sections, not DB edges). Mutates two .md files atomically. Latency ~30ms. Returns {from_path, to_path, forward_relation, inverse_relation}.

Enumerate every authored wiki page under ~/.claude/methodology/wiki/, filesystem-walked from the wiki root. Optionally restrict by kind (adr, specs, guides, reference, conventions, lessons, notes, journal, files). Two filters are applied by default and can be opted out of: (1) redirect stubs (frontmatter ``redirect_to:`` or ``redirect_id:``) are excluded — pass ``include_redirects: true`` to see them; (2) auto-generated pages (frontmatter ``provenance: auto-generated``, produced by ``codebase_analyze``) are excluded — pass ``include_auto_generated: true`` to see them. Read-only; never modifies anything. Distinct from `wiki_reindex` which generates the .generated/INDEX.md from the same enumeration, and from `wiki_read` which fetches one page's content. Latency <200ms on a 9000-page wiki. Returns {root, count, pages, redirect_count, auto_generated_count}.

One-shot idempotent sync of the filesystem wiki (~/.claude/methodology/wiki/) into wiki.pages / wiki.links / wiki.page_sources. Walks every PAGE_KINDS directory, upserts each page keyed on rel_path (body_hash guards no-op re-writes), re-resolves [[slug]] links, then reconciles: any wiki.pages row whose rel_path no longer exists on disk (deleted file, rename, or a wiki_purge run — which only touches the FS, never PG) is purged from wiki.pages, cascading via FK ON DELETE CASCADE to wiki.links and wiki.page_sources. The `_`-prefixed kind dirs (_kinds/_rules/_views/_bibliography/_dashboards) and the root README.md are outside the scan entirely on both phases, so they are never upserted and never purged. Defaults to dry_run=true (report the ghost rel_paths without deleting); pass dry_run=false to actually purge. Distinct from `wiki_purge` (deletes FS files that fail the classifier, never touches PG) — this tool never touches the FS, only reconciles PG to match it. A frontmatter status outside wiki.pages' DB CHECK union falls back to 'seedling' and is reported in warnings (never blocks the page write). Returns {pages_processed, pages_written, pages_unchanged, links_written, links_resolved_pass3, purge: {dry_run, ghost_count, ghost_paths, purged}, errors, error_count, warnings, warning_count}.

Purge wiki pages that no longer earn their place. Two reject axes: (1) the page no longer passes the current classifier (`core/wiki_classifier`) — used after tightening rules or a polluting backfill; (2) the page is a stub — body is majority placeholder markers (_(to be filled)_ / _To be written._ / _(none identified)_), produced by the groomer or by template_v1 synthesis. Stubs masquerade as content but carry none. Memories remain in the store (still surface via `recall`); only the wiki markdown files are removed from disk. Distinct from `wiki_consolidate` (heat decay + lifecycle, doesn't delete based on classifier), `forget` (deletes a memory, not a wiki page), and `wiki_compile` (publishes drafts, doesn't purge). Defaults to dry-run; pass apply=true to actually delete. Latency ~200-500ms. Returns {kept, purged, purged_paths, purged_reasons, dry_run} plus the scan accounting — {wiki_pages_total, scanned, unscanned, errored, unrecognised_dirs} — so a caller can tell a full sweep from one that reached only part of the wiki. A page that failed to read counts as scanned, not unscanned: an I/O fault shows up in `errored`, never as a coverage gap.

Fetch the raw markdown source of one wiki page by its wiki-relative path. Path resolution is sandboxed under the wiki root — absolute paths and `../` traversal are rejected at the storage layer. When the page is a redirect stub (frontmatter ``redirect_to:`` or ``redirect_id:``) the chain is followed transparently up to 5 hops; cycles and dangling targets surface as errors. Pass ``follow_redirects: false`` to read the stub itself. Page content is filesystem-only and always returned even if PostgreSQL is unreachable. As an explicit side effect, a successful read within a known Claude Code session records one deduplicated wiki.citations row (page, session) — the primary authority-earning signal driving page heat/citation_count; best-effort, never blocks or fails the read (no window session, PG down, or a page never compiled into PG all degrade to 'read succeeds, no citation'). Distinct from `wiki_list` which enumerates available pages, and from `wiki_export` which renders a page through Pandoc to PDF/DOCX/HTML. Latency <10ms. Returns {path, content, content_length, offset, root, redirect_chain} or {error}. Pages larger than the response budget come back with ``content_truncated: true`` — page via the ``offset`` argument.

Submit a refined draft (lead, sections, optional title). Updates wiki.drafts in place; records an audit memo, one row per call. The draft's confidence is left as its source claims set it (ADR-1065), so refining never moves a draft past `wiki_curate`'s approve threshold. Sections are refused unless they satisfy the kind contract returned by `wiki_get_draft`. A call carrying none of title/lead/sections/frontmatter is refused whole, and so is one whose value for any of them is empty: blanking a field is not a refinement (ADR-1068, ADR-1069). A refused call writes neither the draft nor a memo. Phase 2.3 (Path B).

Regenerate the wiki table of contents at <wiki_root>/.generated/INDEX.md by enumerating every authored page and grouping it by kind (adr, specs, guides, reference, conventions, lessons, notes, journal, files). Redirect stubs are excluded; auto-generated pages (``provenance: auto-generated``) are surfaced in a separate ``Auto-generated reference`` section after the human-authored content. Output is deterministic — sorted by kind then path so unchanged wikis yield byte-identical INDEX files. Authored pages are never touched. INDEX.md and the exact decision map are refreshed; project mode also updates docs/adr. Use this after bulk wiki edits, imports, or `wiki_compile` runs. Distinct from `wiki_list` (returns the listing in the response, no file write) and from `wiki_consolidate` (heat decay / staleness, not ToC rebuild). An explicit project_root isolates project publication. Latency <500ms on a 9000-page wiki. Returns {path, total_pages, by_kind, auto_generated_by_kind, redirect_count, root}.

Move a wiki page from ``from_path`` to ``to_path`` and leave a redirect stub at the old location pointing to the new one. ``wiki_read`` follows redirect stubs transparently. Refuses to operate on pages without a stable ``id`` field (run ``scripts/wiki_backfill_ids.py`` first) or on existing redirect stubs. Returns {from_path, to_path, page_id, stub_created}.

Verify that code symbols cited by wiki pages still resolve in the AST (via the ai-architect-mcp-codebase MCP server, ADR-0046 Phase 2). Takes an optional path (verify one page) or no args (verify every authored page) and returns per-page verdicts: {page, symbol_refs, missing_refs, is_symbol_stale, rationale}. Requires AP enabled (CORTEX_MEMORY_AP_ENABLED=1, the default); when disabled the handler returns status=skipped and never produces a stale verdict. Read-only — never mutates wiki or memory state.

Author a new wiki page or append/replace content on an existing one (kind inferred from the first path segment: adr, specs, files, notes, lessons, conventions, guides, reference, journal). Pages live under ~/.claude/methodology/wiki/, written atomically via tmp+rename. After a successful write, registers a protected PG pointer memory tagged `wiki` so the page surfaces in `recall`. Use this for any document that should outlive the session — lessons, conventions, runbooks, anything you might link from a future ADR. Distinct from `wiki_adr` (auto-numbered ADRs from structured Context/Decision/Consequences), `wiki_compile` (publishes already-curated drafts), and `remember` (no markdown page, just a memory). Mutates the wiki/ tree, the memories table, wiki.pages (synced synchronously so the page has a resolvable id immediately), and — when `memory_ids` is passed — wiki.citations (one deduplicated row per memory actually used to author the page; how a curate_wiki job's memory cluster becomes durable, queryable provenance). Latency ~50ms. Returns {path, mode, created, bytes_written, root, citations_written} or {error}.