Reference — skills & MCP tools

R read-only W writes to the vault Skills install per agent; MCP tools are called automatically.

Core & knowledge

Retrieval and link-graph plumbing shared by every install — the foundation the domain categories build on.

Skills

W vdb-link-weaver — weave [[wiki links]] into notes by content- and title-match.
W vdb-note-triage — classify untyped notes, fix frontmatter, move them to the right folder.
W vdb-research-assistant — save clippings, synthesize notes into wiki pages, track open questions.
W vdb-wiki-ingestion — turn stale raw notes into synthesized wiki pages; mark sources ingested.

MCP tools

Tool	Purpose
R `vault_search`	FTS5 full-text search over heading-path chunks
R `vault_semantic_search`	Embedding search (when embeddings are built)
R `vault_get_chunks`	Fetch content for search results
R `vault_graph`	Wiki-link graph traversal
R `vault_sql`	Read-only SQL query over the index
R `vault_status`	DB stats — note/chunk/table counts

Productivity

The original worked examples — type: task and type: shopping notes, plus trip and reminder workflows.

Skills

W vdb-shopping — browser-assisted shopping research → decision notes.
W vdb-travel — trip note with linked packing, shopping, and expense lists.
R vdb-due-notify — surface due / approaching items to Telegram (Hermes, OpenClaw).
R vdb-browser-assistant — general-purpose browser automation over CDP (navigate, extract, fill, screenshot); vdb-shopping is a wrapper on top of it.

MCP tools

Tool	Purpose
R `vault_due_tasks`	Tasks due on/before a date
R `vault_due_items`	Any dated item approaching its due date
R `vault_shopping_suggestions`	Frequent items from archived lists
R `vault_stale_notes`	Notes updated since wiki ingestion
R `vault_publish_log`	What was published outward, and when

Infrastructure / DevOps

Ten domain tables for ops, each mapping a type: value to a parser, a table, and a tool. The skills keep those tables fed and audited.

Skills

R vdb-incident-triage — top of the incident chain: fan out to the vault + monitoring MCPs and produce one briefing (affected resources, recent changes, dependents, ranked actions). Read-only — never opens or resolves anything.
W vdb-incident-response — create, track, and resolve incidents.
W vdb-incident-review — sweep stale open incidents → triage note.
W vdb-runbook-manager — create / update / retrieve runbooks.
W vdb-cert-monitor — track TLS expiry, trigger renewal tasks.
W vdb-host-inventory-sync — sync live host / service state into the tables.
W vdb-vm-health-check — cross-reference live VM / container state against the inventory; flag what's down.
W vdb-network-audit — audit devices against network_devices.
W vdb-change-log — record changes with before/after + rollback.
W vdb-service-dashboard — (re)generate the services dashboard page.
W vdb-stale-service-audit — flag unknown / unhealthy services.
W vdb-iac-ingestor — parse Terraform / Pulumi / CDK / Ansible into the vault.
W vdb-source-ingestor — scan source repos → metadata into the vault.
R vdb-capacity-planner — match spare hardware to a deployment goal.
R vdb-security-posture — audit incidents, certs, services → risk report.
R vdb-service-checks — checklist audit for deploys and migrations.

MCP tools

Tool	Purpose
R `vault_host_lookup`	Hosts by name, IP, or status
R `vault_service_query`	Running services / containers
R `vault_network_lookup`	Network device lookup
R `vault_incidents`	Open / resolved incidents
R `vault_runbook`	Operational runbook
R `vault_spare_hardware`	Spare hardware inventory
R `vault_cert_expiry`	TLS certs expiring within N days
R `vault_recent_changes`	Infrastructure change log
R `vault_cloud_resources`	Cloud resource inventory
R `vault_source_repos`	Source repository metadata

Roadmap · opt-in

Goals → epics → stories as plain notes. Optionally, the write tools turn it into a pull-based queue agents work on their own — mark a story ready and an agent claims it, works it, and reports back. The claim is atomic, so two agents never grab the same story. Enable the "project-management" group on the Setup tab (it was called "roadmap" before 2026-07; older configs migrate on load).

Skills

