@mfittko/repo-wiki 0.2.1

package/docs/plans/wiki-graph.md

@@ -0,0 +1,183 @@
+# Epic: Wiki Knowledge Graph
+
+## Summary
+
+Build a plugin-based knowledge graph system that models relationships between wiki pages, source modules, documentation topics, and ownership state. The core graph is backend-agnostic — adapters translate it to different storage and rendering targets (GitHub Wiki, Neo4j, Confluence, Obsidian, flat JSON). The graph powers navigation generation, cross-link validation, agent query routing, affected-page detection for incremental updates, and safe reconciliation with existing wikis.
+
+## Current shipped foundation (Phase 1)
+
+The repository now ships a local deterministic graph foundation at `.llmwiki/graph.json` (`schema_version: 1`) with internal loader/index/traversal helpers.
+
+- Shipped node kinds: `page`, `source`, `documentation`, `module`
+- Shipped edge kinds: `wiki_link`, `provenance`, `affects`, `owns`
+- Shipped validation gates: malformed IDs, duplicate IDs, dangling endpoints, invalid edge endpoint kinds
+
+This foundation is intentionally local and JSON-based. `.llmwiki/wiki` remains the primary derived artifact.
+
+## Still planned (not shipped in Phase 1)
+
+- backend adapters (Neo4j/SQLite/other)
+- plugin discovery and adapter registration
+- public runtime query/path/explain/watch transports
+
+## Architecture
+
+```mermaid
+flowchart TD
+  subgraph Core["Core Graph Model"]
+    Nodes[Nodes: page, module, source-file, doc-topic]
+    Edges[Edges: links-to, depends-on, parent-of, related-to, supersedes, tests, documents]
+    Traversal[Traversal Engine]
+  end
+
+  Core --> StorageLayer[Storage Adapter Interface]
+  Core --> RenderLayer[Render Adapter Interface]
+  Core --> QueryLayer[Query Adapter Interface]
+
+  StorageLayer --> JSON[JSON File]
+  StorageLayer --> Neo4j[Neo4j]
+  StorageLayer --> SQLite[SQLite]
+  StorageLayer --> CustomS[Custom Plugin]
+
+  RenderLayer --> GHWiki[GitHub Wiki]
+  RenderLayer --> Obsidian[Obsidian]
+  RenderLayer --> Confluence[Confluence]
+  RenderLayer --> CustomR[Custom Plugin]
+
+  QueryLayer --> InMemory[In-Memory]
+  QueryLayer --> Cypher[Cypher / Neo4j]
+  QueryLayer --> MCP[MCP Endpoint]
+  QueryLayer --> CustomQ[Custom Plugin]
+```
+
+```mermaid
+flowchart TD
+  Scanner[Production Scanner] --> ImportGraph[Import Graph]
+  WikiPages[Wiki Pages] --> LinkExtract[Link Extraction]
+  Frontmatter[Page Frontmatter] --> Metadata[Relationship Metadata]
+  OwnershipMarkers[Ownership + Preserve Markers] --> Metadata
+
+  ImportGraph --> GraphBuilder[Graph Builder]
+  LinkExtract --> GraphBuilder
+  Metadata --> GraphBuilder
+
+  GraphBuilder --> CoreGraph[Core Graph]
+  CoreGraph --> NavGen[Navigation Generation]
+  CoreGraph --> OrphanDetect[Orphan Detection]
+  CoreGraph --> AffectedCalc[Affected Page Calculation]
+  CoreGraph --> Reconcile[Reconcile / Delete Decisions]
+  CoreGraph --> AgentQuery[Agent Query Routing]
+```
+
+```mermaid
+graph LR
+  subgraph "Example Graph"
+    Home((Home)) --> Arch((Architecture))
+    Home --> Index((Index))
+    Home --> Agent((Agent-Context-Pack))
+    Index --> ModA((Module-A))
+    Index --> ModB((Module-B))
+    Arch --> ModA
+    ModA --> ModB
+    ModB --> DepMap((Dependency-Map))
+    ModA --> TestStrat((Testing-Strategy))
+  end
+```
+
+## Plugin Contract
+
+Each adapter type implements a minimal interface:
+
+**Storage adapter** — persist and load the graph
+- `save(graph)` → serialize graph to backend
+- `load()` → deserialize graph from backend
+- `patch(delta)` → apply incremental changes
+
+**Render adapter** — produce navigation/linking artifacts for the target platform
+- `renderNavigation(graph)` → platform-specific nav (e.g., `_Sidebar.md`, Obsidian MOC, Confluence space tree)
+- `renderPageLinks(node)` → "Related pages" section in platform format
+- `renderBreadcrumbs(node)` → ancestry path
+
+**Query adapter** — expose graph queries to consumers
+- `related(nodeId, depth)` → connected nodes within N hops
+- `path(from, to)` → shortest path between nodes
+- `affected(changedNodes)` → transitively affected pages
+- `orphans()` → nodes with no inbound edges
+- `clusters()` → disconnected subgraphs
+
+## Key Deliverables
+
+### Core graph model
+- Node types: page, module, source-file, documentation-topic
+- Edge types: links-to, depends-on, parent-of, related-to, supersedes, tests, documents, owns, preserves
+- Edge metadata: weight, direction, source (explicit link vs. inferred)
+- Graph construction from wiki content (extracted links, frontmatter)
+- Graph construction from existing wiki ownership metadata and preserved sections
+- Graph construction from source relationships (import graph → page graph)
+- Orphan and cluster detection
+- Generated/human/mixed page classification
+- Deterministic serialization format (JSON reference schema)
+
+### Built-in adapters
+- **Storage: JSON file** — default, zero-dependency, works offline
+- **Storage: Neo4j** — optional, for teams wanting native graph queries at scale
+- **Render: GitHub Wiki** — `_Sidebar.md`, `Index.md`, wikilink format
+- **Render: Obsidian** — MOC pages, `[[wikilink]]` format, graph metadata in YAML frontmatter
+- **Query: In-memory** — default traversal engine for CLI and agent use
+- **Query: MCP** — expose graph queries via Model Context Protocol for agent tooling
+
+### Plugin registration
+- Config-driven adapter selection in `.llmwiki/config.json`
+- Plugin discovery via package exports or local file path
+- Adapter validation (schema compliance check on load)
+
+## Success Criteria
+
+- Core graph model is independent of any specific wiki platform or storage backend
+- Swapping adapters requires only config changes, no code modifications
+- Every wiki page has explicit relationship metadata (inbound/outbound links, module associations)
+- Every wiki page can be classified as generated, human-owned, mixed, or unmanaged
+- Navigation artifacts are generated from the graph via the render adapter, not hardcoded
+- Orphan and under-connected pages are surfaced as lint warnings
+- Agents can query "what pages should I read for task X?" via the query adapter
+- Incremental mode uses the graph to determine affected pages from a source change
+- Reconcile and delete decisions can be derived from graph ownership data instead of filename heuristics
+- A new adapter can be added without modifying core graph code
+
+## Configuration Example
+
+```json
+{
+  "graph": {
+    "storage": {
+      "adapter": "json-file",
+      "options": { "path": ".llmwiki/graph.json" }
+    },
+    "render": {
+      "adapter": "github-wiki",
+      "options": { "sidebar": true, "breadcrumbs": false }
+    },
+    "query": {
+      "adapter": "in-memory",
+      "options": { "maxDepth": 3 }
+    }
+  }
+}
+```
+
+## Dependencies
+
+- Upstream: Production scanner (source-to-module mapping, import graph), LLM compiler (page generation with relationship metadata)
+- Downstream: Incremental mode (affected-page detection via query adapter), agent-integration (query routing via MCP adapter), CI publishing (navigation regeneration via render adapter)
+
+## Open Questions
+
+- How to handle bidirectional link consistency (if A links to B, should B always link back)?
+- Should the graph support weighted relationships (strong vs. weak connections)?
+- How to model cross-repo wiki relationships for monorepo scenarios?
+- Should the graph include documentation-to-source edges or only page-to-page?
+- What's the minimum adapter interface that covers all current use cases without over-abstracting?
+- Should adapters be npm packages, local files, or both?
+- How to handle adapter-specific features (e.g., Neo4j Cypher queries) without leaking into the core model?
+- Should preserved sections be modeled as subnodes, annotations, or opaque page metadata?
+- How should ownership transfer be represented when a human takes over a previously generated page?

