eno-mcp 0.1.0__tar.gz

eno_mcp-0.1.0/.gitignore

@@ -0,0 +1,18 @@
+__pycache__/
+*.pyc
+.venv/
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+*.egg-info/
+dist/
+build/
+.somm/
+.claude/worktrees/
+.playwright-mcp/
+.env
+
+# obsidian plugin build artifacts (when packages/eno-plugin/ lands)
+node_modules/
+packages/eno-plugin/main.js
+packages/eno-plugin/*.zip

eno_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: eno-mcp
+Version: 0.1.0
+Summary: eno-mcp — MCP stdio server exposing the vault's read tools to coding agents
+License: MIT
+Requires-Python: >=3.12
+Requires-Dist: enowiki==0.1.0
+Requires-Dist: mcp>=1.2

eno_mcp-0.1.0/README.md

@@ -0,0 +1,126 @@
+# eno-mcp
+
+MCP stdio server exposing eno's read + write tools to coding agents and
+autonomous agents (Claude Code, Cursor, anything that speaks MCP).
+
+## Tools
+
+Read:
+- `eno_search` — find notes by title or tag
+- `eno_note` — frontmatter + headings + ~400-char excerpt for one note
+- `eno_neighbors` — backlinks + outbound for one note
+- `eno_orphans` — notes with no inbound links (resurfacing)
+- `eno_stubs` — short notes with no outbound links
+- `eno_stale` — notes past a recency threshold
+- `eno_broken_links` — raw broken wikilinks (use eno_concepts / eno_drift instead for classified output)
+- `eno_concepts` — incipient wikilinks (groundwork for not-yet-written notes)
+- `eno_drift` — drift candidates (almost-matches, real bugs)
+- `eno_hygiene` — frontmatter contract violations
+- `eno_health` — diagnostic
+
+Write:
+- `eno_create_note` — create a note; frontmatter auto-populated with `origin: llm` + `author: '[[X]]'`
+- `eno_append_to_note` — append content, optionally under a specific heading
+
+## Wiring it into an MCP agent
+
+Many autonomous agents load MCP servers natively. Two pieces:
+
+**1. Onboarding skill.** Drop the agent brief into a place the agent
+loads from at startup (skill directory, system prompt path, etc.).
+
+```sh
+# Whichever of these matches your agent's setup:
+cp packages/eno-mcp/skills/agent-onboarding.md \
+   ~/.config/my-agent/skills/
+
+# or, if you sync skills via the vault:
+cp packages/eno-mcp/skills/agent-onboarding.md \
+   /path/to/vault/.eno/skills/
+```
+
+The onboarding brief covers the postures (resurfacing > collecting,
+incipient links are intentional, two-phase reads), the tool inventory,
+and common patterns. Self-contained. Read it yourself before deploying
+— it's the contract
+the agent will operate under.
+
+**2. MCP config.** Add eno-mcp to the agent's MCP config — typically
+`~/.config/my-agent/mcp.json` or whatever your install expects.
+
+```json
+{
+  "mcpServers": {
+    "eno": {
+      "command": "uv",
+      "args": [
+        "run",
+        "--directory",
+        "/path/to/eno",
+        "eno-mcp"
+      ],
+      "env": {
+        "ENO_VAULT_DIR": "/path/to/vault",
+        "ENO_AGENT_NAME": "Weaver"
+      }
+    }
+  }
+}
+```
+
+Or, if you prefer the agent to talk to a long-running `eno-serve` daemon
+on dash-main (so multiple agents share one index):
+
+```json
+{
+  "mcpServers": {
+    "eno": {
+      "command": "uv",
+      "args": ["run", "--directory", "/path/to/eno", "eno-mcp"],
+      "env": {
+        "ENO_SERVICE_URL": "http://dash-main:7891",
+        "ENO_AGENT_NAME": "Weaver"
+      }
+    }
+  }
+}
+```
+
+`ENO_AGENT_NAME=Weaver` is what makes new notes get
+`author: '[[Weaver]]'` automatically — the AGENTS.md convention that
+keeps provenance legible without per-call ceremony.
+
+## Wiring it into other agents
+
+Claude Code (project-level): the repo's own `.mcp.json` already wires
+this for sessions opened inside `/eno`. To get it in every Claude Code
+session, copy that snippet into `~/.claude/.mcp.json`.
+
+Other MCP-compatible agents (Cursor, openclaw, custom): same shape —
+spawn `eno-mcp` over stdio with the env vars above.
+
+## Backend choice
+
+The server picks a backend at runtime:
+- `$ENO_SERVICE_URL` set → ServiceBackend (HTTP to a running `eno-serve`)
+- otherwise → LocalBackend (direct sqlite at `$ENO_VAULT_DIR/.eno/index.db`)
+
+Single-host work: omit `ENO_SERVICE_URL`, set `ENO_VAULT_DIR`. Multi-host
+fleet: run `eno-serve` on dash-main and point all workstation agents at
+it via `ENO_SERVICE_URL`.
+
+## Two postures encoded in the tool docstrings
+
+Every tool's docstring is the description an agent sees. Two postures
+are deliberately repeated across tools and worth keeping in mind when
+extending:
+
+1. **Resurfacing > collecting.** Orphans, stale notes, and concept
+   candidates are framed as opportunities, not errors. Tools never tell
+   the agent to "fix" or "clean up" these.
+2. **Incipient links are intentional.** `eno_broken_links` returns raw
+   data; `eno_concepts` separates intentional groundwork from drift.
+   Agents must never describe concepts as broken-link bugs.
+
+If you add a tool that touches link integrity or vault structure, match
+this framing.

eno_mcp-0.1.0/hooks/README.md

@@ -0,0 +1,62 @@
+# Hot-cache hooks
+
+Optional Claude Code hook bundle for projects that want eno's
+"what's hot" bundle injected at session start (and after compaction).
+
+The pattern is borrowed from
+[claude-obsidian](https://github.com/AgriciDaniel/claude-obsidian)'s
+`wiki/hot.md` SessionStart trick — but in eno's version the hot bundle
+is **derived live** from the index by `eno hot`, not written to a
+file. So there's no cache file to keep current; every read is fresh.
+
+## What gets injected
+
+`eno hot` emits markdown with four sections:
+
+1. **Frontier** — pages with high outward reach, low inbound, recently
+   touched. Where you're currently pulling threads.
+2. **Recent appends** — notes whose mtime is within 7 days, newest
+   first.
+3. **Top incipient concepts** — wikilinks the user has gestured at
+   across multiple notes (durable themes, *not* broken links).
+4. **Recent agent contributions** — notes the agent itself authored
+   within 14 days, when `--agent NAME` is provided.
+
+## Install (Claude Code)
+
+1. Edit `hot-cache-hooks.json` and replace `/CHANGE_ME/path/to/eno`
+   with the absolute path to this repo on your machine.
+2. Merge the `hooks` key into `~/.claude/settings.json`. If you
+   already have hooks in there, append these inside the existing
+   `hooks` object (don't overwrite siblings).
+3. Make sure the agent's MCP config exports both env vars
+   (eno-mcp's README has the canonical example):
+   - `ENO_VAULT_DIR=/path/to/vault`
+   - `ENO_AGENT_NAME=Weaver` (or whatever the agent calls itself)
+
+When the hook fires, it runs `eno hot --agent $ENO_AGENT_NAME`. The
+guard `[ -n "${ENO_VAULT_DIR:-}" ] && ... || true` means the hook
+is a no-op (exit 0) in non-eno sessions — safe to install globally.
+
+## Non-Claude-Code agents
+
+Some agents load MCP servers natively but don't honor Claude Code hooks.
+For those, the equivalent is the **session-start protocol** documented
+in `packages/eno-mcp/skills/agent-onboarding.md`: call `eno_hot`
+yourself at the start of every session. The skill brief covers the
+when, why, and what to do with the result.
+
+## Why no Stop hook
+
+The upstream `wiki/hot.md` pattern includes a Stop hook that prompts
+the agent to overwrite `hot.md` with a session summary. Eno doesn't
+need this:
+
+- Durable session output flows through `eno_create_note` and
+  `eno_append_to_note`, both of which stamp `author: '[[Agent]]'`
+  in frontmatter. Provenance is automatic.
+- The next session's `eno hot` re-derives `agent_recent` from those
+  same notes, so the contribution trail is always live.
+
+If you want a per-session log on top of that, add it as a separate
+hook — but it's orthogonal to hot-cache.

eno_mcp-0.1.0/hooks/hot-cache-hooks.json

@@ -0,0 +1,28 @@
+{
+  "_comment": "Drop the `hooks` key into ~/.claude/settings.json (or a project-level settings file) for any Claude Code project that has eno-mcp wired up. Two hooks: SessionStart injects 'eno hot' at conversation start; PostCompact re-injects after compaction (hook-injected context does NOT survive compaction — only CLAUDE.md does). Stop is intentionally omitted: in eno, durable session output flows through eno_create_note / eno_append_to_note (provenance via author=[[<agent>]]), so there's no hot.md to overwrite. The 'eno hot' command always derives fresh from the index, so there's no staleness risk.",
+  "_assumptions": "ENO_VAULT_DIR points at the Obsidian vault. ENO_AGENT_NAME is the agent's name as it appears in note frontmatter author fields (e.g. Weaver). Both must already be set in the agent's environment (the eno-mcp config sets them — see packages/eno-mcp/README.md). The eno repo absolute path below MUST be edited to match your install.",
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup|resume",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "[ -n \"${ENO_VAULT_DIR:-}\" ] && uv --directory /CHANGE_ME/path/to/eno run eno --vault \"$ENO_VAULT_DIR\" hot --agent \"${ENO_AGENT_NAME:-}\" 2>/dev/null || true"
+          }
+        ]
+      }
+    ],
+    "PostCompact": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "[ -n \"${ENO_VAULT_DIR:-}\" ] && uv --directory /CHANGE_ME/path/to/eno run eno --vault \"$ENO_VAULT_DIR\" hot --agent \"${ENO_AGENT_NAME:-}\" 2>/dev/null || true"
+          }
+        ]
+      }
+    ]
+  }
+}

eno_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "eno-mcp"
+version = "0.1.0"
+description = "eno-mcp — MCP stdio server exposing the vault's read tools to coding agents"
+requires-python = ">=3.12"
+license = { text = "MIT" }
+dependencies = [
+    "enowiki==0.1.0",  # the core package (imports as `eno`)
+    "mcp>=1.2",
+]
+
+[project.scripts]
+eno-mcp = "eno_mcp.cli:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/eno_mcp"]

eno_mcp-0.1.0/skills/agent-onboarding.md

@@ -0,0 +1,136 @@
+---
+title: Agent onboarding for eno
+type: skill
+audience: any MCP agent
+---
+
+# Agent onboarding for eno
+
+You are running with the **eno** MCP server attached. eno is the structural
+intelligence layer for an Obsidian-style markdown vault: it indexes the vault
+and exposes it as a queryable surface so you can ground your work in what's
+already written instead of grepping and reading whole files. Read this once,
+internalize the postures, and operate from them.
+
+## Session start protocol
+
+**First action of every session: call `eno_hot`.** Pass `agent_name` (or read
+`$ENO_AGENT_NAME`). It returns four signals derived live from the index:
+
+- `frontier` — pages reaching outward (high out-degree, low in-degree,
+  recently touched). Active threads with momentum.
+- `recent_appends` — notes touched in the last 7 days. Active surfaces,
+  regardless of graph shape.
+- `top_concepts` — durable themes gestured at via incipient wikilinks
+  (**not** bugs — see posture 2).
+- `agent_recent` — your own contributions in the last 14 days, so you
+  remember what *you* built before the user has to remind you.
+
+Internalize this as recent context. Don't announce it or dump it back at the
+user. Just have it available.
+
+**After context compaction**: call `eno_hot` again. Hook-injected context
+doesn't survive compaction in most agent harnesses; only explicitly-loaded
+skill files do. Re-derive on demand.
+
+## Three postures (non-negotiable)
+
+### 1. Ground in the vault before generating
+
+The vault already holds research, notes, and frameworks. Your highest-leverage
+move is finding material that already exists — not generating fresh content
+from training-data priors. When the user asks about something, your first
+action is `eno_search` or `eno_note`, not a blank page.
+
+### 2. Incipient links are opportunities, not broken links
+
+Authors deliberately write wikilinks like `[[Mechanism Design]]` *before*
+creating the target note — it's how conceptual groundwork gets laid.
+`eno_concepts` surfaces these. A high-mention-count concept with no note yet is
+often a page waiting to be written. **Never** frame concept candidates as
+"broken links to fix."
+
+The actual link-bug class is `eno_drift` — wikilinks that *almost* match an
+existing note (em-dash vs hyphen, casing, trailing punctuation) and silently
+don't resolve. Those are real cleanup candidates, and those you can call bugs.
+
+### 3. Two-phase reads, always
+
+Tools return paths + small excerpts (~1KB) by default. To go deeper, call
+`eno_note` on the specific path. Don't read whole files until you've scoped
+which file actually matters. Frontmatter + headings + a 400-char excerpt
+answers most questions without burning budget on full bodies.
+
+## Tool inventory
+
+**Read (cheap, no LLM behind them):**
+- `eno_hot(agent_name?)` — session-start bundle. Call first.
+- `eno_search(query, kind=title|tag)` — find by title substring or tag
+- `eno_note(path)` — frontmatter + headings + ~400-char excerpt
+- `eno_neighbors(path)` — backlinks + outbound; map the neighborhood
+- `eno_frontier(folder?, halflife_days?)` — active outward-reaching pages
+- `eno_orphans(folder?, min_words?)` — substantive notes nothing links to
+- `eno_concepts()` — incipient wikilinks (groundwork, *not* bugs)
+- `eno_drift()` — drift candidates (almost-matches; real bugs)
+- `eno_stale(older_than_days?)` — notes past a recency threshold
+- `eno_stubs()` — short notes with no outbound links
+- `eno_hygiene()` — frontmatter contract violations
+- `eno_health()` — diagnostic only
+
+**Body-content analysis (requires the `enowiki[llm]` extra):**
+- `eno_tiling(...)` — semantic dedup. Before writing on a topic, check
+  whether similar material already exists across notes.
+
+**Folds (synthesized rollups; `eno fold` is CLI-only, deliberate human ops):**
+- Read committed folds via `eno_note("9 Vault Health/folds/<id>")` and find
+  them with `eno_search("fold-", kind="title")`. Folds are dense summaries of a
+  time range or topic — often the best starting point for a brief.
+
+**Write (mutate the vault):**
+- `eno_create_note(path, body, title?, overwrite?, author?)` — create a
+  durable note. Refuses to overwrite by default.
+- `eno_append_to_note(path, content, under_heading?)` — extend an existing
+  note rather than creating a sibling duplicate.
+
+## Common patterns
+
+**"What's active right now?"** → `eno_hot`, then `eno_concepts`, then
+`eno_note` on the candidates; surface the 2-3 most relevant with a one-line
+why.
+
+**"Write about X"** → `eno_search(X)` → `eno_note` + `eno_neighbors` to map
+context → read a relevant fold if one exists → write, wikilinking to the source
+material.
+
+**"What substantial material is buried?"** → `eno_orphans(min_words=1000)` +
+`eno_stale(older_than_days=90)` → `eno_note` each to check density.
+
+**"Did I already cover this?"** → `eno_tiling` for near-duplicates +
+`eno_search` by title before creating anything new.
+
+## What NOT to do
+
+- Don't generate from training-data priors when the vault has the material.
+  Search first.
+- Don't write into `.eno/`, `.git/`, `.obsidian/`, or `.trash/` (the safety
+  net rejects these).
+- Don't frame `eno_concepts` results as "broken links to fix" — they're
+  candidates, not bugs.
+- Don't overwrite notes silently — `eno_create_note` refuses by default; use
+  `eno_append_to_note` to extend.
+- Don't omit the `author` field on notes you create (it's auto-stamped from
+  `$ENO_AGENT_NAME` — just don't override it away). This keeps machine-written
+  pages distinguishable from the human's.
+- Don't read full file bodies via filesystem tools when `eno_note` gives you a
+  structured ~1KB summary.
+
+## Self-check before any write
+
+1. Did I search first? (`eno_search`, `eno_concepts`)
+2. Is there a canonical note this belongs in? (extend, don't duplicate)
+3. Does the path land in a sensible folder for its primary intent?
+4. Are my wikilinks pointing at notes that exist (or incipient on purpose)?
+5. Will `author` be set automatically? (yes, if `$ENO_AGENT_NAME` is set —
+   check `eno_health`)
+
+If any answer is uncertain, prefer surfacing to the user over writing.

eno_mcp-0.1.0/src/eno_mcp/__init__.py

@@ -0,0 +1,3 @@
+"""eno-mcp — MCP stdio server exposing eno's read tools to coding agents."""
+
+__version__ = "0.1.0"

eno_mcp-0.1.0/src/eno_mcp/cli.py

@@ -0,0 +1,25 @@
+"""`eno-mcp` — stdio MCP entrypoint.
+
+No args. Backend choice via env: $ENO_SERVICE_URL → ServiceBackend (talks to
+eno-serve); else $ENO_VAULT_DIR → LocalBackend (reads .eno/index.db directly).
+
+Configure in `.mcp.json`:
+
+    {"mcpServers": {"eno": {"command": "uv", "args": ["run", "eno-mcp"]}}}
+"""
+
+from __future__ import annotations
+
+import sys
+
+
+def main(argv: list[str] | None = None) -> int:
+    from eno_mcp.server import build_server
+
+    server = build_server()
+    server.run()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

eno_mcp-0.1.0/src/eno_mcp/server.py

@@ -0,0 +1,45 @@
+"""FastMCP server — wires tool functions onto the MCP protocol."""
+
+from __future__ import annotations
+
+from mcp.server.fastmcp import FastMCP
+
+from eno_mcp.tools import (
+    eno_append_to_note,
+    eno_broken_links,
+    eno_concepts,
+    eno_create_note,
+    eno_drift,
+    eno_frontier,
+    eno_health,
+    eno_hot,
+    eno_hygiene,
+    eno_neighbors,
+    eno_note,
+    eno_orphans,
+    eno_search,
+    eno_stale,
+    eno_stubs,
+    eno_tiling,
+)
+
+
+def build_server() -> FastMCP:
+    server = FastMCP("eno")
+    server.tool()(eno_search)
+    server.tool()(eno_note)
+    server.tool()(eno_neighbors)
+    server.tool()(eno_orphans)
+    server.tool()(eno_stubs)
+    server.tool()(eno_stale)
+    server.tool()(eno_broken_links)
+    server.tool()(eno_concepts)
+    server.tool()(eno_drift)
+    server.tool()(eno_frontier)
+    server.tool()(eno_hot)
+    server.tool()(eno_tiling)
+    server.tool()(eno_hygiene)
+    server.tool()(eno_create_note)
+    server.tool()(eno_append_to_note)
+    server.tool()(eno_health)
+    return server

eno_mcp-0.1.0/src/eno_mcp/tools.py

@@ -0,0 +1,582 @@
+"""MCP tool implementations.
+
+Plain functions — registered with FastMCP in server.py. Docstrings ARE the tool
+descriptions the agent sees, so prioritize *when* to use the tool over *how* it
+works internally. Returns are jsonable dicts; on failure, return {"error", "hint"}
+rather than raising — gives the agent something actionable.
+"""
+
+from __future__ import annotations
+
+from dataclasses import asdict, is_dataclass
+from typing import Any
+
+from eno.backend import ServiceBackend, make_backend
+from eno.client import ClientError
+from eno.config import index_path
+
+_BACKEND_HINT = (
+    "set $ENO_SERVICE_URL to a running eno-serve, or $ENO_VAULT_DIR to a vault "
+    "path (will use the local .eno/index.db; run `eno index` first)"
+)
+
+
+def _to_dict(obj: Any) -> Any:
+    if obj is None:
+        return None
+    if is_dataclass(obj):
+        return asdict(obj)
+    if isinstance(obj, list):
+        return [_to_dict(o) for o in obj]
+    return obj
+
+
+def _err(e: Exception, hint: str = _BACKEND_HINT) -> dict[str, Any]:
+    return {"error": str(e), "hint": hint}
+
+
+def eno_search(
+    query: str, kind: str = "title", limit: int = 20
+) -> dict[str, Any]:
+    """Find notes in the vault by title substring or tag exact-match.
+
+    Use this when the user asks about something they "have a note on" or
+    when you want to ground a question in what they've already written.
+    Cheap — index-only, no llm. Always try this before reading files
+    blindly with grep.
+
+    Args:
+        query: substring (kind='title') or exact tag (kind='tag').
+        kind: 'title' or 'tag'. Default 'title'.
+        limit: max results. Default 20.
+
+    Returns:
+        {"hits": [{"path", "title", "score", "matched_in"}, ...]} on success;
+        {"error": "...", "hint": "..."} on failure.
+    """
+    try:
+        hits = make_backend().search(query, kind=kind, limit=limit)
+        return {"hits": [_to_dict(h) for h in hits]}
+    except (ClientError, ValueError) as e:
+        return _err(e)
+
+
+def eno_note(path: str, with_excerpt: bool = True) -> dict[str, Any]:
+    """Get one note's frontmatter, headings, and a short prose excerpt.
+
+    Use this when the user references a specific note by name, or after
+    `eno_search` returns a path you want to peek at. Returns a token-cheap
+    summary (~1KB), not the full body — if you need the full file, use
+    your Read tool with the returned path.
+
+    Args:
+        path: vault-relative path (e.g. "2 Projects/Acme/Widget.md").
+        with_excerpt: include ~400 chars of body. Default True.
+
+    Returns:
+        {"path", "title", "word_count", "frontmatter", "headings", "excerpt"}
+        on success; {"note": null, "hint": "..."} if missing;
+        {"error": "...", "hint": "..."} on backend failure.
+    """
+    try:
+        view = make_backend().note(path, with_excerpt=with_excerpt)
+        if view is None:
+            return {"note": None, "hint": f"no note at {path!r}"}
+        return _to_dict(view)
+    except ClientError as e:
+        return _err(e)
+
+
+def eno_neighbors(path: str) -> dict[str, Any]:
+    """List a note's backlinks (notes pointing TO it) and outbound links
+    (notes it points AT) — the local link graph around one node.
+
+    Use this when you want to map context: who else has linked to a topic,
+    what concepts cluster around a note, where in the vault a project's
+    discussion lives. Two graph hops away = call this twice with different
+    paths.
+
+    Args:
+        path: vault-relative path of the focal note.
+
+    Returns:
+        {"path", "title", "backlinks": [...], "outbound": [...]} where each
+        list element is {"path", "title", "word_count"}; or
+        {"neighborhood": null, "hint": "..."} if the note doesn't exist.
+    """
+    try:
+        n = make_backend().neighbors(path)
+        if n is None:
+            return {"neighborhood": None, "hint": f"no note at {path!r}"}
+        return _to_dict(n)
+    except ClientError as e:
+        return _err(e)
+
+
+def eno_orphans(
+    folder: str | None = None, min_words: int = 0, limit: int = 20
+) -> dict[str, Any]:
+    """Find notes with no inbound links — candidates for resurfacing.
+
+    Use this when planning, gardening, or when the user asks "what have I
+    written that I've forgotten about?" The biggest orphans by word count
+    are usually the most-buried important work.
+
+    POSTURE: orphans aren't bugs, they're forgotten gold. Resurface, don't
+    judge.
+
+    Args:
+        folder: filter by folder prefix, e.g. "2 Research Areas".
+        min_words: only include notes ≥ this size. Default 0.
+        limit: max results. Default 20.
+
+    Returns:
+        {"count": N, "orphans": [{"path", "title", "word_count"}, ...]};
+        sorted by word_count descending.
+    """
+    try:
+        rows = make_backend().orphans(
+            folder=folder, min_words=min_words, limit=limit
+        )
+        return {"count": len(rows), "orphans": [_to_dict(r) for r in rows]}
+    except ClientError as e:
+        return _err(e)
+
+
+def eno_stubs(max_words: int = 80, limit: int = 20) -> dict[str, Any]:
+    """Find short notes with no outbound links — abandoned starts that
+    might want fleshing out, or duplicates of better notes.
+
+    Use this for gardening passes, or when looking for half-finished
+    threads in a topic the user is currently working on.
+
+    Args:
+        max_words: word-count ceiling. Default 80.
+        limit: max results. Default 20.
+
+    Returns:
+        {"count": N, "stubs": [{"path", "title", "word_count"}, ...]}.
+    """
+    try:
+        rows = make_backend().stubs(max_words=max_words, limit=limit)
+        return {"count": len(rows), "stubs": [_to_dict(r) for r in rows]}
+    except ClientError as e:
+        return _err(e)
+
+
+def eno_stale(
+    older_than_days: int = 180,
+    stages: list[str] | None = None,
+    limit: int = 20,
+) -> dict[str, Any]:
+    """Find notes whose mtime is past a threshold.
+
+    Use this for resurfacing — old notes the user might want to revisit.
+    By default excludes notes tagged `stage: reference` or `stage: archived`
+    (those are intentionally evergreen). Pass `stages=['draft','active']`
+    to narrow further.
+
+    Args:
+        older_than_days: cutoff in days. Default 180.
+        stages: optional list, e.g. ['draft', 'active'].
+        limit: max results. Default 20.
+
+    Returns:
+        {"count": N, "stale": [{"path", "title", "word_count"}, ...]}.
+    """
+    try:
+        rows = make_backend().stale(
+            older_than_days=older_than_days, stages=stages, limit=limit
+        )
+        return {"count": len(rows), "stale": [_to_dict(r) for r in rows]}
+    except ClientError as e:
+        return _err(e)
+
+
+def eno_broken_links(limit: int = 50) -> dict[str, Any]:
+    """List wikilinks whose target doesn't currently resolve to any note.
+
+    IMPORTANT — these are NOT bugs by default. The user deliberately writes
+    `[[Some Concept]]` references *before* creating the target note, as
+    groundwork for emerging research (incipient links). Backlinks from these
+    help connect ideas before pages crystallize.
+
+    The actual bug class is *drift*: a wikilink whose target *almost*
+    matches an existing note (em-dash vs hyphen, casing, trailing
+    punctuation) and silently doesn't resolve. This raw list mixes both
+    incipient and drift; the gardener (step 5) is what classifies them.
+    Don't pre-classify yourself, and don't frame these as errors.
+
+    Use this when investigating link integrity, when the user asks about
+    "concepts I've gestured at but haven't written," or when looking for
+    what to draft next.
+
+    Args:
+        limit: max results. Default 50.
+
+    Returns:
+        {"count": N, "links": [{"src_path", "target_text", "line_no"}, ...]}.
+    """
+    try:
+        rows = make_backend().broken_links(limit=limit)
+        return {"count": len(rows), "links": [_to_dict(r) for r in rows]}
+    except ClientError as e:
+        return _err(e)
+
+
+def eno_frontier(
+    folder: str | None = None,
+    halflife_days: float = 30.0,
+    limit: int = 20,
+    include_nonpositive: bool = False,
+    exclude_types: list[str] | None = None,
+) -> dict[str, Any]:
+    """List vault frontier pages — where the user is *actively reaching outward*.
+
+    score = (out_degree - in_degree) * exp(-age_days / halflife_days)
+
+    A high score means the page links to many things, is linked to by few,
+    and was recently touched. Hub pages (in >> out) and stale pages drop out.
+    Compare to `eno_orphans` (in_degree=0, no recency signal) and `eno_stale`
+    (recency only, no graph signal). This is the third leg.
+
+    Use this when:
+    - The user asks "what am I currently working on / pulling threads on?"
+    - You want to ground a planning conversation in active threads, not dead
+      ones — frontier pages are where the next note often wants to go.
+    - You're feeding the user's gardener / compactor and want priority
+      pages for review.
+
+    POSTURE: frontier is a *signal*, not a verdict. A high-score page might
+    be a brilliant frontier or a runaway shopping list — the user decides.
+
+    Args:
+        folder: filter by folder prefix (e.g. "2 Research Areas").
+        halflife_days: recency decay constant. Default 30 (recent month
+                       weighted ~1.0; ~6 months → ~0.13; year → ~0.0006).
+        limit: cap on returned pages. Default 20.
+        include_nonpositive: include pages with score <= 0 (hubs, stale).
+                             Default False.
+        exclude_types: frontmatter `type:` values to skip
+                       (e.g. ['log', 'meta']).
+
+    Returns:
+        {"count": N,
+         "frontier": [{"path", "title", "word_count", "out_degree",
+                       "in_degree", "age_days", "recency_weight",
+                       "score"}, ...]}
+        sorted by score descending.
+    """
+    try:
+        rows = make_backend().frontier(
+            folder=folder,
+            halflife_days=halflife_days,
+            limit=limit,
+            include_nonpositive=include_nonpositive,
+            exclude_types=exclude_types,
+        )
+        return {"count": len(rows), "frontier": [_to_dict(r) for r in rows]}
+    except ClientError as e:
+        return _err(e)
+
+
+def eno_hot(agent_name: str = "") -> dict[str, Any]:
+    """Session-start "what's hot" bundle, derived live from the index.
+
+    The eno equivalent of claude-obsidian's `wiki/hot.md` — but computed,
+    not written. Returns the four signals you most want before reading any
+    specific note:
+
+    1. **frontier** — pages with high outward reach, low inbound, recently
+       touched. Where the user is *currently pulling threads*.
+    2. **recent_appends** — notes whose mtime is within the last 7 days,
+       newest first. Active surfaces, regardless of graph shape.
+    3. **top_concepts** — incipient wikilinks by mention_count. Themes the
+       user has been gesturing at across notes — durable interests.
+    4. **agent_recent** — notes the agent itself authored within the last
+       14 days (when `agent_name` is provided). Your own contribution
+       trail; useful for continuity ("I last drafted X on Y").
+
+    Use this:
+    - On session start, before any other tool — establishes recent context
+      so you don't ask the user to recap.
+    - After context compaction (hook-injected context doesn't survive).
+    - When the user asks "what was I working on?" or "what's relevant
+      right now?"
+
+    Args:
+        agent_name: your own agent name as it appears in `author:`
+                    frontmatter (e.g. "Weaver"). Pass to populate
+                    `agent_recent`. Reads from $ENO_AGENT_NAME if unset.
+
+    Returns:
+        {"generated_at", "agent_name",
+         "frontier": [...FrontierNote...],
+         "recent_appends": [...NoteRef...],
+         "top_concepts": [...ConceptCandidate...],
+         "agent_recent": [...NoteRef...]}
+    """
+    import os
+    name = agent_name or os.environ.get("ENO_AGENT_NAME", "")
+    try:
+        bundle = make_backend().hot(agent_name=name)
+        return _to_dict(bundle)
+    except ClientError as e:
+        return _err(e)
+
+
+def eno_tiling(
+    threshold: float = 0.80,
+    error_threshold: float = 0.90,
+    folder: str | None = None,
+    min_words: int = 80,
+    model: str = "nomic-embed-text",
+) -> dict[str, Any]:
+    """Find candidate body-content duplicates via embedding cosine similarity.
+
+    Complements `eno_drift` (link-target fuzzy matches) and the existing
+    title-based duplicate scan in `garden`. This one looks at *bodies*: pairs
+    of notes whose semantic content is suspiciously close, regardless of
+    whether their titles or wikilinks reveal the overlap.
+
+    Two bands:
+    - **error_pairs** (similarity >= 0.90): strong near-duplicate; very likely
+      the same idea written twice. Surface to the user for consolidation.
+    - **review_pairs** (0.80 <= similarity < 0.90): possible tile overlap;
+      worth a glance but the author may have meant for them to be distinct.
+
+    Requires the optional LLM extra; embeddings route through somm, which
+    owns provider selection. If no model backend is reachable, the response
+    carries a non-null `error` string and empty band lists — surface this to
+    the user rather than guessing.
+
+    POSTURE: this is a *signal*, never a verdict. Do not auto-merge. Do
+    not call concept candidates or drift candidates "duplicates" — those
+    are different bug classes. If a tiling pair surprises you, the right
+    move is to read both notes (eno_note) and ask the user.
+
+    Embeddings are cached at `<vault>/.eno/tiling-cache.json`. The cache
+    is keyed on sha256(model + body), so model swaps invalidate
+    automatically and frontmatter-only edits don't re-embed.
+
+    Args:
+        threshold: review-band floor (default 0.80). Lower = more pairs.
+        error_threshold: error-band floor (default 0.90).
+        folder: optional folder prefix filter.
+        min_words: skip notes below this word count (default 80 — short
+                   stubs have no useful embedding signal).
+        model: ollama embed model name. Cache is per-model.
+
+    Returns:
+        {"error_pairs", "review_pairs", "pages_scanned", "pages_embedded",
+         "cache_hits", "skipped", "model", "error_threshold",
+         "review_threshold", "error"}
+    """
+    try:
+        report = make_backend().tiling(
+            threshold=threshold,
+            error_threshold=error_threshold,
+            folder=folder,
+            min_words=min_words,
+            model=model,
+        )
+        return _to_dict(report)
+    except ClientError as e:
+        return _err(e)
+
+
+def eno_hygiene() -> dict[str, Any]:
+    """Audit the vault's frontmatter contract: which notes lack required
+    fields (origin, stage), and how many are missing each field.
+
+    Use this when the user asks about vault structure, before running
+    backfill operations, or to gauge how much of the vault is fully
+    classified.
+
+    Returns:
+        {"counts": {"total", "origin", "stage"},
+         "issues": [{"path", "missing": [...]}, ...]};
+        the issues list can be long — use `counts` for the headline,
+        sample `issues` for examples.
+    """
+    try:
+        rep = make_backend().hygiene()
+        return _to_dict(rep)
+    except ClientError as e:
+        return _err(e)
+
+
+def eno_concepts(limit: int = 30) -> dict[str, Any]:
+    """List concept candidates — wikilink targets the user has gestured
+    at but not yet written. Surfaces emergent themes the user is
+    thinking about across notes.
+
+    Use this to ground suggestions in what the user actually cares about.
+    Instead of asking open-ended "what should I do next?", you can say
+    "you've been gesturing at Mechanism Design, Behavioral Economics,
+    and Andrej Karpathy across several notes — want to draft notes on
+    any of those?"
+
+    POSTURE: these are NOT broken-link errors. They're intentional
+    groundwork for notes-not-yet-written. Frame them as opportunities,
+    never as bugs to fix.
+
+    Args:
+        limit: cap on returned concepts. Default 30 — sorted by
+               mention_count descending; the head is the highest-signal.
+
+    Returns:
+        {"count": N, "concepts": [{"target_text", "mention_count",
+         "sources": [{"src_path", "line_no"}, ...]}, ...]}
+    """
+    try:
+        _, concepts = make_backend().classify_broken_links()
+        return {
+            "count": len(concepts),
+            "concepts": [_to_dict(c) for c in concepts[:limit]],
+        }
+    except ClientError as e:
+        return _err(e)
+
+
+def eno_drift(limit: int = 20) -> dict[str, Any]:
+    """List drift candidates — wikilinks that almost match an existing
+    note but don't resolve (em-dash drift, casing, trailing punctuation).
+
+    Use this when investigating link integrity, when the user mentions a
+    note and you can't find an exact match by name, or when triaging the
+    vault for actionable cleanup. Each candidate names the broken link,
+    the suggested existing note it probably meant to point to, and a
+    similarity score (0-1, where 1.0 = identical after normalization).
+
+    Args:
+        limit: cap on returned candidates. Default 20.
+
+    Returns:
+        {"count": N, "drift": [{"target_text", "suggested_path",
+         "suggested_title", "score", "sources": [...]}, ...]}
+    """
+    try:
+        drift, _ = make_backend().classify_broken_links()
+        return {
+            "count": len(drift),
+            "drift": [_to_dict(d) for d in drift[:limit]],
+        }
+    except ClientError as e:
+        return _err(e)
+
+
+def eno_create_note(
+    path: str,
+    body: str,
+    title: str | None = None,
+    overwrite: bool = False,
+    author: str | None = None,
+) -> dict[str, Any]:
+    """Create a new note in the vault.
+
+    Use this when filing a skill, summary, or research output you want to
+    persist across sessions. The note's frontmatter is auto-populated with
+    `origin: llm`, today's `created` and `updated`, and an `author` wikilink
+    if provided (or read from $ENO_AGENT_NAME).
+
+    POSTURE: Mark yourself in the `author` field — it's the convention that
+    makes future hygiene/garden passes provenance-aware. Don't omit it.
+
+    Args:
+        path: vault-relative path. ".md" appended if missing.
+        body: prose content. The H1 (matching the title) is added
+              automatically; don't include it in body.
+        title: explicit frontmatter title. Defaults to filename stem.
+        overwrite: if False (default), fail when the note already exists;
+              use eno_append_to_note instead. Pass True to replace.
+        author: agent identifier for the `author: '[[X]]'` wikilink. Falls
+              back to $ENO_AGENT_NAME if not set.
+
+    Returns:
+        {"path", "ok", "indexed", "note", "error"} — `indexed: true` means
+        the index was refreshed after the write so subsequent eno_search /
+        eno_neighbors calls see the new note immediately.
+    """
+    try:
+        backend = make_backend()
+        frontmatter = None
+        if title is not None:
+            frontmatter = {"title": title, "origin": "llm"}
+            if author:
+                frontmatter["author"] = f"[[{author}]]"
+        result = backend.create_note(
+            path,
+            body,
+            frontmatter=frontmatter,
+            overwrite=overwrite,
+            author=author,
+        )
+        return _to_dict(result)
+    except ClientError as e:
+        return _err(e)
+
+
+def eno_append_to_note(
+    path: str,
+    content: str,
+    under_heading: str | None = None,
+) -> dict[str, Any]:
+    """Append content to an existing vault note.
+
+    Use this when extending a note you (or a human) already wrote — adding
+    a finding to a research dossier, logging a result under a project
+    page's "Top items" heading, etc. Prefer this over eno_create_note when
+    the note exists.
+
+    Args:
+        path: vault-relative path of the existing note.
+        content: prose to append. Will be separated from existing content
+              by a blank line.
+        under_heading: optional. Format e.g. "## State" or "### Open items".
+              If provided, content is inserted right under that heading,
+              before the next heading at the same or higher level. If
+              omitted, content is appended to the end of the file.
+
+    Returns:
+        {"path", "ok", "indexed", "note", "error"}.
+    """
+    try:
+        result = make_backend().append_to_note(
+            path, content, under_heading=under_heading
+        )
+        return _to_dict(result)
+    except ClientError as e:
+        return _err(e)
+
+
+def eno_health() -> dict[str, Any]:
+    """Quick liveness check on the eno backend.
+
+    For ServiceBackend (when $ENO_SERVICE_URL is set), pings /health.
+    For LocalBackend, confirms the index file exists. Diagnostic only —
+    don't call this before every other tool.
+
+    Returns:
+        {"ok", "mode", "vault" | "service_url"}; or {"error", "hint"}.
+    """
+    try:
+        backend = make_backend()
+        if isinstance(backend, ServiceBackend):
+            res = backend.client.get("/health")
+            return res or {"ok": False, "hint": "service returned no body"}
+        if not index_path(backend.vault).exists():
+            return {
+                "ok": False,
+                "mode": "local",
+                "vault": str(backend.vault),
+                "hint": "no index — run `eno index`",
+            }
+        return {
+            "ok": True,
+            "mode": "local",
+            "vault": str(backend.vault),
+            "index": str(index_path(backend.vault)),
+        }
+    except ClientError as e:
+        return _err(e)

eno_mcp-0.1.0/tests/test_server.py

@@ -0,0 +1,48 @@
+"""Smoke test that build_server() wires every tool without import errors."""
+
+from eno_mcp.server import build_server
+
+
+def test_build_server_has_eno_name():
+    server = build_server()
+    assert server.name == "eno"
+
+
+def test_build_server_registers_all_nine_tools():
+    server = build_server()
+    # FastMCP exposes registered tools via list_tools (async) or its internal
+    # registry. We grab the internal names regardless of API shape.
+    names = _registered_tool_names(server)
+    expected = {
+        "eno_search",
+        "eno_note",
+        "eno_neighbors",
+        "eno_orphans",
+        "eno_stubs",
+        "eno_stale",
+        "eno_broken_links",
+        "eno_concepts",
+        "eno_drift",
+        "eno_hygiene",
+        "eno_create_note",
+        "eno_append_to_note",
+        "eno_health",
+    }
+    assert expected.issubset(names), f"missing: {expected - names}"
+
+
+def _registered_tool_names(server) -> set[str]:
+    # Try several known FastMCP attrs across versions.
+    for attr in ("_tool_manager", "tool_manager"):
+        mgr = getattr(server, attr, None)
+        if mgr is None:
+            continue
+        tools = getattr(mgr, "_tools", None) or getattr(mgr, "tools", None)
+        if tools is None:
+            continue
+        if isinstance(tools, dict):
+            return set(tools.keys())
+        # list of Tool objects with .name
+        return {getattr(t, "name", None) for t in tools if getattr(t, "name", None)}
+    # Fallback: introspect the FastMCP-decorated attributes
+    return set()

eno_mcp-0.1.0/tests/test_tools.py

@@ -0,0 +1,212 @@
+"""Tests for tool functions, exercised against a fixture vault via LocalBackend.
+The MCP wire layer is not tested here — that's FastMCP's job. We test that each
+tool returns the right shape on success and a clean error dict on failure."""
+
+from pathlib import Path
+
+import pytest
+from eno.indexer import index_vault
+from eno_mcp import tools
+
+
+@pytest.fixture()
+def vault(tmp_path: Path, monkeypatch) -> Path:
+    (tmp_path / "Alpha.md").write_text(
+        "---\norigin: human\nstage: active\n---\n# Alpha\n\n[[Beta]] [[Imaginary]]\n"
+    )
+    (tmp_path / "Beta.md").write_text("# Beta\n\n[[Alpha]]\n")
+    (tmp_path / "Orphan.md").write_text("# Orphan\n\nshort and unlinked")
+    monkeypatch.setenv("ENO_VAULT_DIR", str(tmp_path))
+    monkeypatch.setenv("ENO_DIR", str(tmp_path / ".eno"))
+    monkeypatch.delenv("ENO_SERVICE_URL", raising=False)
+    index_vault(tmp_path)
+    return tmp_path
+
+
+def test_search_finds_by_title(vault):
+    out = tools.eno_search("alpha")
+    assert "hits" in out
+    paths = [h["path"] for h in out["hits"]]
+    assert "Alpha.md" in paths
+
+
+def test_search_invalid_kind_returns_error_dict(vault):
+    out = tools.eno_search("x", kind="bogus")
+    assert "error" in out
+    assert "hint" in out
+
+
+def test_note_returns_view_with_excerpt(vault):
+    out = tools.eno_note("Alpha.md")
+    assert out["title"] == "Alpha"
+    assert out["frontmatter"]["origin"] == "human"
+    assert out["excerpt"]
+    assert any(h["text"] == "Alpha" for h in out["headings"])
+
+
+def test_note_missing_returns_null(vault):
+    out = tools.eno_note("Nope.md")
+    assert out["note"] is None
+    assert "hint" in out
+
+
+def test_neighbors(vault):
+    out = tools.eno_neighbors("Alpha.md")
+    backlink_paths = [b["path"] for b in out["backlinks"]]
+    assert "Beta.md" in backlink_paths
+
+
+def test_neighbors_missing(vault):
+    out = tools.eno_neighbors("Nope.md")
+    assert out["neighborhood"] is None
+
+
+def test_orphans(vault):
+    out = tools.eno_orphans()
+    paths = [r["path"] for r in out["orphans"]]
+    assert "Orphan.md" in paths
+    assert out["count"] == len(out["orphans"])
+
+
+def test_orphans_folder_filter_empty(vault):
+    out = tools.eno_orphans(folder="DoesNotExist")
+    assert out["count"] == 0
+
+
+def test_stubs(vault):
+    out = tools.eno_stubs(max_words=20)
+    paths = [r["path"] for r in out["stubs"]]
+    assert "Orphan.md" in paths
+
+
+def test_stale_recent_files_returns_empty(vault):
+    out = tools.eno_stale(older_than_days=180)
+    assert out["count"] == 0
+
+
+def test_broken_links_includes_imaginary(vault):
+    out = tools.eno_broken_links()
+    targets = [b["target_text"] for b in out["links"]]
+    assert "Imaginary" in targets
+
+
+def test_hygiene(vault):
+    out = tools.eno_hygiene()
+    # Beta and Orphan have no frontmatter; Alpha has both required fields.
+    assert out["counts"]["origin"] == 2
+    assert out["counts"]["stage"] == 2
+    assert out["counts"]["total"] == 3
+
+
+def test_concepts_returns_incipient_links(vault):
+    out = tools.eno_concepts()
+    assert "concepts" in out
+    targets = [c["target_text"] for c in out["concepts"]]
+    assert "Imaginary" in targets
+
+
+def test_drift_returns_fuzzy_matches(tmp_path: Path, monkeypatch):
+    # Drift case: target almost matches existing note
+    (tmp_path / "Real Note.md").write_text("# Real Note\n")
+    (tmp_path / "Caller.md").write_text("# Caller\n\n[[Real Notes]]\n")
+    monkeypatch.setenv("ENO_VAULT_DIR", str(tmp_path))
+    monkeypatch.setenv("ENO_DIR", str(tmp_path / ".eno"))
+    monkeypatch.delenv("ENO_SERVICE_URL", raising=False)
+    from eno.indexer import index_vault
+    index_vault(tmp_path)
+    out = tools.eno_drift()
+    assert out["count"] == 1
+    assert out["drift"][0]["target_text"] == "Real Notes"
+    assert out["drift"][0]["suggested_path"] == "Real Note.md"
+
+
+def test_concepts_limit_respected(vault):
+    out = tools.eno_concepts(limit=0)
+    assert out["concepts"] == []
+
+
+def test_hot_returns_bundle(vault):
+    out = tools.eno_hot(agent_name="Weaver")
+    assert out["agent_name"] == "Weaver"
+    assert out["generated_at"]
+    assert "frontier" in out
+    assert "recent_appends" in out
+    assert "top_concepts" in out
+    assert "agent_recent" in out
+    # Imaginary is an incipient concept on the fixture
+    targets = [c["target_text"] for c in out["top_concepts"]]
+    assert "Imaginary" in targets
+
+
+def test_hot_reads_agent_from_env(vault, monkeypatch):
+    monkeypatch.setenv("ENO_AGENT_NAME", "Weaver")
+    out = tools.eno_hot()
+    assert out["agent_name"] == "Weaver"
+
+
+def test_create_note_via_mcp(vault):
+    out = tools.eno_create_note(
+        path="WeaverNote.md",
+        body="written by weaver",
+        author="Weaver",
+    )
+    assert out["ok"]
+    assert out["indexed"]
+    assert (vault / "WeaverNote.md").exists()
+    raw = (vault / "WeaverNote.md").read_text()
+    assert "[[Weaver]]" in raw
+    assert "written by weaver" in raw
+
+
+def test_create_note_refuses_existing_via_mcp(vault):
+    out = tools.eno_create_note(path="Alpha.md", body="x")
+    assert not out["ok"]
+    assert "exists" in out["error"]
+
+
+def test_append_to_note_via_mcp(vault):
+    out = tools.eno_append_to_note(
+        path="Beta.md", content="appended via mcp"
+    )
+    assert out["ok"]
+    assert "appended via mcp" in (vault / "Beta.md").read_text()
+
+
+def test_append_under_heading_via_mcp(vault):
+    (vault / "Sectioned.md").write_text(
+        "# Sectioned\n\n## State\n\nfirst\n\n## Other\n\nstuff\n"
+    )
+    out = tools.eno_append_to_note(
+        path="Sectioned.md",
+        content="under-state line",
+        under_heading="## State",
+    )
+    assert out["ok"]
+    raw = (vault / "Sectioned.md").read_text()
+    state_pos = raw.index("## State")
+    other_pos = raw.index("## Other")
+    assert state_pos < raw.index("under-state line") < other_pos
+
+
+def test_health_local_ok(vault):
+    out = tools.eno_health()
+    assert out["ok"] is True
+    assert out["mode"] == "local"
+
+
+def test_health_local_no_index(tmp_path: Path, monkeypatch):
+    """Without running index_vault, health reports the missing index."""
+    monkeypatch.setenv("ENO_VAULT_DIR", str(tmp_path))
+    monkeypatch.setenv("ENO_DIR", str(tmp_path / ".eno"))
+    monkeypatch.delenv("ENO_SERVICE_URL", raising=False)
+    out = tools.eno_health()
+    assert out["ok"] is False
+    assert "no index" in out["hint"]
+
+
+def test_health_service_mode_uses_service_url(monkeypatch):
+    """When ENO_SERVICE_URL is set, eno_health pings the service."""
+    monkeypatch.setenv("ENO_SERVICE_URL", "http://service.invalid:9999")
+    out = tools.eno_health()
+    assert "error" in out
+    assert "unreachable" in out["error"]