Mimir (mimir-skin)

Mimir

English · 简体中文

A learning vault that teaches. It is an Obsidian vault and a DeepSeek Harness agent preset, wired together so that the agent is a teacher rather than a chatbot: it probes what you already understand, plans a dependency map of the subject, waits for your approval, then builds the topic one node at a time and writes everything into the vault as it goes.

Named for Mímir's well, the well of wisdom under Yggdrasil. What you are looking at is the well; the vault is where the water goes.

---

The problem it is built for

Reading about something and understanding it are different states, and only one of them survives a month. A pile of disconnected facts rots; facts held in place by their connections do not, because each one stays recoverable from the others.

So the goal here is not coverage. It is the moment a pile of loose facts collapses into two or three generating ideas, and stays collapsed.

Two principles do the work, and the rest of the system is downstream of them:

1. Unconditional truths first. Start from the few things you can accept as-is, with no caveats. Not because bottom-up is tidier, but because caveat-free facts are the only ones the mind will commit to without hedging. Where no exception-free truth exists at the level you are working at, the honest move is to say so and drop to the next solid ground: a definition, a distinction, a constraint.
2. "How could I have discovered this?" A fact with no visible reason to be the way it is feels arbitrary, and arbitrary facts do not stick. So every step is motivated from the problem that sent someone down that path. Nothing appears from nowhere.

The method is a port of amosblomqvist/learn, rebuilt for DSH: the reference system's graded-quiz extension becomes a real selectable-question tool, its researcher and diagram steps become preset sub-agents, and its markdown log becomes an actual vault.

What you get

The app	Mimir as one window: the vault, the teacher and the drawings together, with nothing else to install. It carries its own runtime and its own editor, so a first run asks one question — connect a model — and then teaches. See The application.
The preset	Mimir Tutor — nine method skills, six specialist sub-agents, and the standing rules about verifying facts before asserting them. This is the teacher.
The board	The lesson itself, published into the conversation: the spine of dependency nodes and where you are in each, the question, a one-line hint, and the vault's drawings. Scroll back to it, reload, fork — it is part of the transcript, so it is still there.
The vault	A working Obsidian vault: session, concept and map templates, a spaced-review queue, generated SVG dependency maps, a glossary that grows only from words a lesson actually needed, and a reading list capped at two books a session.
The theme	Mimir — warm paper and sage in daylight, a cold blue-black under cyan-and-magenta at night, a serif for what is read and a monospace for what is furniture.
Three plugins	Reading-size and light/dark controls, a startup animation, and a publisher that copies a finished note and its diagrams into a second library vault.
Two exports	A finished lesson printed to A4 as a record and as a study sheet, and the fact-shaped part of it collected into an Anki deck with its own note types. Both are two commands, and both read the notes.
Link previews	Hover a link in the conversation and a card opens with the page's title, its opening paragraph and its lead image — Wikipedia's own summary where the link is an article.

The application