package/docs/plans/wiki-health.md

@@ -0,0 +1,76 @@
+# Epic: Wiki Health Linting
+
+## Summary
+
+Extend the existing `repo-wiki lint` gate with wiki health checks that detect graph-level problems: orphan pages, stale generated pages, missing cross-references, recurring unpaged concepts, broken wiki links, and generated pages whose sources no longer exist. Health findings should be deterministic, config-driven for severity, and consumable by both CI and agents proposing repair patches.
+
+## Architecture
+
+```mermaid
+flowchart TD
+  Wiki["Local wiki pages"] --> Graph["Wiki link graph"]
+  Manifest["Manifest + source cards"] --> Graph
+  Graph --> Orphan["Orphan detector<br/>(no inbound links)"]
+  Graph --> Stale["Stale page detector<br/>(source commit far behind HEAD)"]
+  Graph --> BrokenLinks["Broken link checker"]
+  Graph --> MissingCross["Missing cross-reference detector"]
+  Graph --> Concepts["Recurring concept detector<br/>(unpaged concepts)"]
+  Manifest --> DeletedSource["Deleted/renamed source detector"]
+  DeletedSource --> StaleGen["Stale generated page report"]
+  Orphan --> Report["Health report"]
+  Stale --> Report
+  BrokenLinks --> Report
+  MissingCross --> Report
+  Concepts --> Report
+  StaleGen --> Report
+  Report --> CI["CI exit code policy"]
+  Report --> Agent["Agent repair patch input"]
+```
+
+## Key Deliverables
+
+- Orphan-page detection: pages with no inbound wiki links.
+- Stale-page detection: generated pages whose `source_commit` is far behind HEAD.
+- Broken wiki link checker: links to pages that do not exist.
+- Missing cross-reference detector: related module and cross-cutting pages not linked to each other.
+- Recurring concept detector: terms mentioned frequently across pages that lack their own dedicated page.
+- Deleted/renamed source detector: generated pages for files or modules that no longer exist.
+- Config-driven severity: each check independently set to `warning` or `error`.
+- Machine-readable JSON output for CI and agent consumption alongside human-readable text.
+- Integration with `repo-wiki lint` as the primary gate; optionally surfaced via a future `repo-wiki health` command.
+
+## Success Criteria
+
+- Health findings are deterministic for the same wiki and manifest inputs.
+- CI can fail on error-level findings while surfacing warnings without blocking.
+- An agent can consume the JSON output and propose targeted repair patches.
+- Stale generated pages for deleted sources are identified and eligible for safe deletion by the publisher.
+
+## Acceptance Criteria (from PLAN.md)
+
+- Health findings are deterministic under the same wiki and manifest inputs.
+- Config controls warning vs error severity per check.
+- Lint output is consumable by CI and by an agent proposing repair patches.
+
+## Severity Defaults
+
+| Check | Default |
+|---|---|
+| Orphan pages | warning |
+| Stale pages (source commit) | warning or error by policy |
+| Broken wiki links | warning (should become error for navigation-critical links) |
+| Missing cross-references | warning |
+| Recurring unpaged concepts | warning |
+| Stale generated pages (deleted sources) | error |
+| Oversized pages | warning |
+
+## Dependencies
+
+- Upstream: wiki linter, publisher, scanner (for source commit and file-existence data).
+- Downstream: incremental mode (uses stale/deleted page data for safe deletes), agent integration (consumes health JSON for repair prompts).
+
+## Open Questions
+
+- How should the health linter distinguish useful hub pages from pages that are merely large?
+- Should recurring concept detection run on compiled page content or on source card metadata?
+- What threshold (number of mentions, number of pages) triggers a "missing page" suggestion?

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "@mfittko/repo-wiki",
+  "version": "0.2.1",
+  "description": "Node.js CLI and library for compiling any Git repository and its validated documentation into a GitHub Wiki knowledge base.",
+  "type": "module",
+  "private": false,
+  "bin": {
+    "repo-wiki": "./dist/bin/repo-wiki.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js"
+    }
+  },
+  "files": [
+    "dist/",
+    "docs/",
+    "prompts/",
+    "skills/",
+    ".llmwiki/schema.md",
+    ".llmwiki/config.json",
+    "CHANGELOG.md",
+    "README.md",
+    "AGENTS.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=24"
+  },
+  "scripts": {
+    "clean": "rm -rf dist .tsbuildinfo",
+    "prepare": "npm run build",
+    "lint:code": "tsc --project tsconfig.json --noEmit",
+    "smoke:consumer": "set -eu; tmp_dir=$(mktemp -d); trap 'rm -rf \"$tmp_dir\"' EXIT; pack_out=$(npm pack --pack-destination \"$tmp_dir\"); tarball=$(printf '%s\\n' \"$pack_out\" | tail -n 1); tarball_path=\"$tmp_dir/$tarball\"; if [ ! -f \"$tarball_path\" ]; then echo 'No tarball produced' >&2; exit 1; fi; consumer_dir=\"$tmp_dir/consumer\"; mkdir -p \"$consumer_dir\"; cd \"$consumer_dir\"; npm init -y >/dev/null; npm install --no-audit --no-fund \"$tarball_path\" >/dev/null; npx --no-install repo-wiki --help >/dev/null",
+    "build": "tsc --project tsconfig.json",
+    "test:compiled": "node ./dist/test/run-compiled-tests.js",
+    "coverage:compiled": "c8 --include=dist/src/**/*.js --reporter=text --check-coverage --lines 95 node ./dist/test/run-compiled-tests.js",
+    "coverage": "npm run build && npm run coverage:compiled",
+    "check": "npm run build && npm run test:compiled",
+    "test": "npm run check",
+    "repo-wiki": "npm run build --silent && node ./dist/bin/repo-wiki.js",
+    "scan:bootstrap": "npm run build --silent && node ./dist/bin/repo-wiki.js scan --mode bootstrap --repo . --out .llmwiki/run",
+    "plan:bootstrap": "npm run build --silent && node ./dist/bin/repo-wiki.js plan --scan .llmwiki/run --out .llmwiki/bootstrap-plan.json",
+    "compile:local": "npm run build --silent && node ./dist/bin/repo-wiki.js compile --scan .llmwiki/run --plan .llmwiki/bootstrap-plan.json --wiki .llmwiki/wiki",
+    "lint:local": "npm run build --silent && node ./dist/bin/repo-wiki.js lint --wiki .llmwiki/wiki --scan .llmwiki/run",
+    "kb:bootstrap": "npm run build --silent && node ./dist/bin/repo-wiki.js run --mode bootstrap --repo . --scan .llmwiki/run --plan .llmwiki/bootstrap-plan.json --wiki .llmwiki/wiki",
+    "kb:incremental": "npm run build --silent && node ./dist/bin/repo-wiki.js run --mode incremental --repo . --scan .llmwiki/run --plan .llmwiki/incremental-plan.json --wiki .llmwiki/wiki",
+    "kb:publish": "npm run build --silent && node ./dist/bin/repo-wiki.js publish --wiki .llmwiki/wiki",
+    "self:wiki": "npm run kb:bootstrap",
+    "pack:check": "npm run build --silent && npm pack --dry-run",
+    "lint:docs": "npm run build --silent && node ./dist/bin/repo-wiki.js lint-docs --repo . --scan .llmwiki/run",
+    "changelog:ensure": "node ./scripts/update-changelog.mjs ensure",
+    "changelog:release": "node ./scripts/update-changelog.mjs release",
+    "changelog:update": "node ./scripts/update-changelog.mjs update",
+    "verify": "npm test"
+  },
+  "keywords": [
+    "llm-wiki",
+    "knowledge-base",
+    "github-wiki",
+    "repository-analysis",
+    "agent-context",
+    "codex",
+    "documentation-generator",
+    "markdown-lint",
+    "documentation-debt",
+    "github-actions"
+  ],
+  "license": "MIT",
+  "types": "./dist/src/index.d.ts",
+  "dependencies": {
+    "typescript": "^5.8.3"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.21",
+    "c8": "^10.1.3"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  }
+}