W vdb-po — Product-Owner skill: build and manage the vault-native ticket tree (goals, epics, stories).
W vdb-sprint — agent work queue: claim a ready story atomically, execute it, write status back.
W vdb-completion — completion protocol when a work stream ends: tick the plan TOC, log to the daily note, move the story to review, run the PR checklist (and on an isolated worktree branch, push + open the PR/MR).
R vdb-pr-review — vault-side PR review: load the infra pages, plan, story, incidents, and runbooks the change touches, review with that context, post findings on approval.

MCP tools

Tool	Purpose
R `vault_roadmap_summary`	Goal / epic / story rollup
R `vault_epic_stories`	Stories under an epic
R `vault_ready_stories`	Stories marked ready to claim
R `vault_story_candidates`	Stories needing grooming
W `vault_claim_story`	Claim a story atomically for an agent
W `vault_update_story_status`	Write progress back to the note

QA impact graph · opt-in

A directed graph of service / call relationships plus QA scenarios. Given a change, find the affected scenarios and coverage gaps. Edges are derived from relationship frontmatter (calls/publishes/reads…). Enable the "qa" group.

Skills

R vdb-impact-analysis — given a change, find affected scenarios + coverage gaps.
W vdb-graph-sync — build / refresh graph_nodes and graph_edges.

MCP tools

Tool	Purpose
R `vault_blast_radius`	What a node change can reach
R `vault_affected_scenarios`	Scenarios touched by a change
R `vault_coverage_gaps`	Paths with no QA scenario
R `vault_scenario_coverage`	What a scenario exercises
R `vault_upstream_clients`	Who calls a node
R `vault_downstream_calls`	What a node calls

Delegation · opt-in

Hand a task to another agent running in an isolated git worktree — interactively (a tmux session you can take over) or fire-and-forget (a headless systemd-run job). A durable type: handoff note seeds the agent; each launch is recorded as a type: agent-session note. Enable the "dispatch" group.

Skills

W vdb-handoff — summarize context into a durable Handoffs/ note to save for later or pass on.
W vdb-handoff-session — spawn an interactive, takeoverable tmux session.
W vdb-dispatch — fire-and-forget headless delegation via systemd-run.
W vdb-session-resume — resume a rate-limited tmux agent by scheduling a continue for its usage-limit reset (systemd-run / at / hermes cron; works with or without Hermes).

MCP tools

Tool	Purpose
R `vault_agent_sessions`	List delegated sessions + their take-over command and status

Plans · opt-in

Durable planning artifacts. Planning happens in the vault; execution happens outside it — a plan is the what/why, a handoff is the hand-to-an-agent event, and the two cross-link. A type: plan note starts under Projects/<project>/plans/ and, once carried out, is flipped to status: executed and archived into a year/month directory that stays indexed. Enable the "plans" group.

Skills

W vdb-plan — scaffold, list, and archive plan notes (also vdb plan new|list|archive from the CLI).

MCP tools

Tool	Purpose
R `vault_pending_plans`	Plans not yet executed, per project or vault-wide
R `vault_plan_history`	Executed plans, newest first — what actually shipped
W `vault_mark_plan_executed`	Flip a plan to executed (frontmatter + DB; the file move is `vdb plan archive`)

Operon · opt-in

Support for the Operon Obsidian task plugin as the vault's task system of record. Not a new note type — it re-parses your existing type: task notes and runs in parallel to Productivity's task_items (both parsers fire, so date-windowed vault_due_tasks keeps working). operon_tasks carries the raw Operon frontmatter: Operon writes status: <Pipeline>.<Label> (e.g. Project.doing) and the prefix can't be stripped, so the tool matches on a substring — pass status="doing". Enable the "operon" group; without the plugin installed it just mirrors task notes into the table, harmlessly.

Skills

No dedicated skill — the existing task workflows write these notes. Migrate an existing vault to the Operon file-task contract (7-char operonId, prefixed status, datetime sync fields) with scripts/migrate-tasks-to-operon.py; snapshot / restore the durable Operon config with scripts/operon-config-backup.py.

MCP tools

Tool	Purpose
R `vault_operon_tasks`	Operon tasks by pipeline status (prefix-tolerant), area, or due window

