feat(wiki): port full 42-scope catalogue from agentic-ai for parity

User pointed at ``agentic-ai/packages/memory/src/wiki/scopes.ts`` as
the reference: agentic-ai defines 42 canonical project scopes; Cortex
had 27. Importing the missing 15 + aligning 3 scope names brings
Cortex to parity.

# Renamed for parity
* ``configuration-reference`` → ``configuration``.
* ``migration`` → ``migration-guides``.
* ``extending`` → ``plugins-extensions``.

Anchor filenames overlap so existing pages keep coverage; only the
scope-name string (in dashboards + curation_gaps frontmatter) changes.

# Added 15 scopes
Diátaxis how-to / tutorial axis:
* ``how-to-guides`` — umbrella index of task-oriented recipes.
* ``tutorials`` — step-by-step learning paths.
* ``integration-guides`` — wiring into IDEs, CI, model APIs,
  databases, MCP clients, downstream services.
* ``examples`` — end-to-end working sample apps / demos.

Setup + local-dev:
* ``local-development`` — contributor's machine setup, dev server,
  hot-reload, mocks.

Operational telemetry:
* ``logging`` — log format, levels, sinks, rotation, structured
  fields, conventions for new log sites.
* ``observability`` — metrics, traces, dashboards, alerts;
  OpenTelemetry surface; copy-paste log queries.

Security:
* ``secrets-management`` — API keys, tokens, certs across dev, CI,
  prod. Rotation + leak procedure. Distinct from access-control
  (about the secrets themselves, not who can use them).
* ``access-control`` — RBAC / ABAC / capability matrix.

Contribution + governance:
* ``coding-standards`` — mechanical rules (file size, layer
  boundaries, naming, lint config, type discipline, source-citation
  requirements).
* ``release-process`` — how a human cuts a release (vs ci-cd which
  is the pipeline).
* ``changelog`` — user-facing record per version (Keep a Changelog).
* ``roadmap`` — strategic surface: planned / in-progress / deferred
  with reasons.

Inclusive design:
* ``accessibility`` — WCAG level, keyboard nav, screen-reader.
  "Not applicable — no UI" valid for non-UI projects.
* ``localization`` — i18n library, source strings, translator
  workflow. "Not applicable — single-locale project" valid.

Total scopes: 27 → 42. cortex coverage drops to 15/42 until the
autonomous worker authors the new anchors. Every other project's
queue grows by the same delta.

# README architecture + agent integration sections refreshed
* "Agent Integration" now opens with Cortex's own headless authoring
  worker — same agent infrastructure the user's team uses, applied
  to documentation maintenance. Added the autonomous-6h-spawn
  explanation.
* "Architecture" table refreshed: shared/ row added, core count
  bumped to 175+ (added wiki curation modules), MCP-exposed handler
  count = 49. New "Wiki curation subsystem (3.17.0)" subsection
  enumerates every module that implements the autonomous loop with
  its responsibility.
* CORTEX_CONSOLIDATE_TTL_HOURS named in the configuration paragraph.

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

Author: cdeust

README.md

@@ -364,44 +364,63 @@ Each page renders with:
 
 ## Agent Integration
 
-Cortex works with teams of specialized agents. Each agent has scoped memory (`agent_topic`) while sharing critical decisions across the team — based on Wegner's transactive memory theory (1987): teams store more knowledge than individuals because each member specializes.
+Cortex works with teams of specialized agents — and in 3.17.0 it **uses one itself**. The headless authoring worker is a Claude agent that wakes up every six hours and drains the wiki curation queue: it reads page metadata, queries the codebase-intelligence MCP tools to ground each section in real call-graph facts, then invokes `claude -p` (your existing Claude Code credentials, no API key) to author the missing content. The result is autonomous documentation maintained by the same agent infrastructure your team already uses.
+
+Each agent — Cortex's worker included — has scoped memory (`agent_topic`) while sharing critical decisions across the team — based on Wegner's transactive memory theory (1987): teams store more knowledge than individuals because each member specializes.
 
 <p align="center">
 <img src="docs/diagram-team-memory.svg" alt="Transactive Memory System" width="80%"/>
 </p>
 
-**Specialization** — each agent writes to its own topic. Engineer's debugging notes don't clutter tester's recall.
+**Specialization** — each agent writes to its own topic. Engineer's debugging notes don't clutter tester's recall. The headless wiki worker writes to `agent_topic=wiki-curation` so its drafts don't pollute interactive recall.
+
+**Coordination** — decisions auto-protect and propagate. When engineer decides "use Redis over Memcached," every agent sees it at next session start. ADRs the worker drafts at session end (Entry / Mandatory / How / Result / Serves) are part of this propagation: the task-record IS the cross-agent shared memory.
 