package/prompts/compiler.md

@@ -0,0 +1,16 @@
+# Wiki Compiler Prompt
+
+You are compiling a Git repository into a GitHub Wiki knowledge base.
+
+Rules:
+
+- Source code at the pinned commit is authoritative.
+- Tests, CI, configuration, schemas, and migrations are high-authority evidence.
+- Markdown documentation is secondary evidence. Use it for intent, terminology, onboarding, and rationale, but validate operational or behavioral claims before presenting them as current truth.
+- If markdown conflicts with code, trust code and add the conflict to Documentation-Debt-Report.md or Open-Questions.md.
+- Preserve human-maintained sections between HUMAN_NOTES markers.
+- Prefer updating existing pages over creating new pages.
+- Every material claim should be tied to source paths or documentation cards.
+- Do not copy secrets, tokens, private keys, or full .env values.
+
+Output should be a structured patch of markdown pages.

package/prompts/lint.md

@@ -0,0 +1,18 @@
+# Wiki and Documentation Lint Prompt
+
+Validate the compiled wiki and ingested markdown.
+
+Check for:
+
+- missing required pages
+- broken wiki links
+- orphan pages
+- missing source commit metadata
+- secret-like content
+- stale documentation influencing authoritative wiki text
+- documentation claims contradicted by code, tests, CI, config, schemas, or migrations
+- unvalidated operational claims from markdown
+- duplicate pages or concepts
+- oversized pages
+
+Documentation is not rejected by default; it is scored, labeled, and reported.