Activity & reviews

Agent attribution and the periodic reviews that synthesize what happened. The server stamps the VAULT_AGENT env var on every query_log row, so multi-agent usage stays distinguishable.

Skills

R vdb-morning-briefing — daily briefing synthesized from vault data.
W vdb-worklog — ad-hoc logger: append one timestamped entry to today's daily note (done / handed off / parked) without the plan-and-PR ceremony of vdb-completion.
W vdb-weekly-review — weekly retro; saves a review note.
W vdb-periodic-review — monthly / quarterly strategic review.

MCP tools

Tool	Purpose
W `vault_log_activity`	Log a significant agent action to DB + markdown
R `vault_activity_log`	Query the activity log (`date='today'\|'week'`)
R `vault_find_note`	Resolve a title to a path/ID

Publishing & sync

The vault is the source of truth, but not an island. Stories, epics, and incidents can push to and pull from external ticketing / project-management tools (GitHub Issues, GitLab, Jira). Sync is always explicit and user-controlled — no automated background writes — so the vault and the tracker converge only when you ask.

W vdb-publisher — publishing is its own skill.

Pushes vault content outward — to ticketing systems, wikis, static HTML, GitHub, or webhooks. It always runs a dry-run first, honors hard path/tag exclusions that are never published, and is configured through /vdb-setup. You decide what leaves the vault. Skill source →

Setup & maintenance

The skills that look after the install itself rather than your content. All three are re-runnable and non-destructive.

Skills

W vdb-setup — the setup wizard: drives the vdb tui menu, interviews you for what the menu can't capture, then implements the result. Re-runnable — it detects existing state and resumes or updates instead of overwriting.
W vdb-update — diffs the commit log between the SHA recorded in vdb-config.yaml and the current template HEAD, classifies changes by impact, and produces an update plan scoped to what changed and what you actually installed.
W vdb-optimizer — the self-improvement loop. Audits the DB and the skill ecosystem: which skills read files raw where an MCP tool exists, which new tables or tools the content justifies, and — from the hook telemetry — which skills are stale, orphaned, or locally customized.

Behind them

These lean on the CLI rather than dedicated MCP tools: vdb tui (feature menu) · vdb config apply · vdb upgrade check / run · vdb audit · vdb hooks install · vdb lockstep.

The optimizer's inputs are the telemetry tables that survive a full rebuild — query_log, tool_miss_log, subagent_log, skill_usage — written by the cross-harness hooks.

Using the tools

Agents route to MCP tools automatically when a request is vault-shaped — phrase it in terms of your content.

Ask something like…	Tool invoked
"what tasks are due this week"	`vault_due_tasks`
"find my notes on Kubernetes networking"	`vault_search` → `vault_get_chunks`
"what's running on my NAS"	`vault_service_query`
"show open incidents"	`vault_incidents`
"find the runbook for Coolify"	`vault_runbook`
"what certs are expiring soon"	`vault_cert_expiry`
"what changed on pmx-01 last week"	`vault_recent_changes`
"what's the blast radius of changing auth-svc"	`vault_blast_radius`
"find notes linked to this wiki page"	`vault_graph`

The two-step read pattern

vault_search returns chunk IDs and scores, not content. Pass those IDs to vault_get_chunks to read. Agents chain both automatically — "find my notes on X and summarize them" triggers the pair.

Forcing an explicit call

If the agent isn't routing to MCP, name the tool:

agent prompt

"use vault_search to find notes about <topic>"
"call vault_due_tasks for today"
"query the vault database for services on <host>"

Customize the schema

Adding a domain table is a five-place lockstep — do all five or none. Run vdb lockstep to verify.

Drop loop in _init_db() — add the table name
CREATE TABLE in _init_db()
Parser function — _parse_X_meta() / _parse_X_items()
Dispatch arm in _index() — elif note_type == "X":
MCP tool in vault-mcp-server.py + entry in the TOOLS dict

Generic note structure (notes, chunks, links, tags, FTS) needs no changes for new content types. See docs/setup-guide.md for the full checklist, embedding models, and troubleshooting.