The preset teaches inside DSH and the vault is read in Obsidian — two applications, and a reader has to assemble them. app/ is that assembly: one window holding both, so the teacher is beside the notes rather than in another window.

  Mimir shell (Electron)
     |-- starts  SiYuan kernel      -> the window loads its interface
     `-- starts  runtime bridge     -> the Mimir dock in that interface talks to it

• SiYuan is carried, unmodified, and credited. Nothing is forked and nothing patches it: the shell starts the kernel and installs a plugin through SiYuan's published API. CREDITS.md states the licence position, which is worth reading before changing how SiYuan is carried.
• The vault is markdown; SiYuan holds a view of it. A reconciler keeps the files and a notebook in step, and where both sides have moved it reports a conflict and touches neither — nothing is resolved silently.
• The method travels with it. The nine skills and the six specialists are in the application rather than in a preset on the machine that built it.
• The dock reads what the teacher writes: headings, lists, tables, fenced code, [[wikilinks]] and mermaid diagrams, and it shows which notes refer back to the one you are reading.

Build it with:

node app/scripts/build-app.mjs

Signing and notarization need a Developer ID certificate and an Apple ID, and are described in app/packages/shell/build/README.md. The design decisions and the things that went wrong are recorded in docs/app/0001-the-single-app.md.

The board

Every lesson is published as it happens. When the teacher teaches a node it calls mimir_board, which puts onto the transcript:

• the spine — the dependency map's nodes in teaching order, each marked held, learning, fragile or planned, so you can see where you are without leaving the lesson;
• the question and its options, word for word the same as the card you answer;
• one line of hint, only when it genuinely helps;
• the drawings this lesson turns on, rendered at full width.

Two things about the drawings are worth knowing, because they are the reason the board exists as a tool rather than as a note. They travel to your interface and never into the model's context — the teacher is told their names and nothing else, so a lesson can carry four diagrams without four thousand tokens of path data entering the conversation. And a drawing that is missing, unreadable or too large comes back named as missing, on screen, rather than being silently absent: a lesson that refers to a picture you cannot see is worse than one that admits the picture is not there.

There is no second window to keep in step. The conversation is the lesson; the board is the part of it you read at a glance.

Where a lesson goes afterwards

The vault is the record; two commands get the record out of it.

node Tools/export-lesson-pdf.mjs --done --both   # A4 into Learn/Exports/
node Tools/anki-cards.mjs --all                  # a deck into Learn/Exports/anki/

export-lesson-pdf.mjs prints each lesson twice. The record is the session as it stands — the plan, the nodes, the checks with what each one revealed. The study sheet is the same lesson with the checks turned into questions and the answers moved to an appendix, so it can be worked from rather than read. It measures what it can: a page that would orphan a heading breaks before it instead, and a lesson whose drawing is missing says so rather than printing a filename.

anki-cards.mjs collects only what Anki is good at — a name, a date, a character, a wrong claim to be judged — into a ## 🃏 Cards section beside the knowledge it tests, in the two shapes the note type understands: front :: back :: kind, and a cloze card written {{c1::…}}. A derivation never becomes a card, because a card turns reconstruction into recognition and the reviewing method is explicit that this is worse than no review. A species card must carry the characters that tell it apart, and a glossary entry is carded only when its note says card: true: a reference should be generous, and a deck should not. The package it writes carries both note types, their templates and their CSS, so importing the one file is the whole install.

Both tools take --vault DIR to read a vault other than the one they live in.

The hover card

A link in the conversation is a link you can look at without leaving the lesson. Rest the pointer on it for a moment and a card opens beside it; Wikipedia links get the article's own opening paragraph from Wikimedia's summary API rather than a scrape.

It has to be two halves, and the reason is worth knowing. The conversation is served under a content-security policy of connect-src 'self', so the page cannot fetch Wikipedia itself, and an iframe is refused by X-Frame-Options. So the host half fetches beside the workspace and answers one loopback route, and the browser half only listens for a hover. The route is fenced like the server-side fetch it is: http and https only, no credentials, no redirect into the machine, a capped body and a hard timeout — and a refusal is an ordinary answer with a reason a person can read, never a blank card.

Install

You need Obsidian and DeepSeek Harness.

git clone https://github.com/tommyhedgerow/Mimir.git
cd Mimir
./scripts/install.sh

That does two things: it puts the preset in your DSH home, and it installs the board into your DSH profile. Both matter — a preset cannot carry the board's browser half, so an installation without the second step gives you a teacher who publishes to nothing.

./scripts/install.sh --lang zh-CN installs the Simplified Chinese preset instead. Both can be installed at once; their ids differ, so they sit side by side in the session picker.

Then:

1. Restart DSH. A preset is composed once per process, so the new one is not visible until the harness comes back up.
2. Open the Mimir folder as the workspace, and pick Mimir Tutor in the session picker.
3. Open the same folder as a vault in Obsidian.
4. Say what you want to learn. "Teach me plate tectonics." "I want to understand what Kant actually did." "Explain mycorrhiza."

./scripts/install.sh --dry-run shows what it would do without touching anything. ./scripts/uninstall.sh reverses it.

If you would rather just have the teacher

Both presets are on Preset Square as single .dshpreset files, which DSH Desktop installs from Settings → Agent presets → Import:

• Mimir Tutor (English) — teaches in English.
• Mimir Tutor (Simplified Chinese) — teaches in Simplified Chinese.

Two older listings — mimir-tutor-20d96e and mimir-tutor-chinese-582526 — are still on the square and are out of date: they predate the lesson board and still carry the retired pane. Preset Square has no update route, so a preset that changes is published again rather than edited. Use the two above.

That route gives you the teacher and nothing else: no vault, no theme, no plugins, and no board. It is the right one if you already have a vault and only want the method.

Running in a browser instead of the desktop app

Everything here works under dsh web exactly as it does in DSH Desktop — the same preset root, the same profile, the same board. Two things to know:

• The board's row is composed once per process. After installing, restart the server, not just the page.
• Importing a .dshpreset is a DSH Desktop feature. The import route ships in the desktop shell, so under dsh web there is nothing to catch the file. Use ./scripts/install.sh, or copy the preset to <dsh home>/.agent-presets/mimir-tutor/ by hand — the layout is identical.

Fuller detail, including the manual path, the Windows notes and how to build a .dshpreset to share, is in INSTALL.md.

How a session actually goes

Probe. The teacher asks a bracketed set of questions: something at the level you should get right, and something you should get wrong. The truth is in between. An all-correct run means the questions were too easy, so it escalates. One miss is one coordinate, not a verdict: it probes around the miss to find out whether it is a slip, a gap, or a misconception, because a misconception has to be dislodged rather than topped up.

Plan. A cartographer sub-agent maps the field first, so the plan is not built on a half-remembered version of the subject. What comes back is prose plus a small dependency map, roots at the top and your goal at the bottom. Then it waits. That map is your checkpoint, and it is also the teaching order.

Teach. One node at a time, and every node gets the same four moves: motivate it, establish it, connect it to what you already hold, and check it. A miss means stop and repair. Nothing is built on an unconfirmed node.

Write it down. Sessions, concepts, maps and review entries land in the vault as they happen, not reconstructed at the end. The diagrams are generated from the notes' own frontmatter by a script, so a picture of where you stand cannot quietly go stale.

Review. Taught concepts earn a due date. Retrieval first, repair on a miss, and the next interval set by how well it went. Four clean retrievals and the concept is retired off the queue.

What is in the repository

Learn/                the vault
  How We Learn.md       the method, written for the learner rather than the machine
  Learner Profile.md    a blank form: your floors, your edges, your misconceptions
  Sessions/             one dated note per session, written live
  Concepts/             atomic notes, one idea each, wikilinked into a graph
  Maps/                 one per strand, holding the dependency order and the frontier
  Reviews/              the spaced-review queue
  Glossary/             one note per niche word a lesson actually needed
  Templates/            Session, Concept, Map
  Viz/                  generated SVG, drawn at the width of the reading column
  Dashboard.base        live views: what is due, what is fragile, where each strand stands

preset/               the DSH agent preset, and the board
  preset.yml            the name and description the session picker shows
  agent.cordis.yml      the persona, the tool rows, and the six specialists
  skills/               the nine method skills, one directory each
  mimir-skin/           the board: its host half, its browser half and its layer

preset-zh/            the same teacher, in Simplified Chinese

.obsidian/            the theme and the three plugins, ready to use
Tools/                the generators, the exports, the board's build and its tests
  vault-map.mjs         validate the spines, and write the generated maps
  vault-chart.mjs       draw every SVG in Learn/Viz from those spines
  export-lesson-pdf.mjs a lesson to A4, as a record and as a study sheet
  anki-cards.mjs        the card-shaped part of the vault into an Anki package
  lib/                  the markdown reader, the Anki writer, the note types
  link-preview/         the hover card's two halves, and its builder
assets/               the artwork in this README, and the startup animation
scripts/              install, uninstall, plugin sync, and preset packaging
docs/                 what is translated and what deliberately is not
app/                  the application: the shell, the bridge, the harness profile
                      with its skills and specialists, and the SiYuan dock

app/ is a pnpm workspace of its own with its own lock file, because it pins the harness packages the application runs and those move on a different schedule from the vault's plugins.

The checks

Nothing here is trusted to stay in step by luck. Each of these fails loudly rather than drifting:

node Tools/check-tokens.mjs                # one palette across the theme, the charts, the plugins and the board
node Tools/vault-map.mjs                   # the maps in the notes are the maps the scripts draw
node Tools/build-mimir-skin.mjs --check    # the board ships built, and the build is current
node Tools/test-mimir-board.mjs            # the board's host half mounts, registers, and refuses a path it should
node Tools/test-mimir-skin.mjs             # the board's browser half: contrast floors, token names, the shipped bundle
node Tools/test-anki-cards.mjs             # the deck: the glossary gate, the two card shapes, a real .apkg
node Tools/test-export-lesson-pdf.mjs      # the print: A4, a text layer, links with brackets, embeds as drawings
node Tools/test-link-preview.mjs           # the hover card: the route, the refusals, the shipped bundle
node Tools/check-bilingual.mjs             # the two languages carry the same skills and the same composition
node scripts/sync-plugins.mjs --check      # the vendored plugins are the ones their repositories released
./scripts/pack-preset.sh --check           # both presets still build, and build reproducibly
cd app && npm test                         # the markdown parser, the vault sync's decisions, and the
                                           # parser embedded in the dock still matching its source
node app/scripts/sync-markdown.mjs --check # the dock's parser is generated, so it can go stale

Licence

MIT. The method is a port of amosblomqvist/learn, which is MIT too.