obsidian-second-brain 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Minh Nhat Hoang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,136 @@
+# second-brain
+
+**Give your AI coding sessions a long-term memory — an Obsidian vault that maintains itself.**
+
+Every Claude Code session ends the same way: the context dies with it. The transcript lands in a folder nobody reads back, and the next session starts cold. second-brain closes that loop:
+
+- **Capture** — session transcripts mirror into your vault automatically; ending a task with `/wrap` distills it into a small, curated plan + output artifact.
+- **Synthesize** — an hourly job (Claude Haiku, a fast model) turns new artifacts into dated episode notes; a weekly job (Claude Sonnet, a stronger one) consolidates episodes into stable per-project wiki pages — what the project is, what was decided and why, how projects relate.
+- **Recall** — init adds a section to your `CLAUDE.md` instructing sessions to consult `wiki/index.md` whenever the repository alone can't answer. Sessions start light and *find* context instead of being fed giant dumps.
+
+No manual curation. Idle hours cost $0 — a content-hash manifest skips runs with nothing new. And every run that did work leaves a human-readable report in `wiki/reports/`, so the system is never a black box.
+
+```
+You work in Claude Code
+  ├─ transcripts mirror into the vault            (archive, $0)
+  └─ /wrap on finishing a task → curated artifact
+        │
+        ▼  hourly · Haiku
+  wiki/episodes/ — dated episode notes per project
+        │
+        ▼  weekly · Sonnet
+  wiki/<project>.md — per-project wiki pages: decisions, rationale, relations
+        │
+        ▼
+  your next session reads wiki/index.md when it lacks context — and just knows
+```
+
+## Requirements
+
+| Requirement | Notes |
+|---|---|
+| **macOS** | scheduling uses launchd (Windows/Linux not yet supported) |
+| **Node >= 20** | the build runs automatically on install |
+| **[Obsidian](https://obsidian.md)** | the vault folder must contain `.obsidian/` — open it in Obsidian once, or let init create a fresh vault with `--new-vault` |
+| **[Claude Code](https://claude.com/claude-code)** | used at least once, so `~/.claude/projects/` exists; its `claude` CLI also powers synthesis — without it everything still works except episode/wiki generation |
+
+## Install
+
+```bash
+npm install -g obsidian-second-brain
+second-brain init
+```
+
+> After upgrading (`npm update -g obsidian-second-brain`), run `second-brain init` again: npm replaces the package folder, which holds the generated config. Re-running is idempotent and never touches your vault content.
+
+<details>
+<summary>From source instead</summary>
+
+```bash
+git clone https://github.com/minhnhat08/second-brain.git ~/tools/second-brain
+cd ~/tools/second-brain
+npm install     # installs dependencies and builds (via the prepare hook — if it fails, run `npm run build`)
+npm link        # puts the `second-brain` command on your PATH
+second-brain init
+```
+
+The clone is the install: the scheduled jobs run out of this folder, so don't park it somewhere temporary. If you move it later, run `second-brain init` again from the new location. Prefer not to touch your global npm? Skip `npm link` and use `node dist/cli.js` wherever you see `second-brain` below.
+
+</details>
+
+`init` asks two questions — Enter accepts the defaults shown in brackets:
+
+```
+Claude folder [/Users/you/.claude]
+Obsidian vault [/Users/you/Documents/Obsidian Vault]
+```
+
+It refuses to continue if the Claude folder has no `projects/` (run Claude Code once first) or the vault has no `.obsidian/` (open it in Obsidian once, or pass `--new-vault`). Then it sets up the whole loop:
+
+- scaffolds the vault as an LLM wiki (`raw/`, `wiki/`, `AGENTS.md`, its own git repo for history)
+- installs the `/wrap` command and adds a marker-fenced section to your `~/.claude/CLAUDE.md`: the `/wrap` habit plus the retrieval policy
+- generates `config/projects.json` and loads the hourly + weekly launchd jobs
+
+**Your files are safe.** Nothing is silently overwritten: conflicts prompt (or use `--force` / `--keep-existing`), every override is backed up next to the original, a symlinked `CLAUDE.md` is followed to its target and edited *additively*, and init prints a `review:` line whenever it touches an instruction file — read what it added.
+
+Unattended install: `second-brain init --claude <dir> --vault <dir> --new-vault --keep-existing [--skip-launchd]`. Without a terminal attached, unspecified paths take the defaults and any file conflict aborts unless `--force` or `--keep-existing` is given.
+
+## Daily use
+
+There is none — that's the point. Two habits make the wiki good:
+
+- End meaningful tasks with **`/wrap`**. Curated artifacts are far better synthesis input than raw transcripts, and the installed CLAUDE.md section reminds the agent to offer it.
+- Browse `wiki/index.md` in Obsidian now and then; `wiki/reports/` shows exactly what any run did.
+
+## Is it working?
+
+```bash
+launchctl list | grep second-brain        # hourly + weekly jobs loaded
+tail -5 /tmp/second-brain.stdout.log      # last run summary
+ls -t "<vault>/wiki/reports/" | head -3   # recent run reports — <vault> is the path you chose in init
+```
+
+If init warned `claude CLI preflight failed`, synthesis fell back to `noop` (mirror + reports only). Confirm `claude --version` works in a plain terminal, then set `synthesis.backend` to `cli-claude` in `config/projects.json`. A second concurrent run exiting with `Another instance holds the lock` is by design.
+
+## Configuration
+
+`config/projects.json` — in the install folder, not the vault:
+
+| Field | Meaning |
+|---|---|
+| `vaultRoot` | `<vault>/raw/projects` — where transcripts mirror to (must end in `raw/projects`) |
+| `providers[]` | one entry per source; all four fields required: `name` (`claude` / `codex` / `gemini`), `sourceRoot`, `destinationPath`, `enabled` |
+| `synthesis.backend` | `noop` ($0: mirror + reports only) · `cli-claude` (Haiku hourly, Sonnet weekly) · `ollama` (local hourly; weekly stays on cli-claude) |
+| `synthesis.claudeBin` | absolute path to the `claude` binary — init records the one it verified; scheduled jobs never see your shell PATH |
+| `logsRoot` | run logs directory |
+
+Paths support `${ENV_VAR}` expansion; the file is validated with clear errors. Edit it and the next run picks it up — no reload step.
+
+## Uninstall
+
+```bash
+second-brain uninstall
+npm uninstall -g obsidian-second-brain
+```
+
+Removes the launchd jobs, the managed CLAUDE.md section, `/wrap`, and generated files it installed — skipping any you modified. **Your vault content is never touched**: it is your data and your audit trail.
+
+## Development
+
+```bash
+npm run typecheck
+npm test                # 172 unit/integration tests
+npm run coverage        # per-file line/branch coverage
+npm run e2e             # drives the real built binary against temp worlds ($0)
+SB_E2E_CLAUDE=1 npx tsx --test tests/e2e/claude-smoke.e2e.ts  # paid smoke (one haiku call)
+```
+
+The E2E suites spawn `dist/cli.js` as a child process against disposable worlds (vault paths deliberately contain spaces): ingest/consolidation with reports and idle skips, init/uninstall lifecycle (PATH shims keep your real launchd untouched), lock contention, crash redo, timezone pinning, and backend degradation. The release bar lives in [docs/publish-readiness.md](docs/publish-readiness.md); the architecture in [docs/design.md](docs/design.md).
+
+## Status
+
+Running live against a real vault — 900+ sessions, idempotent re-runs, a report per run. Public release is pending a short observation window. Next on the roadmap: local semantic search over the mirrored transcripts.
+
+## License
+
+[MIT](LICENSE)

package/config/projects.example.json

@@ -0,0 +1,13 @@
+{
+  "vaultRoot": "${HOME}/Documents/Obsidian Vault/raw/projects",
+  "logsRoot": "../logs",
+  "synthesis": { "backend": "noop" },
+  "providers": [
+    {
+      "name": "claude",
+      "sourceRoot": "${HOME}/.claude/projects",
+      "destinationPath": "sessions/claude",
+      "enabled": true
+    }
+  ]
+}

package/dist/artifact-frontmatter.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+const slugPattern = /^[a-z0-9][a-z0-9-]*$/u;
+const artifactFrontmatterSchema = z.object({
+    date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/u),
+    project: z
+        .string()
+        .refine((value) => value === "_inbox" || slugPattern.test(value), {
+        message: "project must be a kebab-case slug or the reserved _inbox"
+    }),
+    session_id: z.string().regex(/^[A-Za-z0-9_-]+$/u),
+    task: z.string().min(1),
+    type: z.enum(["output", "plan"])
+});
+export function parseArtifact(content) {
+    // Editors on other machines may save artifacts with a BOM or CRLF endings;
+    // both would otherwise quarantine a perfectly valid file.
+    const lines = content.replace(/^\uFEFF/u, "").split(/\r?\n/u);
+    if (lines[0] !== "---") {
+        throw new Error("Artifact is missing its opening frontmatter fence");
+    }
+    const closingIndex = lines.indexOf("---", 1);
+    if (closingIndex === -1) {
+        throw new Error("Artifact is missing its closing frontmatter fence");
+    }
+    const fields = {};
+    for (const line of lines.slice(1, closingIndex)) {
+        if (line.trim().length === 0) {
+            continue;
+        }
+        const separatorIndex = line.indexOf(":");
+        if (separatorIndex === -1) {
+            throw new Error(`Malformed frontmatter line: ${line}`);
+        }
+        const key = line.slice(0, separatorIndex).trim();
+        // Last-wins merging would let a later line silently shadow an already
+        // validated value; duplicates are author mistakes worth surfacing.
+        if (Object.hasOwn(fields, key)) {
+            throw new Error(`Duplicate frontmatter key: ${key}`);
+        }
+        fields[key] = line.slice(separatorIndex + 1).trim();
+    }
+    return {
+        body: lines.slice(closingIndex + 1).join("\n").replace(/^\n+/u, ""),
+        frontmatter: artifactFrontmatterSchema.parse(fields)
+    };
+}

package/dist/changeset.js

@@ -0,0 +1,18 @@
+import { createHash } from "node:crypto";
+const GENERATED_AT_LINE = /^- generated_at: /u;
+export function normalizeRenderedBody(markdown) {
+    const lines = markdown.split("\n");
+    // Both renderers open the body with their first "## " heading ("## Conversation"
+    // or "## Event N"); the volatile generated_at stamp only exists above it.
+    const headerEnd = lines.findIndex((line) => line.startsWith("## "));
+    const boundary = headerEnd === -1 ? lines.length : headerEnd;
+    return lines
+        .filter((line, index) => index >= boundary || !GENERATED_AT_LINE.test(line))
+        .join("\n");
+}
+export function hashContent(content) {
+    return createHash("sha256").update(content, "utf8").digest("hex");
+}
+export function hashRenderedBody(markdown) {
+    return hashContent(normalizeRenderedBody(markdown));
+}

package/dist/classify.js

@@ -0,0 +1,50 @@
+import { buildSourceKey } from "./manifest.js";
+export function classifySources(manifest, sources) {
+    const added = [];
+    const changed = [];
+    const unchanged = [];
+    for (const source of sources) {
+        const entry = manifest.entries[buildSourceKey(source)];
+        if (entry === undefined) {
+            added.push(source);
+            continue;
+        }
+        if (entry.contentHash === source.contentHash) {
+            unchanged.push(source);
+            continue;
+        }
+        changed.push(source);
+    }
+    return { added, changed, unchanged };
+}
+export function hasWork(classified) {
+    return classified.added.length > 0 || classified.changed.length > 0;
+}
+export function groupByProject(sources) {
+    const groups = new Map();
+    for (const source of sources) {
+        const group = groups.get(source.project);
+        if (group === undefined) {
+            groups.set(source.project, [source]);
+            continue;
+        }
+        group.push(source);
+    }
+    return groups;
+}
+export function renderedFileToIngestSource(file) {
+    return {
+        contentHash: file.contentHash,
+        path: file.destinationPath,
+        project: file.project,
+        provider: file.providerName,
+        sessionId: file.sessionId,
+        type: "transcript"
+    };
+}
+export function toManifestEntries(sources, ingestedAt) {
+    return Object.fromEntries(sources.map((source) => [
+        buildSourceKey(source),
+        { contentHash: source.contentHash, ingestedAt }
+    ]));
+}

package/dist/cli-claude-backend.js

@@ -0,0 +1,40 @@
+import { readFile } from "node:fs/promises";
+import { parseEpisodePatch } from "./episode-patch.js";
+import { assertEpisodesMatchProject, buildEpisodePrompt } from "./episode-prompt.js";
+import { runCommand } from "./shell.js";
+const defaultDependencies = {
+    readSource: (path) => readFile(path, "utf8"),
+    run: runCommand
+};
+export function createCliClaudeBackend(options = {}, dependencies = defaultDependencies) {
+    const claudeBin = options.claudeBin ?? "claude";
+    return {
+        name: "cli-claude",
+        synthesize: async (input) => {
+            const prompt = await buildEpisodePrompt(input, dependencies.readSource);
+            const result = await dependencies.run(claudeBin, ["-p", "--model", "haiku", "--output-format", "json", prompt], process.cwd());
+            const text = extractResultText(result.stdout);
+            const patch = parseEpisodePatch(text);
+            assertEpisodesMatchProject(patch.episodes, input.project);
+            return { episodes: patch.episodes };
+        }
+    };
+}
+export function extractResultText(stdout) {
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch {
+        // The CLI can print a banner, login prompt, or usage-limit notice instead
+        // of the JSON envelope; a bare SyntaxError would be useless in failures[].
+        throw new Error(`claude CLI emitted non-JSON output: ${stdout.slice(0, 120).trim()}`);
+    }
+    if (typeof parsed === "object" &&
+        parsed !== null &&
+        "result" in parsed &&
+        typeof parsed.result === "string") {
+        return parsed.result;
+    }
+    throw new Error("Unexpected claude CLI output envelope: missing result text");
+}

package/dist/cli.js

@@ -0,0 +1,337 @@
+#!/usr/bin/env node
+import { realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { join, resolve, sep } from "node:path";
+import { createCliClaudeBackend } from "./cli-claude-backend.js";
+import { loadConfig, parseCliArgs, selectProviders } from "./config.js";
+import { createCliClaudeConsolidationBackend, resolveConsolidationBackend } from "./consolidation-backend.js";
+import { runConsolidation } from "./consolidation.js";
+import { runIngest } from "./ingest.js";
+import { acquireLock } from "./lock.js";
+import { createLogger } from "./logger.js";
+import { createOllamaBackend } from "./ollama-backend.js";
+import { createReportWriter } from "./report.js";
+import { resolveBackend } from "./synthesis.js";
+import { syncProviderTree } from "./sync.js";
+const defaultDependencies = {
+    createLogger,
+    loadConfig,
+    now: () => new Date(),
+    stdout: (message) => {
+        process.stdout.write(message);
+    },
+    syncProviderTree
+};
+export async function runCli(argv, dependencies = defaultDependencies) {
+    const args = parseCliArgs(argv);
+    const configPath = resolve(args.configPath ?? join(import.meta.dirname, "..", "config", "projects.json"));
+    const config = await dependencies.loadConfig(configPath);
+    const logger = dependencies.createLogger(config.logsRoot);
+    const selectedProviders = selectProviders(config.providers, args);
+    const results = [];
+    const generatedAt = dependencies.now().toISOString();
+    const vaultPaths = args.ingest || args.consolidate ? resolveVaultPaths(config.vaultRoot) : undefined;
+    const lock = vaultPaths ? await acquireLock(vaultPaths.lockPath) : undefined;
+    try {
+        logger.info(`Using config: ${configPath}`);
+        logger.info(`Selected providers: ${selectedProviders.map((provider) => provider.name).join(", ")}`);
+        for (const provider of selectedProviders) {
+            const result = await syncProvider(provider, config.vaultRoot, generatedAt, logger, dependencies);
+            results.push(result);
+        }
+        const syncedCount = results.filter((result) => result.status === "synced").length;
+        const errorCount = results.filter((result) => result.status === "error").length;
+        const renderedFiles = results.flatMap((result) => result.status === "synced" ? result.renderedFiles : []);
+        let ingestSummary;
+        let consolidationSummary;
+        // One writer per run: a combined --ingest --consolidate run accumulates
+        // both stages into a single report file.
+        const reportWriter = vaultPaths
+            ? createReportWriter({
+                now: dependencies.now,
+                reportsRoot: vaultPaths.reportsRoot,
+                runKind: args.runKind ?? "manual",
+                vaultRoot: vaultPaths.vaultDir
+            })
+            : undefined;
+        if (vaultPaths && args.ingest) {
+            const backend = resolveBackend(config.synthesis.backend, {
+                "cli-claude": createCliClaudeBackend({
+                    claudeBin: config.synthesis.claudeBin
+                }),
+                ollama: createOllamaBackend({ model: config.synthesis.ollamaModel })
+            });
+            ingestSummary = await runIngest({
+                artifactsRoot: vaultPaths.artifactsRoot,
+                backend,
+                episodesRoot: vaultPaths.episodesRoot,
+                logPath: vaultPaths.wikiLogPath,
+                manifestPath: vaultPaths.manifestPath,
+                now: dependencies.now,
+                renderedFiles,
+                reportWriter
+            });
+            logger.info(ingestSummary.skipped
+                ? "Ingest: skipped (no changes)"
+                : `Ingest: episodes=${ingestSummary.episodePaths.length}, transcripts_tracked=${ingestSummary.trackedTranscripts}, failures=${ingestSummary.failures.length}, quarantined=${ingestSummary.quarantined.length}`);
+        }
+        if (vaultPaths && args.consolidate) {
+            const backend = resolveConsolidationBackend(config.synthesis.backend, {
+                "cli-claude": createCliClaudeConsolidationBackend({
+                    claudeBin: config.synthesis.claudeBin
+                })
+            });
+            consolidationSummary = await runConsolidation({
+                backend,
+                episodesRoot: vaultPaths.episodesRoot,
+                indexPath: vaultPaths.indexPath,
+                logPath: vaultPaths.wikiLogPath,
+                manifestPath: vaultPaths.manifestPath,
+                now: dependencies.now,
+                reportWriter,
+                wikiRoot: vaultPaths.wikiRoot
+            });
+            logger.info(consolidationSummary.skipped
+                ? "Consolidation: skipped (no new episodes)"
+                : `Consolidation: pages_created=${consolidationSummary.pagesCreated.length}, pages_updated=${consolidationSummary.pagesUpdated.length}, episodes=${consolidationSummary.episodesConsolidated}, failures=${consolidationSummary.failures.length}`);
+        }
+        // Both stages write into the same report file, so either path works.
+        const reportPath = ingestSummary?.reportPath ?? consolidationSummary?.reportPath;
+        if (reportPath !== undefined) {
+            logger.info(`Run report: ${reportPath}`);
+        }
+        logger.info(`Summary: synced=${syncedCount}, error=${errorCount}`);
+        const logPath = await logger.flush();
+        dependencies.stdout(`Log written to ${logPath}\n`);
+        return {
+            ...(consolidationSummary ? { consolidation: consolidationSummary } : {}),
+            errorCount,
+            ...(ingestSummary ? { ingest: ingestSummary } : {}),
+            logPath,
+            renderedFiles,
+            ...(reportPath !== undefined ? { reportPath } : {}),
+            syncedCount
+        };
+    }
+    finally {
+        await lock?.release();
+    }
+}
+function resolveVaultPaths(vaultRoot) {
+    // Defense-in-depth (design 7.6): the prune scope must stay confined to
+    // raw/projects, so a hand-edited config cannot point ingest at a stray tree.
+    const normalized = resolve(vaultRoot);
+    if (!normalized.endsWith(join(`${sep}raw`, "projects"))) {
+        throw new Error(`vaultRoot must end in raw/projects to run ingest, got: ${vaultRoot}`);
+    }
+    const vault = resolve(normalized, "..", "..");
+    return {
+        artifactsRoot: join(vault, "raw", "artifacts"),
+        episodesRoot: join(vault, "wiki", "episodes"),
+        indexPath: join(vault, "wiki", "index.md"),
+        lockPath: join(vault, "wiki", ".ingest.lock"),
+        manifestPath: join(vault, "wiki", ".ingest-state.json"),
+        reportsRoot: join(vault, "wiki", "reports"),
+        vaultDir: vault,
+        wikiLogPath: join(vault, "wiki", "log.md"),
+        wikiRoot: join(vault, "wiki")
+    };
+}
+async function syncProvider(provider, vaultRoot, generatedAt, logger, dependencies) {
+    const destinationRoot = join(vaultRoot, provider.destinationPath);
+    try {
+        const summary = await dependencies.syncProviderTree({
+            destinationRoot,
+            generatedAt,
+            providerName: provider.name,
+            sourceRoot: provider.sourceRoot
+        });
+        logger.info(`[${provider.name}] synced: rendered_markdown=${summary.renderedMarkdownFiles}, copied=${summary.copiedFiles}, deleted=${summary.deletedFiles}`);
+        return {
+            copiedFiles: summary.copiedFiles,
+            deletedFiles: summary.deletedFiles,
+            providerName: provider.name,
+            renderedFiles: summary.renderedFiles,
+            renderedMarkdownFiles: summary.renderedMarkdownFiles,
+            status: "synced"
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        logger.info(`[${provider.name}] error: ${message}`);
+        return {
+            message,
+            providerName: provider.name,
+            status: "error"
+        };
+    }
+}
+export function parseInitArgs(argv) {
+    let claudeDir;
+    let vaultDir;
+    let force = false;
+    let keepExisting = false;
+    let newVault = false;
+    let skipLaunchd = false;
+    for (let index = 0; index < argv.length; index += 1) {
+        const currentArg = argv[index];
+        if (currentArg === "--claude" || currentArg === "--vault") {
+            const nextArg = argv[index + 1];
+            if (!nextArg) {
+                throw new Error(`Missing value for ${currentArg}`);
+            }
+            if (currentArg === "--claude") {
+                claudeDir = nextArg;
+            }
+            else {
+                vaultDir = nextArg;
+            }
+            index += 1;
+            continue;
+        }
+        if (currentArg === "--force") {
+            force = true;
+            continue;
+        }
+        if (currentArg === "--keep-existing") {
+            keepExisting = true;
+            continue;
+        }
+        if (currentArg === "--new-vault") {
+            newVault = true;
+            continue;
+        }
+        if (currentArg === "--skip-launchd") {
+            skipLaunchd = true;
+            continue;
+        }
+        throw new Error(`Unknown argument: ${currentArg}`);
+    }
+    return { claudeDir, force, keepExisting, newVault, skipLaunchd, vaultDir };
+}
+function appDir() {
+    return resolve(import.meta.dirname, "..");
+}
+function stdout(message) {
+    process.stdout.write(message);
+}
+async function runInitCommand(argv) {
+    const { homedir } = await import("node:os");
+    const { runCommand } = await import("./shell.js");
+    const { runInit } = await import("./init.js");
+    const home = homedir();
+    const isTTY = process.stdin.isTTY === true && process.stdout.isTTY === true;
+    const flags = parseInitArgs(argv);
+    const defaults = {
+        claudeDir: join(home, ".claude"),
+        vaultDir: join(home, "Documents", "Obsidian Vault")
+    };
+    let askText;
+    let askYesNo;
+    let closePrompts = () => undefined;
+    if (isTTY) {
+        const { createInterface } = await import("node:readline/promises");
+        const readline = createInterface({ input: process.stdin, output: process.stdout });
+        askText = async (question, fallback) => {
+            const answer = (await readline.question(`${question} [${fallback}] `)).trim();
+            return answer.length > 0 ? answer : fallback;
+        };
+        askYesNo = async (question) => {
+            const answer = (await readline.question(`${question} `)).trim().toLowerCase();
+            return answer === "y" || answer === "yes";
+        };
+        closePrompts = () => readline.close();
+    }
+    else {
+        askText = async (_question, fallback) => fallback;
+        askYesNo = async () => false;
+    }
+    try {
+        const claudeDir = flags.claudeDir ?? (await askText("Claude folder", defaults.claudeDir));
+        const vaultDir = flags.vaultDir ?? (await askText("Obsidian vault", defaults.vaultDir));
+        const summary = await runInit({
+            claudeDir,
+            force: flags.force,
+            keepExisting: flags.keepExisting,
+            newVault: flags.newVault,
+            skipLaunchd: flags.skipLaunchd,
+            vaultDir
+        }, {
+            appDir: appDir(),
+            askYesNo,
+            env: process.env,
+            exec: runCommand,
+            home,
+            isTTY,
+            launchAgentsDir: join(home, "Library", "LaunchAgents"),
+            log: (message) => stdout(`${message}\n`),
+            nodePath: process.execPath,
+            now: () => new Date(),
+            uid: String(process.getuid?.() ?? 501)
+        });
+        stdout(`created: ${summary.created.length}, kept: ${summary.kept.length}, overridden: ${summary.overridden.length}\n`);
+        stdout(`synthesis backend: ${summary.backend}\n`);
+        for (const plist of summary.plists) {
+            stdout(`launchd job loaded: ${plist}\n`);
+        }
+    }
+    finally {
+        closePrompts();
+    }
+}
+async function runUninstallCommand(argv) {
+    const { homedir } = await import("node:os");
+    const { runCommand } = await import("./shell.js");
+    const { runUninstall } = await import("./uninstall.js");
+    const home = homedir();
+    const flags = parseInitArgs(argv);
+    const summary = await runUninstall({ claudeDir: flags.claudeDir ?? join(home, ".claude") }, {
+        appDir: appDir(),
+        exec: runCommand,
+        launchAgentsDir: join(home, "Library", "LaunchAgents"),
+        log: (message) => stdout(`${message}\n`),
+        uid: String(process.getuid?.() ?? 501)
+    });
+    for (const removedPath of summary.removed) {
+        stdout(`removed: ${removedPath}\n`);
+    }
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    const command = argv[0];
+    if (command === "init") {
+        await runInitCommand(argv.slice(1));
+        return;
+    }
+    if (command === "uninstall") {
+        await runUninstallCommand(argv.slice(1));
+        return;
+    }
+    const syncArgv = command === "sync" ? argv.slice(1) : argv;
+    const result = await runCli(syncArgv);
+    if (result.errorCount > 0) {
+        process.exitCode = 1;
+    }
+}
+function isDirectInvocation() {
+    const entry = process.argv[1];
+    if (entry === undefined) {
+        return false;
+    }
+    // npm bin stubs and symlinked paths (e.g. /tmp on macOS) make argv[1]
+    // differ textually from import.meta.url; compare real paths or the CLI
+    // silently no-ops when invoked through a symlink.
+    try {
+        return realpathSync(entry) === fileURLToPath(import.meta.url);
+    }
+    catch {
+        return false;
+    }
+}
+if (isDirectInvocation()) {
+    main().catch((error) => {
+        // A clean one-line failure beats an unhandled-rejection stack trace.
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 1;
+    });
+}