Describe the vault: root path, folder taxonomy, note counts, method.

Call this first in a session so you know the structure you are writing into. The taxonomy is data (.secondbrain/config.json), not code.

Create the folder taxonomy and config file in an empty or new vault.

Idempotent: existing folders and notes are left untouched.

List note paths, optionally restricted to one folder.

Read one note: frontmatter, body, tags and outgoing links.

Create a note. Refuses to clobber an existing note unless overwrite=true.

Append to a note, creating it if absent.

The append-only primitive: prefer this over rewriting raw capture notes.

Insert text at the end of the section under heading, adding the section at the end of the note if it is missing.

Merge keys into a note's YAML frontmatter.

Move or rename a note inside the vault.

Move a note into the archive folder. Nothing is ever deleted.

Find notes by NAME or path. */? globs work; a bare word matches any name containing it.

Use this when you know roughly what a note is called. Use search_notes when you need to look inside the content.

Literal or regex search across note CONTENT, with surrounding lines.

Plain text matching, no embeddings. Read the excerpts, judge relevance yourself, then read_note the ones that matter.

Find notes carrying a tag (frontmatter tags or inline #tag). Nested tags match: ml also matches ml/rl.

Find notes by a frontmatter key, optionally matching an exact value.

Notes that link to this one via [[wikilink]].

Graph neighbours of a note, scored: direct links either way, shared outbound links, shared tags. Each result says why it matched.

Structural only — no semantics. Judge the candidates yourself.

Notes modified in the last N days, newest first.

Persist the current session into the vault -- the /compact step.

YOU write the summary; this tool only files it. Before calling, compact the session yourself into: what was being done and why, decisions taken with their reasons, what is still open, which files/artifacts were touched. Write durable facts, not a transcript -- a reader six months from now should not need the conversation.

Creates a note in the sessions folder marked undistilled, and drops a pointer into today's log.

Append a timestamped entry to the day's append-only log.

For in-flight capture: a fact, a link, a half-formed idea. Never rewrite the log -- it is the raw stream distillation feeds on.

Read one day's log (ISO date, default today).

Raw captures not yet distilled, oldest first, with their content.

This is the core loop and it is YOUR job, not the server's: read each item, pull out the ideas that will still matter later, write each one as a single atomic note via create_concept_note (linking to existing notes with [[Title]]), then call mark_distilled on the source listing what you produced. Skip anything ephemeral -- mark it distilled with an empty produced list.

Write one atomic note: one idea, stated as a claim.

title should read as an assertion you could disagree with, not a topic label. claim is the idea in one or two sentences. links are titles of existing notes -- call find_notes or search_notes first so you link into the graph instead of creating an island.

Mark a raw capture as distilled, recording which notes came out of it.

Where the graph is fraying: undistilled backlog, orphan notes, unresolved [[links]], most-connected hubs, per-folder counts.

Use it to pick the next maintenance job -- an unresolved link is usually a note worth writing; an orphan is usually a note worth linking.

Write a Map-of-Content index note over notes you have curated.

Random notes pulled up for re-reading -- the anti-write-only-vault move.

Re-read them, then either link them somewhere new, sharpen the claim, or archive them if they no longer hold.

Notes untouched for N+ days, oldest first.