I was drowning in my own notes

For about two years, I lived inside Obsidian. Daily notes, fleeting thoughts, meeting takeaways, half-formed ideas at 2am, voice memos I'd transcribe by hand. My vault had over 3,000 notes.

And I remembered almost none of it.

Every morning I'd open my laptop and stare at yesterday's daily note, trying to reconstruct where I was. The vault was full — full of captures that were never synthesized, tasks that were never carried forward, ideas that died in a folder called _inbox. I was doing the work of a knowledge worker but getting none of the compounding returns. Notes went in. Nothing came out.

What made it worse: I knew I was supposed to do the synthesis. Review your notes. Write a morning brief. Connect the dots. But after a full day of work, the last thing I wanted to do was sit down and play editor. So I didn't. And the vault stayed a graveyard.

The real problem isn't note-taking

Here's what I eventually figured out: I wasn't failing at note-taking. I was failing at synthesis — and I was expecting myself to do it at the worst possible time.

Synthesis requires cognitive distance. You need to look at what you captured with fresh eyes. The problem is that "fresh eyes" happen in the morning, and the synthesis work needs to happen after the day is over. That's a structural mismatch, and no productivity system fixes it because it's not a productivity problem.

It's a timing problem. And timing problems are exactly what automation solves.

The thought that changed everything: Claude doesn't get tired at 11pm. It doesn't need cognitive distance — it can read the whole day in one pass and pull out what matters. So I built vault-os to hand that job off.

What vault-os actually does

vault-os has two main jobs: capture anything, anywhere, and synthesize everything while you sleep.

Capture via Telegram bot. I wanted to send notes from my phone without opening Obsidian. The bot uses tag-based routing — anything you send gets sorted into the right section of your daily note automatically. #idea goes into Content Ideas. #signal goes into Research Signals. #link or a bare URL goes into Links to Process. Plain text goes to Captures. Voice messages get transcribed locally and then routed the same way.

Nightly agent at 23:00. A PowerShell script runs 12 phases: it reads your day, runs Claude over your captures, synthesizes patterns, writes an evening review, prepares your morning brief, and carries forward any unfinished tasks. By the time you wake up, your daily note for the new day already has context loaded.

Morning digest API. A REST endpoint serves the morning brief so you can display it anywhere — a home screen widget, a terminal script, a Raycast extension, whatever fits your setup.

Architecture: the two components

server.js — Node.js + Express + Telegraf

The server handles Telegram and the REST API. The core of it is a routing function that decides where each message goes in your daily note:

