Hive today targets teams at ACMM Level 3-4 — repos with CI, agents running 24/7. The goal is to make Hive useful starting from Level 1 (someone with an idea and no code), guiding them through the full developer journey to full automation. Along the way, a layered knowledge base (powered by llm-wiki) accumulates learnings, test patterns, and project-specific facts that compound over time — making agents smarter and automation safer at every level.
This design is informed by contrasting MetaSwarm (dsifry/metaswarm) with Hive. MetaSwarm's best idea — a self-improving knowledge base with automated extraction and selective priming — is adopted here. Its weakest idea — using more LLMs to verify LLM output — is replaced by Hive's existing deterministic pipeline approach, with testing as the primary trust mechanism instead of adversarial LLM review.
The container image includes a small Obsidian-compatible seed vault in src/deploy/data/wiki/. Current seed files are agents.md and getting-started.md; they introduce Hive agent roles, governor modes, beads, and the knowledge layer. Operators can extend these Markdown files in a derived image or mount/clone their own vault.
The image copies src/deploy/data/ to /opt/hive/seed-data/. At startup, deploy/entrypoint.sh copies missing seed files from there into /data/, so the wiki seed lands at /data/wiki/ without overwriting existing operator content. The entrypoint also prepares /data/vaults/hive-wiki; if HIVE_WIKI_GIT_URL is set and the vault is not already a git checkout, it clones that URL there, otherwise the local vault directory is created for the knowledge service to use. The seed files are intended as starter knowledge, not immutable product documentation: edit or replace them with project-specific runbooks, gotchas, and policies that should be available to agent priming.
Fixes #2924.
Evaluated three implementations. geronimo-iia/llm-wiki scored 39/40 — the clear winner:
- 23 MCP tools (vs 12 and 4 for alternatives)
- First-class multi-wiki via
wiki_spaces_create(no wrapper code needed) - BM25 search via tantivy with confidence-weighted ranking
- Single Rust binary, zero runtime deps (just needs
git) - HTTP transport (shared service, not per-client stdio)
- Auto-commits on ingest, redaction support
- MIT/Apache-2.0 licensed — can fork if needed
- Risk: single maintainer, 1 month old. Mitigated by license + pure Rust.
Knowledge flows DOWN automatically (community → personal). Knowledge flows UP only with explicit opt-in.
┌─────────────────────────────────────────────────┐
│ Community Wiki PUBLIC / READ-ONLY │
│ Hosted centrally (e.g., wiki.hive.dev) │
│ CNCF patterns, Go/React best practices │
│ Anyone can read, curated contributors write │
│ "Go operators need envtest" │
│ "Helm charts need values.schema.json" │
└──────────────────┬──────────────────────────────┘
│ MCP query (HTTP, cross-wiki)
┌──────────────────▼──────────────────────────────┐
│ Org Wiki SHARED / TEAM-SCOPED │
│ Hosted per-org (e.g., wiki.kubestellar.io) │
│ Or git-backed repo (hivecommons/hive-wiki) │
│ Org members read+write, outsiders read-only │
│ "ALWAYS use DCO signing" │
│ "isDemoData wiring is MANDATORY" │
└──────────────────┬──────────────────────────────┘
│ MCP query (HTTP or local)
┌──────────────────▼──────────────────────────────┐
│ Project Wiki SHARED / REPO-SCOPED │
│ Lives in .hive/wiki/ inside the repo │
│ Same access as the repo itself │
│ "vite.config.ts TS errors are IDE noise" │
│ "createMockCluster() lives in test/factory" │
└──────────────────┬──────────────────────────────┘
│ MCP query (local)
┌──────────────────▼──────────────────────────────┐
│ Personal Wiki PRIVATE / LOCAL-ONLY │
│ Lives on YOUR machine (~/.hive/wiki/) │
│ Your preferences, corrections, style │
│ NEVER leaves your machine. NEVER shared. │
│ Highest precedence — overrides all layers above │
│ "I prefer single bundled PRs" │
│ "Don't summarize at the end of responses" │
└──────────────────┬──────────────────────────────┘
│ all layers merged + filtered
┌──────────────────▼──────────────────────────────┐
│ knowledge-primer.sh (pipeline stage) │
│ Deterministic: queries MCP by file paths, │
│ filters by relevance, injects into work │
│ order sent to agent │
│ Precedence: personal > project > org > community│
└─────────────────────────────────────────────────┘
| Layer | Where it lives | Who can read | Who can write | Hosting |
|---|---|---|---|---|
| Personal | ~/.hive/wiki/ on user's machine |
Only you | Only you | Local llm-wiki instance (never networked) |
| Project | .hive/wiki/ in repo |
Anyone with repo access | Agents + Knowledge Curator | Local llm-wiki instance per worktree |
| Org | Dedicated git repo (e.g., hivecommons/hive-wiki) |
Org members | Promoted facts from project wikis | llm-wiki HTTP service (self-hosted or cloud) |
| Community | Public git repo or hosted service | Anyone | Curated contributors (PR-based) | llm-wiki HTTP service at wiki.hive.dev |
- Personal wiki never syncs — it stays on your machine, period. No telemetry, no upload, no "anonymous aggregation."
- Project wiki inherits repo visibility — private repo = private wiki. Public repo = public wiki.
- Promotion is always explicit — facts flow up (personal → project → org → community) only when a human or agent explicitly promotes them.
- Down-flow is automatic — community/org/project knowledge primes your agents automatically. You don't have to opt in to receive collective knowledge.
- Personal always wins — if your personal wiki says "use tabs" and the org wiki says "use spaces," your agents use tabs.
Personal fact
→ user runs: hive promote --to project "this is useful for the team"
→ fact appears in .hive/wiki/ with provenance: "promoted from personal by <user>"
Project fact (seen in 3+ repos across org)
→ knowledge curator proposes promotion
→ org maintainer approves (or auto-promote if confidence > 0.9)
→ fact appears in org wiki
Org fact (universal best practice)
→ maintainer opens PR to community wiki repo
→ community reviewers approve
→ fact available to all Hive users
| Capability | MetaSwarm JSONL | llm-wiki |
|---|---|---|
| Cross-referencing | Manual tags | [[wikilinks]] with backlinks |
| Querying | grep -i on files |
MCP semantic query ("gotchas for CardWrapper.tsx?") |
| Staleness detection | Weekly cron by curator agent | Built-in lint finds contradictions, orphans, stale claims |
| Multi-format | JSON only | HTML (humans), JSON-LD (structured), .txt (LLM context) |
| Version control | Flat files in repo | Git-backed with merge/diff/blame |
| Dashboard integration | None | HTML export renderable in Hive dashboard |
| Type | Example | Primed When |
|---|---|---|
| Pattern | "Use mock factories from test/factories.ts" |
Agent touches test files |
| Gotcha | ".join() on undefined crashes — guard with (arr || []).join()" |
Agent edits hook consumers |
| Decision | "State management uses Zustand + TanStack Query" | Agent adds new state |
| Regression | "PR #1281: .join() on undefined — test in useSearchIndex.test.ts" |
Agent edits useSearchIndex.ts |
| Test scaffold | "This project uses vitest + msw + testing-library" | Agent creates any test file |
| Integration | "envtest needs 30s timeout on CI, 10s locally" | Agent modifies controller tests |
| Coverage rule | "Cards using useCached* MUST have isDemoData test cases" |
Agent creates a new card |
Hive guides (not does) the work at lower levels, progressively increasing autonomy as the project matures.
What Hive does: Guides the user through project scaffolding.
- User describes what they want to build
- Hive queries community wiki for scaffolding patterns, CI templates, project structure
- Guides user through: repo creation → initial structure → first commit → basic CI
- Testing starts here: Hive guides user to write acceptance criteria as test stubs
test("should reconcile CRD when namespace is created")withTODObody- These define the contract — what "done" looks like — before any production code
- 0% coverage, 100% intent
- Knowledge: Community patterns only (no project-specific facts yet)
- Agents: None running. Hive is interactive/advisory.
What Hive does: Acts as reviewer/advisor, not autonomous.
- Hive reviews PRs on request (not auto-scanning)
- Flags PRs that add code without tests: "this handler has no test — want me to suggest one?"
- Testing: Tests alongside features, no hard gate
- Coverage trending up (tracked, not enforced)
- Test stubs from Level 1 get filled in as features land
- Community wiki primes test patterns: "Go operators need envtest", "React: use msw for API mocking"
- Knowledge accumulation begins:
- Knowledge Curator watches merged PRs, extracts gotchas and patterns
- Project wiki starts: "this repo uses controller-runtime v2", "webhook tests need envtest"
- User corrections ("no, we use X not Y") become high-confidence facts
- Agents: Scanner in advisory mode (suggests, doesn't act). No governor.
What Hive does: Scanner and reviewer active, governor in QUIET/IDLE mode.
- Scanner triages issues, creates fix PRs for simple bugs
- Reviewer monitors CI health, nightly tests, coverage trends
- Testing becomes a gate:
- Coverage thresholds enforced in CI (configurable, e.g., 70% lines)
- Thresholds ratchet up as project matures (never down)
- Scanner auto-creates issues when coverage drops below threshold
- Nightly integration tests catch service drift
- Knowledge is now rich:
- Org wiki contributes cross-repo patterns: "all kubestellar repos need Netlify preview deploys"
- Project wiki has dozens of facts from merged PRs
- Regression patterns accumulate: "changing webhook port breaks envtest — update
testenv.Environment.WebhookInstallOptions"
- Agents: Scanner + reviewer. Governor in QUIET/IDLE. Architect opportunistic.
What Hive does: Governor scales dynamically, all agents active.
- Full Hive deployment: scanner, reviewer, architect, outreach, supervisor
- Governor adjusts cadences and models by queue depth (SURGE/BUSY/QUIET/IDLE)
- Testing is what makes autonomy safe:
- Full TDD: every bug fix reproduces the bug in a test first (red), then fixes (green)
merge-gate.shrequires green CI — deterministic, not LLM-verified- Regression tests accumulate automatically from every bug fix
- Coverage thresholds are high and enforced (e.g., 90%+ lines)
- The test suite is the trust mechanism — not "an LLM reviewed another LLM's code"
- Knowledge compounds:
- All three wiki layers active, merged at prime time
- Knowledge Curator extracts from every merged PR across all repos
- Lessons from this project feed back into org layer (and optionally community)
- Agents get smarter without any human intervention
- Agents: All 5. Governor active. Auto-deploy. Dashboard monitoring.
| Level | Test Approach | Coverage Gate | Who Writes Tests | Trust Model |
|---|---|---|---|---|
| 1 — Inception | Acceptance criteria as test stubs (TODO bodies) |
None | User (guided by Hive) | Human judgment |
| 2 — Advisory | Tests alongside features, no hard gate | Tracked, not enforced | User + Hive suggests | Human review + test results |
| 3 — Quality-Gated | Coverage threshold in CI, nightly integration | 70%+ (ratcheting) | User + scanner fixes include tests | CI pass = trust |
| 4 — Security-Aware | Full TDD, regression on every bug fix | 90%+ enforced | Agents (scanner, architect) | Green test suite = trust |
Bug found
→ Test written to reproduce (red)
→ Fix applied (green)
→ Knowledge Curator extracts pattern
→ Wiki updated: "guard .join() against undefined in hook consumers"
→ Next agent touching that area gets primed with the gotcha
→ Writes the guard AND the test proactively
The wiki stores test patterns alongside code patterns:
- Test scaffolding: "This project uses vitest + msw + testing-library" → primed when agent creates any test file
- Mock patterns: "Use
createMockCluster()fromtest/factories.ts, not inline mocks" → primed when agent touches test files - Regression markers: "PR #1281 crashed because
.join()on undefined — regression test inuseSearchIndex.test.ts" → primed when agent editsuseSearchIndex.ts - Integration gotchas: "envtest needs 30s timeout on CI, 10s locally" → primed when agent modifies controller tests
- Coverage rules: "Cards using
useCached*hooks MUST have isDemoData test cases" → primed when agent creates a new card component
Just as the governor adapts model selection by queue depth, it adapts test requirements by project maturity:
ACMM Level 1-2: testMode = "suggest"
→ Hive suggests tests, doesn't block without them
ACMM Level 3: testMode = "gate"
→ CI blocks merges below coverage threshold
→ Scanner creates issues for coverage drops
ACMM Level 4: testMode = "tdd"
→ Agents must write failing test before fix (red-green)
→ Merge gate requires green suite + coverage threshold
→ Regression test required for every bug fix
Hive is a Go binary with structured packages under src/pkg/. The knowledge system adds a new pkg/knowledge/ package and extends existing packages.
src/pkg/knowledge/
client.go — llm-wiki MCP HTTP client (query, search, ingest, lint, spaces)
primer.go — Selective fact retrieval by file paths, keywords, work type
bead_synthesizer.go — Synthesize facts from beads (replaced curator.go's merged-PR mining, #5786)
promote.go — Promote facts between layers (project→org, etc.)
types.go — Fact, Layer, WikiConfig, ConfidenceScore, Precedence types
client_test.go
primer_test.go
bead_synthesizer_test.go
promote_test.go
| Package | Integration |
|---|---|
pkg/config/ |
Add Knowledge section to hive.yaml (layers, wiki paths, curator schedule, primer config) |
pkg/snapshot/ |
Add Knowledge []Fact field to snapshot state — primed facts per work item |
pkg/classify/ |
After classification, call knowledge.Primer.Prime(item) to enrich with relevant facts |
pkg/governor/ |
Add test maturity level to governor decisions; adapt agent directives by ACMM level |
pkg/scheduler/ |
Add curator schedule (daily or on-merge trigger) |
pkg/dashboard/ |
Add /api/knowledge/* endpoints proxying to llm-wiki MCP; Knowledge tab in frontend |
pkg/agent/ |
Include primed facts in agent work orders |
The pipeline is Go code, not shell scripts:
snapshot.Build()
→ classify.Classify(items) // existing: complexity tier, lane, model rec
→ knowledge.Prime(items, layers) // NEW: query wiki by file paths, merge layers
→ scheduler.Dispatch(items) // existing: send to agents with enriched snapshot
The primer runs deterministically — Go HTTP client queries llm-wiki, filters by file paths, no LLM in the loop.
scheduler.RunCurator(schedule)
→ github.FetchMergedPRs(since) // existing GitHub client
→ knowledge.Extract(prs) // NEW: parse diffs, review comments, CI results
→ knowledge.Ingest(facts, wiki) // NEW: call llm-wiki MCP ingest endpoint
The curator uses an LLM (via llm-wiki's synthesis layer) for knowledge extraction only — not for enforcement or gating.
knowledge:
enabled: true
engine: "llm-wiki" # geronimo-iia/llm-wiki (Rust)
layers:
- type: personal
path: "~/.hive/wiki"
shared: false # NEVER syncs, NEVER leaves machine
precedence: 1 # highest — overrides all others
- type: project
path: ".hive/wiki"
shared: true # inherits repo visibility
precedence: 2
- type: org
url: "https://wiki.kubestellar.io/mcp" # or local git repo
shared: true
precedence: 3
- type: community
url: "https://wiki.hive.dev/mcp" # public, read-only
shared: true
precedence: 4 # lowest — overridden by all others
curator:
auto_promote_threshold: 0.9 # confidence to auto-promote project→org
primer:
max_facts: 25
priority: ["regression", "gotcha", "test_scaffold", "pattern", "decision"]
merge_strategy: "precedence" # personal > project > org > communityFiles to create/modify in src/:
-
src/pkg/knowledge/types.go— Core typesFact,Layer,LayerType,WikiConfig,ConfidenceScorePrimerConfig,CuratorConfig,PromoteRequest
-
src/pkg/knowledge/client.go— llm-wiki MCP HTTP clientSearch(query, filters),Read(slug),Ingest(facts),Lint(),Stats()SpacesList(),SpacesCreate(name, path)- Connects to llm-wiki HTTP endpoint (configurable per layer)
- Falls back gracefully if wiki unavailable
-
src/pkg/knowledge/primer.go— Selective fact primingPrime(items []WorkItem, layers []Layer) []EnrichedItem- Queries each layer by file paths, keywords, work type
- Merges results with precedence (personal > project > org > community)
- Filters to top N facts by priority order
-
src/pkg/knowledge/bead_synthesizer.go— Knowledge extraction- Synthesizes facts from beads and ingests them via llm-wiki
wiki_ingest - The original
curator.gomerged-PR comment-mining pipeline was never wired to a production caller and was removed in #5786
- Synthesizes facts from beads and ingests them via llm-wiki
-
src/pkg/config/— AddKnowledgefield to config struct, parse fromhive.yaml -
src/pkg/snapshot/state.go— AddKnowledge []Factto snapshot state -
src/pkg/dashboard/server.go— Add knowledge API endpoints (proxying to llm-wiki MCP) -
Tests —
client_test.go,primer_test.go,curator_test.gowith mock llm-wiki server
-
Existing ACMM advisory/governor signals — test progression inputs
- Reuse the current maturity evaluation pipeline instead of adding a separate knowledge-package detector.
-
src/pkg/governor/governor.go— Add test maturity to governor logic- Governor reads maturity level from snapshot
- Adjusts agent directives: suggest (L1-2) → gate (L3) → tdd (L4)
-
src/policies/— Template variables for test mode per maturity level
-
src/pkg/knowledge/promote.go— Fact promotion between layersPromote(fact, fromLayer, toLayer)— copies with provenance- Auto-promote when confidence > threshold AND seen in 3+ repos
-
Org wiki deployment — Docker Compose service or standalone llm-wiki HTTP instance
-
Community wiki — Hosted service (future, separate infrastructure)
The Hive dashboard gets a new Knowledge tab — the primary UI for users to browse, search, and manage their wikis.
┌──────────────────────────────────────────────────────────────────┐
│ Hive Dashboard │
│ [Agents] [Governor] [Health] [Knowledge] [Settings] │
├──────────────────────────────────────────────────────────────────┤
│ │
│ Layer Switcher │ Page View │
│ ┌─────────────────────┐ │ ┌──────────────────────────────┐ │
│ │ 🔒 Personal (12) │ │ │ guard-join-undefined │ │
│ │ 📁 Project (47) │ │ │ │ │
│ │ 🏢 Org (89) │ │ │ Type: gotcha │ │
│ │ 🌍 Community (340) │ │ │ Confidence: ████████░░ 0.95 │ │
│ └─────────────────────┘ │ │ Status: verified │ │
│ │ │ Layer: project │ │
│ Search: [________________] │ │ │ │
│ │ │ `.join()` on undefined │ │
│ Filter: [All types ▼] │ │ crashes. Always use │ │
│ │ │ `(arr || []).join(',')`. │ │
│ Facts (sorted by relevance) │ │ │ │
│ ┌─────────────────────┐ │ │ ── Sources ────────────── │ │
│ │ ● guard-join-undef… │ │ │ PR #1281 (2026-03-15) │ │
│ │ gotcha · 0.95 │ │ │ PR #1455 (2026-04-02) │ │
│ │ project · 14 uses │ │ │ │ │
│ ├─────────────────────┤ │ │ ── Related ────────────── │ │
│ │ ○ isDemoData-wiring │ │ │ [[isDemoData-wiring]] │ │
│ │ pattern · 0.92 │ │ │ [[hook-undefined-guard]] │ │
│ │ project · 9 uses │ │ │ │ │
│ ├─────────────────────┤ │ │ ── Override Status ──────── │ │
│ │ ○ dco-signing │ │ │ No personal override │ │
│ │ decision · 1.00 │ │ │ │ │
│ │ org · 31 uses │ │ │ Last primed: 2 days ago │ │
│ └─────────────────────┘ │ │ Usage count: 14 │ │
│ │ │ │ │
│ Health │ │ [Promote to Org] [Archive] │ │
│ ⚠️ 3 stale (>90 days) │ │ [Override (Personal)] │ │
│ ⚠️ 1 orphaned │ │ [View in Graph] │ │
│ ✅ 0 contradictions │ │ │ │
└──────────────────────────────┴──────────────────────────────────┘
11a. Layer switcher
- Toggle between Personal / Project / Org / Community
- Lock icon on Personal (visual reminder: private)
- Fact counts per layer
- "All layers" view merges with precedence indicators
11b. Unified search
- BM25 search across all subscribed layers via llm-wiki MCP
wiki_search - Results tagged with source layer and confidence
- Filter by type (pattern/gotcha/regression/test_scaffold/decision/integration/coverage_rule)
- Filter by status (draft/verified/stale/archived)
11c. Fact detail view
- Full markdown content rendered
- Confidence bar (visual 0.0-1.0)
- Source provenance: which PRs, which review comments, when extracted
- Wikilinks to related facts (clickable, navigate within dashboard)
- Override indicator: "Your personal wiki overrides this org fact" with diff view
- Usage stats: how many times agents were primed with this fact, when last used
- Actions: Promote (to higher layer), Archive, Override (create personal copy), View in Graph
11d. Graph view
- Toggle from list view to wikilink graph (Mermaid rendered via llm-wiki
wiki_graph) - Nodes colored by layer (blue=personal, green=project, orange=org, purple=community)
- Node size by usage count
- Click node to navigate to fact detail
- Filter graph by type, layer, or search term
11e. Health panel (sidebar)
- Stale facts: unreferenced >90 days (click to review batch)
- Orphaned pages: no inbound wikilinks (suggest linking or archiving)
- Contradictions: conflicting facts detected by
wiki_lint(click to resolve) - Coverage trend: graph of project test coverage over time
- Test maturity: current ACMM level indicator (1-4) with criteria checklist
11f. Subscription management (under Settings tab)
- List of subscribed org/community wiki URLs
- Add/remove wiki endpoints
- Per-project layer toggle: enable/disable specific layers
- Personal wiki path (defaults to
~/.hive/wiki/)
GET /api/knowledge # List facts across layers (paginated, filterable)
GET /api/knowledge/:layer # List facts in specific layer
GET /api/knowledge/:layer/:slug # Read single fact with metadata
GET /api/knowledge/search?q=&type= # BM25 search across subscribed layers
GET /api/knowledge/graph?root=&depth= # Wikilink graph (Mermaid/JSON)
GET /api/knowledge/health # Stale/orphan/contradiction counts
GET /api/knowledge/stats # Aggregate stats (counts by type, layer, confidence)
POST /api/knowledge/promote # Promote fact to higher layer
POST /api/knowledge/archive # Archive a fact
POST /api/knowledge/override # Create personal override of a fact
GET /api/knowledge/subscriptions # List subscribed wiki endpoints
POST /api/knowledge/subscriptions # Add/remove subscription
All endpoints proxy to llm-wiki MCP tools. Dashboard auth (bearer token) applies to mutations.
- Set up llm-wiki MCP server locally against a test project
- Run
knowledge-primer.shand confirm it produces enrichedactionable.jsonwith relevant facts - Run
knowledge-curator.shagainst recent merged PRs and confirm facts are extracted and ingested - Verify pipeline runs end-to-end: enumerate → classify → prime → kick
- Verify agents receive knowledge in their work orders
- Create test projects at each maturity level (1-4)
- Run
test-maturity.shand confirm correct level detection - Verify governor adjusts test directives by level
- Verify scanner behavior changes: suggests (L2) vs gates (L3) vs TDD (L4)
- Stand up org wiki, push facts from project curator
- Verify
knowledge-primer.shmerges layers correctly (personal > project > org > community) - Verify org-level facts appear in agent work orders
- Verify personal overrides take precedence in merged results
- Dashboard Knowledge tab renders with all four layers
- Search returns results across layers with correct precedence
- Fact detail view shows provenance, wikilinks, usage stats
- Promote/Archive/Override actions work end-to-end
- Graph view renders wikilink connections across layers
- Health panel shows stale/orphan/contradiction counts from
wiki_lint - Subscription management adds/removes wiki endpoints
- llm-wiki implementation —
geronimo-iia/llm-wiki(Rust). 39/40 score. First-class multi-wiki, BM25 search, git-backed, HTTP transport. Single binary, zero deps. - Knowledge layers — Four layers (personal/project/org/community), not three. Personal wiki is private, local-only, highest precedence.
- Privacy model — Down-flow automatic, up-flow explicit. Personal never shared. Project inherits repo visibility.
- Rust 1.95 requirement — Our machine has 1.87. Need to install via rustup or use Homebrew nightly. Or use the prebuilt binary / Homebrew tap (
brew install geronimo-iia/tap/llm-wiki). - Community wiki seeding — What initial content? CNCF TAG guidelines? Extracted from top 100 CNCF project READMEs? Start empty and let it grow?
- Knowledge curation approval — Auto-extracted facts go to project wiki at confidence < 0.9. Auto-promote to org wiki at confidence >= 0.9. Human approval for community wiki (PR-based).
- Cross-project fact promotion — Automatic when seen in 3+ repos AND confidence > 0.9. Otherwise manual.
- Personal wiki bootstrapping — Should
hive initcreate a personal wiki from Claude Code's existing memory files? (e.g., migrate~/.claude/projects/*/memory/→~/.hive/wiki/)