-**Coordination** — decisions auto-protect and propagate. When engineer decides "use Redis over Memcached," every agent sees it at next session start.
+**Directory** — entity-based queries span all topics. "What do we know about the reranker?" returns results from engineer, tester, researcher, AND the wiki worker's drafts naming the reranker.
 
-**Directory** — entity-based queries span all topics. "What do we know about the reranker?" returns results from engineer, tester, and researcher.
+**Autonomous wiki maintenance.** SessionStart auto-spawns the consolidate hook every six hours. The hook reads `~/.claude/methodology/.last_consolidate`; if older than the TTL, it spawns a detached subprocess that drains the curation-gap queue. No cron, no daemon, no manual invocation — the agent runs because you open Claude Code, and stops when nothing's left to author.
 
 Works with any custom agents. See [zetetic-team-subagents](https://github.com/cdeust/zetetic-team-subagents) for a ready-made team of **27 specialists** — each with scoped memory that doesn't clutter the others.
 
 ---
 
 ## Architecture
 
-Clean Architecture with strict dependency rules. Inner layers never import outer layers.
+Clean Architecture with strict dependency rules. Inner layers never import outer layers. The 3.17.0 release added the autonomous wiki-curation subsystem on top of the existing layers without crossing any boundary.
 
 <p align="center">
 <img src="docs/diagram-architecture.svg" alt="Clean Architecture layers" width="80%"/>
 </p>
 
 | Layer | What lives here | Count |
 |---|---|---|
-| **core/** | Neuroscience + retrieval logic | 118 modules |
+| **shared/** | Pure utilities (text, hash, similarity, types) | 11 modules |
+| **core/** | Neuroscience + retrieval + wiki curation logic | 175+ modules |
 | **context_assembly/** | Structured context assembler | 10 modules |
-| **infrastructure/** | PostgreSQL, embeddings, file I/O | 33 modules |
-| **handlers/** | MCP tools | 62 tools |
-| **hooks/** | Lifecycle automation | 7 hooks |
+| **infrastructure/** | PostgreSQL, embeddings, file I/O, MCP client | 33 modules |
+| **handlers/** | MCP tools + consolidation cycles | 91+ tools / 49 MCP-exposed |
+| **hooks/** | Lifecycle automation (incl. autonomous consolidate spawn) | 9 hooks |
+| **server/** | HTTP standalone + wiki API + viz | 4 modules |
 | **observability/** | Prometheus text-format metrics | 1 module |
 
+**Wiki curation subsystem (3.17.0):**
+
+* `core/wiki_coverage.py` — 42 canonical project scopes, per-domain audit, file-level coverage, anchor freshness window.
+* `core/wiki_curation_gaps.py` — 14 canonical file-doc sections, gap detection.
+* `core/wiki_drift.py` — drift detection (missing source citations, stale mtime, off-template).
+* `core/wiki_stub_detector.py` — placeholder + shallow-content scoring.
+* `core/wiki_file_doc_skeleton.py` — generates skeletons with visible gap markers.
+* `core/wiki_coverage_dashboard.py` — per-project `wiki/_dashboards/<project>.md` regenerated each cycle.
+* `core/auto_task_record.py` + `handlers/auto_task_record_writer.py` — session-end auto-draft of ADRs with Entry/Mandatory/How/Result/Serves.
+* `handlers/consolidation/wiki_maintenance.py` — purge + audit + dashboard generation.
+* `handlers/consolidation/headless_authoring.py` — drains the gap queue via `claude -p` with codebase-intelligence MCP tools grounding each section.
+* `hooks/consolidate_background.py` + `session_start.py` — autonomous 6-hour spawn loop.
+
 **Storage:** PostgreSQL 15+ with pgvector (HNSW) and pg_trgm. All retrieval in PL/pgSQL stored procedures.
 
 **Concurrency (v3.13+):** `psycopg_pool.ConnectionPool` with two latency classes — `interactive_pool` (min=2, max=8) for recall/remember/anchor, `batch_pool` (min=1, max=2) for consolidate/ingest. Tool handlers run on worker threads via `asyncio.to_thread`; per-tool admission semaphores bound fan-out. Heat is a *function* computed at read time by `effective_heat()` — homeostatic writes one scalar per domain per run instead of N rows.
 
-**Configuration:** Set `DATABASE_URL` (default: `postgresql://localhost:5432/cortex`). All parameters use `CORTEX_MEMORY_` prefix — see `mcp_server/infrastructure/memory_config.py` for the full list (~40 parameters).
+**Configuration:** Set `DATABASE_URL` (default: `postgresql://localhost:5432/cortex`). All parameters use `CORTEX_MEMORY_` prefix — see `mcp_server/infrastructure/memory_config.py` for the full list (~40 parameters). Wiki cycle TTL is `CORTEX_CONSOLIDATE_TTL_HOURS` (default 6h).
 
 ---