function routeMessage(text) {
  const t = text.trim();
  if (/^#(idea|fikir)\b/i.test(t))    return '## Content Ideas';
  if (/^#(signal|research|sinyal)\b/i.test(t)) return '## Research Signals';
  if (/^#link\b/i.test(t) || /^https?:\/\//i.test(t)) return '## Links to Process';
  return '## Captures';
}

Simple regex matching. I added Turkish/Azerbaijani aliases (fikir, sinyal) because I switch languages mid-thought constantly. You can extend this to whatever tags your brain uses.

Multi-line messages are handled per-line — if you paste a block of text with five ideas, each line gets routed independently. This matters more than it sounds; it means you can dump a brain dump into Telegram and it lands sorted.

The voice pipeline runs: OGG (Telegram's format) → ffmpeg converts to 16kHz mono WAV → whisper-cli transcribes → text goes through the same routing function. The whole thing is synchronous on my machine and takes about 4 seconds for a 30-second voice memo.

REST endpoints are minimal: GET /morning-brief returns the prepared brief as JSON, POST /capture lets other tools push content directly.

nightly-agent.ps1 — PowerShell, 12 phases

I wrote this in PowerShell because it runs as a Windows Task Scheduler job and I didn't want a dependency on a running Node process. The phases are:

• FAZ 1-2: Environment check, date setup, locate today's note
• FAZ 3 (Claude Think): Read all captured content, run a synthesis prompt, extract key themes, identify what was actually important vs. noise
• FAZ 4-5: Task extraction, carry-forward logic for incomplete items
• FAZ 6 (Morning Brief): Write tomorrow's opening section — not a summary of yesterday, but a launch pad for tomorrow. What's the one thing that matters. What task deserves first attention. What idea is worth developing.
• FAZ 7-10: Link processing, research signal digestion, content angle extraction
• FAZ 11 (Evening Review): Appended to today's note — a short human-readable synthesis of the day that you can read before sleep
• FAZ 12: Cleanup, log rotation, error reporting

The Claude API calls follow a consistent pattern: write the prompt to a temp file, call claude --print with --max-turns 1, capture stdout, clean up.

$prompt | Out-File -FilePath $tmpFile -Encoding UTF8
$result = & claude --print --max-turns 1 $tmpFile 2>$null
Remove-Item $tmpFile -ErrorAction SilentlyContinue

I use --max-turns 1 everywhere in the nightly agent because I don't want back-and-forth — I want one focused output per phase. This also keeps costs predictable. A full nightly run on a moderately active day costs me about $0.04.

What a daily note actually looks like

The daily note template has fixed sections that the automation respects:

# 2026-05-29

## Morning Brief
<!-- written by nightly agent from previous night -->

## Captures
<!-- plain Telegram messages land here -->

## Content Ideas
<!-- #idea tags land here -->

## Research Signals
<!-- #signal tags land here -->

## Links to Process
<!-- #link tags and bare URLs land here -->

## Evening Review
<!-- written by nightly agent at 23:00 -->

During the day, you're just sending messages. The structure fills itself in. The Morning Brief is already there when you open Obsidian. The Evening Review appears after the agent runs. You never touch the note directly unless you want to.

This matters for adoption: if the automation requires you to maintain the structure, you'll break it within two weeks. The structure has to be robust enough to survive a messy day where you just dump text into Telegram without thinking.

Voice capture and why local matters

I almost used OpenAI Whisper API for transcription. It's easier to set up and the accuracy is excellent. I switched to whisper.cpp for one reason: the content of voice notes.

When you're thinking out loud into your phone, you're not performing. You're rough-drafting decisions, processing frustrations, working through half-formed ideas that you wouldn't put in a document. That content is genuinely private — not in a paranoid way, but in the way that a sketchbook is private. It's your unedited thinking.

Sending that audio to an API means it transits servers you don't control. Running whisper.cpp locally means the audio never leaves your machine. The model is a file on disk (ggml-small.bin, 466MB), the process runs in a subprocess, and nothing goes over the network.

Accuracy with small is good enough for most voice notes — I get the occasional mishearing on proper nouns and mixed-language sentences, but the meaning survives. If you mostly dictate in a single language, small is the right tradeoff. medium (1.5GB) is noticeably better for multilingual.

What I wake up to

Here's what the Morning Brief section looks like on a real morning:

## Morning Brief

Carry-forward: Finish the vault-os README (started yesterday, left at setup section).

Yesterday's thread: Three captures around API cost optimization clustered
with a research signal on context caching. Worth developing.

Content angle ready: "Local-first AI tools" — #idea from Tuesday still
unaddressed, now has supporting signals from two separate sources.

Today's open question: The routing logic handles single-line captures well
but breaks on multi-paragraph pastes. Worth fixing or acceptable?

The brief is not a summary. It's a launch pad. There's a difference: a summary tells you what happened, a launch pad tells you where to start.

Getting started

Prerequisites: Node.js 18+, PowerShell 7+, Claude CLI authenticated, ffmpeg on PATH, whisper.cpp compiled.

git clone https://github.com/sabahattink/vault-os
cd vault-os
./setup.sh
# Edit .env: VAULT_PATH, TELEGRAM_BOT_TOKEN, ANTHROPIC_API_KEY
node dashboard/server.js

For the nightly agent, register scripts/nightly-agent.ps1 as a Windows Task Scheduler job at 23:00:

pwsh -File scripts/install-scheduler.ps1

What's next

I'm building this in public. Three things on the roadmap I actually need:

Decision intelligence endpoint. Extract decisions from a date range — not summaries, but actual choices made and the reasoning captured around them.

Weekly synthesis agent. Look across seven days of evening reviews and find the thread — what was I actually working on this week vs. what I said I was working on.

Mobile shortcut integration. An iOS Shortcut that records audio and POSTs directly to the capture endpoint, bypassing Telegram entirely for voice-only workflows.

If you use Obsidian and your vault isn't working for you — not because you're bad at it, but because synthesis is genuinely hard to sustain — vault-os might be worth trying.

GitHub: github.com/sabahattink/vault-os

Star it if it looks useful. Issues and PRs welcome.

Tags: obsidian, productivity, ai, opensource