package/prompts/page-templates.md

@@ -0,0 +1,25 @@
+# Page Templates
+
+## Module page
+
+- Purpose
+- Main source paths
+- Entry points and symbols
+- Runtime behavior
+- Dependencies
+- Tests
+- Documentation-derived context, clearly labeled
+- Known risks
+- Open questions
+- Human notes block
+
+## Documentation Debt Report
+
+- Documentation ingestion config
+- Status table
+- Stale documentation candidates
+- Contradiction-review candidates
+- Unvalidated operational claims
+- Commands found in markdown
+- Environment variables mentioned in markdown
+- Recommended follow-up

package/skills/repo-wiki-cli/SKILL.md

@@ -0,0 +1,139 @@
+---
+name: repo-wiki-cli
+description: "Use when running repo-wiki CLI workflows in this repository or as a distributed plugin for external repositories: scanning, planning, compiling, linting, local wiki regeneration, and GitHub Wiki publishing. Keywords: repo-wiki CLI, npx repo-wiki, self:wiki, kb:bootstrap, lint:local, lint-docs, publish wiki, GitHub Wiki, .llmwiki."
+user-invocable: false
+---
+
+# repo-wiki CLI Operations
+
+Use this skill when operating the `repo-wiki` CLI for this repository or for an external repository that uses repo-wiki.
+
+## Safety and authority
+
+- Source, tests, CI, and configuration are authoritative. Generated wiki pages under `.llmwiki/wiki/` are derived artifacts.
+- Prefer the installed/public CLI shape (`repo-wiki` or `npx repo-wiki`) in examples so this skill works both inside this repository and as a distributed plugin.
+- Inside the repo-wiki source repository, package scripts are acceptable because they build the local TypeScript implementation first.
+- Do not run `repo-wiki init` in an already configured repository unless explicitly asked; it mutates `.llmwiki/config.json` and may create setup files.
+- Command-specific `--help` may execute defaults in older scaffold versions. Use top-level `repo-wiki --help`, `npx repo-wiki --help`, package README/docs, or source inspection for exact options.
+- `lint-docs` warnings are currently advisory in the scaffold. `repo-wiki lint` / `npm run lint:local` is the required local wiki gate before publishing.
+- Publishing pushes to the GitHub Wiki repository. Only publish trusted local wiki output from a trusted branch/context.
+
+## Common commands
+
+Portable CLI form for any repository:
+
+```bash
+npx repo-wiki run --mode bootstrap --repo . --scan .llmwiki/run --plan .llmwiki/bootstrap-plan.json --wiki .llmwiki/wiki
+npx repo-wiki lint-docs --repo . --scan .llmwiki/run
+npx repo-wiki lint --wiki .llmwiki/wiki --scan .llmwiki/run
+npx repo-wiki publish --wiki .llmwiki/wiki --remote https://github.com/OWNER/REPO.wiki.git
+```
+
+Source-repository package scripts, useful while developing repo-wiki itself:
+
+```bash
+npm run build          # Compile TypeScript to dist/
+npm run check          # Build and run compiled tests
+npm run coverage       # Build and run coverage gate
+npm run self:wiki      # Bootstrap/regenerate this repo's local .llmwiki/wiki
+npm run lint:docs      # Validate ingested markdown documentation; warnings may be expected
+npm run lint:local     # Validate generated local wiki; must pass before publish
+npm run kb:publish     # Publish .llmwiki/wiki; requires LLMWIKI_PUBLISH_REMOTE or GITHUB_WIKI_REMOTE
+```
+
+## Regenerate the local wiki snapshot
+
+Use this when source/docs changed and the local generated wiki should reflect the current checkout.
+
+Portable form:
+
+```bash
+npx repo-wiki run --mode bootstrap --repo . --scan .llmwiki/run --plan .llmwiki/bootstrap-plan.json --wiki .llmwiki/wiki
+npx repo-wiki lint --wiki .llmwiki/wiki --scan .llmwiki/run
+```
+
+Source-repository package-script form:
+
+```bash
+npm run self:wiki
+npm run lint:local
+```
+
+Expected success signal from `repo-wiki lint` or `lint:local`:
+
+```json
+{
+  "errors": 0,
+  "warnings": 0
+}
+```
+
+If `lint:docs` reports warnings, inspect whether they are expected documentation-debt findings before treating them as blockers. Error-level findings should be fixed or explicitly escalated before publication.
+
+## Publish a GitHub Wiki
+
+Always use the external GitHub Wiki remote form in instructions and examples:
+
+```text
+https://github.com/OWNER/REPO.wiki.git
+```
+
+For this repository, that is:
+
+```text
+https://github.com/mfittko/repo-wiki.wiki.git
+```
+
+Portable publish workflow:
+
+```bash
+npx repo-wiki lint --wiki .llmwiki/wiki --scan .llmwiki/run
+npx repo-wiki publish --wiki .llmwiki/wiki --remote https://github.com/OWNER/REPO.wiki.git
+```
+
+Source-repository publish workflow while developing repo-wiki itself:
+
+```bash
+npm run lint:local
+LLMWIKI_PUBLISH_REMOTE=https://github.com/mfittko/repo-wiki.wiki.git npm run kb:publish
+```
+
+A successful publish returns JSON similar to:
+
+```json
+{
+  "status": "published",
+  "remote": "https://github.com/OWNER/REPO.wiki.git",
+  "branch": "master",
+  "pages": 37
+}
+```
+
+If the publish response is `skipped-no-remote`, rerun with `LLMWIKI_PUBLISH_REMOTE`, `GITHUB_WIKI_REMOTE`, or pass `--remote` directly to the CLI.
+
+## External repository bootstrap pattern
+
+For another repository, the public workflow is:
+
+```bash
+npx repo-wiki init --repo . --write-agents
+npx repo-wiki run --mode bootstrap --repo . --wiki .llmwiki/wiki
+npx repo-wiki publish --wiki .llmwiki/wiki --remote https://github.com/OWNER/REPO.wiki.git
+```
+
+Do not publish from untrusted pull requests. Prefer dry-run or local artifacts in CI unless publish credentials and event context are trusted.
+
+## Artifact map
+
+- `.llmwiki/run/` - scan artifacts, manifest, source cards, documentation cards.
+- `.llmwiki/bootstrap-plan.json` - bootstrap page plan.
+- `.llmwiki/incremental-plan.json` - incremental page plan.
+- `.llmwiki/wiki/` - generated local GitHub Wiki markdown.
+- `.llmwiki/schema.md` - schema and operating conventions for generated wiki maintenance.
+
+## Troubleshooting
+
+- If publish skips with no remote, set `LLMWIKI_PUBLISH_REMOTE=https://github.com/OWNER/REPO.wiki.git` or pass `--remote https://github.com/OWNER/REPO.wiki.git`.
+- If `lint:local` or `repo-wiki lint` fails, inspect the JSON `issues` array and fix generated wiki links, required pages, frontmatter, or secret-like content before publishing.
+- If package scripts fail because `dist/` is stale or absent, run `npm run build` or the package script again; most scripts already build first.
+- If local scans unexpectedly include `tmp/` worktrees or scratch directories, inspect source filtering configuration and scanner behavior before trusting the generated wiki.