granite-mem 0.1.3 → 0.1.5

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command } from "commander";
+import { Command, InvalidArgumentError } from "commander";
 
 // src/commands/init.ts
 import fs3 from "fs";
@@ -109,7 +109,7 @@ function writeDefaultConfig(dir) {
 function loadConfig(vaultRoot) {
   const configPath = path.join(vaultRoot, CONFIG_FILENAME);
   if (!fs.existsSync(configPath)) {
-    throw new Error(`No ${CONFIG_FILENAME} found in ${vaultRoot}. Run "mem init" first.`);
+    throw new Error(`No ${CONFIG_FILENAME} found in ${vaultRoot}. Run "granite init" first.`);
   }
   const raw = fs.readFileSync(configPath, "utf-8");
   const parsed = yaml.load(raw);
@@ -143,7 +143,7 @@ function findVaultRoot(from) {
 function requireVaultRoot(from) {
   const root = findVaultRoot(from);
   if (!root) {
-    throw new Error(`No Granite vault found. Run "mem init" to create ${getDefaultVaultRoot()}.`);
+    throw new Error(`No Granite vault found. Run "granite init" to create ${getDefaultVaultRoot()}.`);
   }
   return root;
 }
@@ -180,11 +180,11 @@ function initVault(dir = getDefaultVaultRoot()) {
     console.log(`  ${typeConfig.folder}/  (${name})`);
   }
   console.log("");
-  console.log('Next: mem new "My first note" --type fleeting');
+  console.log('Next: granite new "My first note" --type fleeting');
 }
 
 // src/commands/new.ts
-import fs6 from "fs";
+import fs10 from "fs";
 
 // src/core/note.ts
 import fs4 from "fs";
@@ -533,8 +533,8 @@ function countNoteFiles(vaultRoot, config) {
 }
 function upsertNoteAndLinks(db, note) {
   const upsertNote = db.prepare(`
-    INSERT INTO notes (slug, id, title, type, created, modified, tags, aliases, body, filepath)
-    VALUES (@slug, @id, @title, @type, @created, @modified, @tags, @aliases, @body, @filepath)
+    INSERT INTO notes (slug, id, title, type, created, modified, tags, aliases, body, filepath, status, source)
+    VALUES (@slug, @id, @title, @type, @created, @modified, @tags, @aliases, @body, @filepath, @status, @source)
     ON CONFLICT(slug) DO UPDATE SET
       id = excluded.id,
       title = excluded.title,
@@ -544,7 +544,9 @@ function upsertNoteAndLinks(db, note) {
       tags = excluded.tags,
       aliases = excluded.aliases,
       body = excluded.body,
-      filepath = excluded.filepath
+      filepath = excluded.filepath,
+      status = excluded.status,
+      source = excluded.source
   `);
   const deleteLinks = db.prepare("DELETE FROM links WHERE source_slug = ?");
   const insertLink = db.prepare(`
@@ -562,7 +564,9 @@ function upsertNoteAndLinks(db, note) {
       tags: JSON.stringify(note.frontmatter.tags),
       aliases: JSON.stringify(note.frontmatter.aliases),
       body: note.body,
-      filepath: note.filepath
+      filepath: note.filepath,
+      status: note.frontmatter.status ?? "active",
+      source: note.frontmatter.source ?? "human"
     });
     deleteLinks.run(note.slug);
     const links = parseWikilinks(note.body);
@@ -1196,6 +1200,489 @@ function parseJsonArray(raw) {
   }
 }
 
+// src/core/sync/manager.ts
+import fs9 from "fs";
+import path9 from "path";
+
+// src/core/sync/client.ts
+var SyncClient = class {
+  baseUrl;
+  apiKey;
+  timeoutMs;
+  constructor(config, timeoutMs = 5e3) {
+    this.baseUrl = config.server.replace(/\/$/, "");
+    this.apiKey = config.api_key;
+    this.timeoutMs = timeoutMs;
+  }
+  async request(method, endpoint, body) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const response = await fetch(`${this.baseUrl}${endpoint}`, {
+        method,
+        headers: {
+          "Authorization": `Bearer ${this.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        const text = await response.text().catch(() => "");
+        throw new SyncApiError(response.status, text || response.statusText);
+      }
+      return await response.json();
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async push(payload) {
+    return this.request("POST", "/v1/sync/push", payload);
+  }
+  async pull(sinceSeq, deviceId) {
+    return this.request("GET", `/v1/sync/pull?since_seq=${sinceSeq}&device_id=${deviceId}`);
+  }
+  async quickPull(sinceSeq, deviceId, timeoutMs = 200) {
+    const oldTimeout = this.timeoutMs;
+    this.timeoutMs = timeoutMs;
+    try {
+      return await this.pull(sinceSeq, deviceId);
+    } catch {
+      return null;
+    } finally {
+      this.timeoutMs = oldTimeout;
+    }
+  }
+  async listDevices() {
+    return this.request("GET", "/v1/sync/devices");
+  }
+  async ping() {
+    try {
+      await this.request("GET", "/v1/sync/ping");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+var SyncApiError = class extends Error {
+  constructor(statusCode, body) {
+    super(`Sync API error ${statusCode}: ${body}`);
+    this.statusCode = statusCode;
+    this.body = body;
+    this.name = "SyncApiError";
+  }
+};
+
+// src/core/sync/device.ts
+import fs6 from "fs";
+import path6 from "path";
+import os2 from "os";
+import { v4 as uuidv42 } from "uuid";
+var DEVICE_FILE = "device.json";
+function getDeviceFilePath(vaultRoot) {
+  const graniteDir = path6.join(vaultRoot, ".granite");
+  fs6.mkdirSync(graniteDir, { recursive: true });
+  return path6.join(graniteDir, DEVICE_FILE);
+}
+function getOrCreateDeviceId(vaultRoot, deviceName) {
+  const filePath = getDeviceFilePath(vaultRoot);
+  if (fs6.existsSync(filePath)) {
+    const raw = fs6.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  }
+  const info = {
+    device_id: uuidv42(),
+    device_name: deviceName || os2.hostname(),
+    created: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  fs6.writeFileSync(filePath, JSON.stringify(info, null, 2), "utf-8");
+  return info;
+}
+function getDeviceId(vaultRoot) {
+  return getOrCreateDeviceId(vaultRoot).device_id;
+}
+
+// src/core/sync/changelog.ts
+import Database2 from "better-sqlite3";
+import fs7 from "fs";
+import path7 from "path";
+import crypto from "crypto";
+var SYNC_DB_FILE = "sync.db";
+var SYNC_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS changelog (
+  seq         INTEGER PRIMARY KEY AUTOINCREMENT,
+  note_id     TEXT NOT NULL,
+  operation   TEXT NOT NULL,
+  timestamp   TEXT NOT NULL,
+  device_id   TEXT NOT NULL,
+  checksum    TEXT NOT NULL,
+  synced      INTEGER NOT NULL DEFAULT 0
+);
+
+CREATE INDEX IF NOT EXISTS idx_changelog_note_id ON changelog(note_id);
+CREATE INDEX IF NOT EXISTS idx_changelog_synced ON changelog(synced);
+
+CREATE TABLE IF NOT EXISTS sync_meta (
+  key   TEXT PRIMARY KEY,
+  value TEXT
+);
+`;
+function getSyncDbPath(vaultRoot) {
+  const graniteDir = path7.join(vaultRoot, ".granite");
+  fs7.mkdirSync(graniteDir, { recursive: true });
+  return path7.join(graniteDir, SYNC_DB_FILE);
+}
+function openSyncDb(vaultRoot) {
+  const dbPath = getSyncDbPath(vaultRoot);
+  const db = new Database2(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.exec(SYNC_SCHEMA_SQL);
+  return db;
+}
+function computeChecksum(content) {
+  return crypto.createHash("sha256").update(content, "utf-8").digest("hex");
+}
+function recordChange(db, noteId, operation, deviceId, fileContent) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const checksum = computeChecksum(fileContent);
+  const stmt = db.prepare(`
+    INSERT INTO changelog (note_id, operation, timestamp, device_id, checksum, synced)
+    VALUES (?, ?, ?, ?, ?, 0)
+  `);
+  const result = stmt.run(noteId, operation, now, deviceId, checksum);
+  return {
+    seq: result.lastInsertRowid,
+    note_id: noteId,
+    operation,
+    timestamp: now,
+    device_id: deviceId,
+    checksum,
+    synced: false
+  };
+}
+function getPendingChanges(db) {
+  return db.prepare("SELECT * FROM changelog WHERE synced = 0 ORDER BY seq ASC").all();
+}
+function markChangesSynced(db, upToSeq) {
+  db.prepare("UPDATE changelog SET synced = 1 WHERE seq <= ?").run(upToSeq);
+}
+function getLastServerSeq(db) {
+  const row = db.prepare("SELECT value FROM sync_meta WHERE key = 'last_server_seq'").get();
+  return row ? Number(row.value) : 0;
+}
+function setLastServerSeq(db, seq) {
+  db.prepare("INSERT OR REPLACE INTO sync_meta (key, value) VALUES ('last_server_seq', ?)").run(String(seq));
+}
+function getLastSyncTime(db) {
+  const row = db.prepare("SELECT value FROM sync_meta WHERE key = 'last_sync'").get();
+  return row?.value ?? null;
+}
+function setLastSyncTime(db) {
+  db.prepare("INSERT OR REPLACE INTO sync_meta (key, value) VALUES ('last_sync', ?)").run((/* @__PURE__ */ new Date()).toISOString());
+}
+function getPendingCount(db) {
+  const row = db.prepare("SELECT COUNT(*) as c FROM changelog WHERE synced = 0").get();
+  return row.c;
+}
+
+// src/core/sync/conflict.ts
+import fs8 from "fs";
+import path8 from "path";
+var CONFLICTS_DIR = ".granite/conflicts";
+function getConflictsDir(vaultRoot) {
+  const dir = path8.join(vaultRoot, CONFLICTS_DIR);
+  fs8.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function detectConflict(localNote, remoteChange) {
+  if (remoteChange.operation === "delete") return false;
+  if (!remoteChange.frontmatter) return false;
+  const localModified = new Date(localNote.frontmatter.modified).getTime();
+  const remoteModified = new Date(remoteChange.frontmatter.modified).getTime();
+  return localModified !== remoteModified && remoteChange.checksum !== "";
+}
+function resolveConflict(vaultRoot, localNote, remoteChange, deviceId) {
+  if (!remoteChange.frontmatter || remoteChange.body === void 0) return null;
+  const localModified = new Date(localNote.frontmatter.modified).getTime();
+  const remoteModified = new Date(remoteChange.frontmatter.modified).getTime();
+  const remoteWins = remoteModified > localModified;
+  if (remoteWins) {
+    const conflictFile2 = saveConflictBackup(vaultRoot, localNote, deviceId);
+    return {
+      note_id: localNote.frontmatter.id,
+      local_modified: localNote.frontmatter.modified,
+      remote_modified: remoteChange.frontmatter.modified,
+      resolved: true,
+      conflict_file: conflictFile2
+    };
+  }
+  const conflictFile = saveRemoteConflictBackup(vaultRoot, remoteChange);
+  return {
+    note_id: localNote.frontmatter.id,
+    local_modified: localNote.frontmatter.modified,
+    remote_modified: remoteChange.frontmatter.modified,
+    resolved: true,
+    conflict_file: conflictFile
+  };
+}
+function saveConflictBackup(vaultRoot, note, deviceId) {
+  const conflictsDir = getConflictsDir(vaultRoot);
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const filename = `${note.frontmatter.id}_${deviceId}_${timestamp}.md`;
+  const filePath = path8.join(conflictsDir, filename);
+  const content = serializeFrontmatter(note.frontmatter, note.body);
+  fs8.writeFileSync(filePath, content, "utf-8");
+  return filePath;
+}
+function saveRemoteConflictBackup(vaultRoot, change) {
+  const conflictsDir = getConflictsDir(vaultRoot);
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const filename = `${change.note_id}_remote_${timestamp}.md`;
+  const filePath = path8.join(conflictsDir, filename);
+  if (change.frontmatter && change.body !== void 0) {
+    const content = serializeFrontmatter(change.frontmatter, change.body);
+    fs8.writeFileSync(filePath, content, "utf-8");
+  }
+  return filePath;
+}
+function listConflicts(vaultRoot) {
+  const conflictsDir = path8.join(vaultRoot, CONFLICTS_DIR);
+  if (!fs8.existsSync(conflictsDir)) return [];
+  return fs8.readdirSync(conflictsDir).filter((f) => f.endsWith(".md")).map((f) => path8.join(conflictsDir, f));
+}
+function clearResolvedConflicts(vaultRoot) {
+  const files = listConflicts(vaultRoot);
+  for (const f of files) {
+    fs8.unlinkSync(f);
+  }
+  return files.length;
+}
+
+// src/core/sync/manager.ts
+var SyncManager = class {
+  vaultRoot;
+  config;
+  syncConfig;
+  client;
+  deviceId;
+  constructor(vaultRoot, config) {
+    if (!config.sync?.enabled) {
+      throw new Error("Sync is not enabled. Add a sync section to granite.yml.");
+    }
+    this.vaultRoot = vaultRoot;
+    this.config = config;
+    this.syncConfig = config.sync;
+    this.client = new SyncClient(this.syncConfig);
+    this.deviceId = getDeviceId(vaultRoot);
+  }
+  /**
+   * Track a local mutation and push it in the background (fire-and-forget).
+   * This is the hook called after every note create/update/delete.
+   */
+  trackAndPush(note, operation) {
+    const db = openSyncDb(this.vaultRoot);
+    try {
+      const content = fs9.existsSync(note.filepath) ? fs9.readFileSync(note.filepath, "utf-8") : "";
+      recordChange(db, note.frontmatter.id, operation, this.deviceId, content);
+    } finally {
+      db.close();
+    }
+    this.push().catch(() => {
+    });
+  }
+  /**
+   * Push all pending local changes to the relay server.
+   */
+  async push() {
+    const db = openSyncDb(this.vaultRoot);
+    try {
+      const pending = getPendingChanges(db);
+      if (pending.length === 0) {
+        return { pushed: 0, server_seq: getLastServerSeq(db) };
+      }
+      const changes = [];
+      for (const entry of pending) {
+        const note = this.findNoteById(entry.note_id);
+        changes.push({
+          note_id: entry.note_id,
+          operation: entry.operation,
+          timestamp: entry.timestamp,
+          checksum: entry.checksum,
+          slug: note?.slug ?? "",
+          frontmatter: note?.frontmatter,
+          body: note?.body
+        });
+      }
+      const lastSeq = getLastServerSeq(db);
+      const result = await this.client.push({
+        device_id: this.deviceId,
+        last_server_seq: lastSeq,
+        changes
+      });
+      const maxSeq = Math.max(...pending.map((p) => p.seq));
+      markChangesSynced(db, maxSeq);
+      setLastServerSeq(db, result.server_seq);
+      setLastSyncTime(db);
+      return { pushed: result.accepted, server_seq: result.server_seq };
+    } finally {
+      db.close();
+    }
+  }
+  /**
+   * Pull remote changes and apply them locally.
+   */
+  async pull() {
+    const db = openSyncDb(this.vaultRoot);
+    try {
+      const lastSeq = getLastServerSeq(db);
+      const response = await this.client.pull(lastSeq, this.deviceId);
+      let applied = 0;
+      let conflicts = 0;
+      for (const change of response.changes) {
+        const result = this.applyRemoteChange(change);
+        if (result === "applied") applied++;
+        if (result === "conflict") conflicts++;
+      }
+      setLastServerSeq(db, response.server_seq);
+      setLastSyncTime(db);
+      return { applied, conflicts };
+    } finally {
+      db.close();
+    }
+  }
+  /**
+   * Quick pull with a tight timeout — used before read commands.
+   * Returns silently if server is unreachable.
+   */
+  async quickPull() {
+    const db = openSyncDb(this.vaultRoot);
+    try {
+      const lastSeq = getLastServerSeq(db);
+      const response = await this.client.quickPull(lastSeq, this.deviceId);
+      if (!response) return;
+      for (const change of response.changes) {
+        this.applyRemoteChange(change);
+      }
+      setLastServerSeq(db, response.server_seq);
+      setLastSyncTime(db);
+    } finally {
+      db.close();
+    }
+  }
+  /**
+   * Full bidirectional sync: push then pull.
+   */
+  async sync() {
+    const pushResult = await this.push();
+    const pullResult = await this.pull();
+    return {
+      pushed: pushResult.pushed,
+      pulled: pullResult.applied,
+      conflicts: pullResult.conflicts
+    };
+  }
+  /**
+   * Get current sync status.
+   */
+  status() {
+    const db = openSyncDb(this.vaultRoot);
+    try {
+      const deviceInfo = getOrCreateDeviceId(this.vaultRoot);
+      return {
+        device_id: deviceInfo.device_id,
+        device_name: deviceInfo.device_name,
+        last_sync: getLastSyncTime(db),
+        pending_changes: getPendingCount(db),
+        server_seq: getLastServerSeq(db)
+      };
+    } finally {
+      db.close();
+    }
+  }
+  /**
+   * List connected devices.
+   */
+  async devices() {
+    return this.client.listDevices();
+  }
+  /**
+   * List unresolved conflict files.
+   */
+  conflicts() {
+    return listConflicts(this.vaultRoot);
+  }
+  applyRemoteChange(change) {
+    switch (change.operation) {
+      case "create":
+        return this.applyRemoteCreate(change);
+      case "update":
+        return this.applyRemoteUpdate(change);
+      case "delete":
+        return this.applyRemoteDelete(change);
+      default:
+        return "skipped";
+    }
+  }
+  applyRemoteCreate(change) {
+    if (!change.frontmatter || change.body === void 0) return "skipped";
+    const existing = this.findNoteById(change.note_id);
+    if (existing) return "skipped";
+    const typeConfig = this.config.note_types[change.frontmatter.type];
+    if (!typeConfig) return "skipped";
+    const folder = path9.join(this.vaultRoot, typeConfig.folder);
+    fs9.mkdirSync(folder, { recursive: true });
+    const slug = change.slug || change.note_id;
+    const filepath = path9.join(folder, `${slug}.md`);
+    const content = serializeFrontmatter(change.frontmatter, change.body);
+    fs9.writeFileSync(filepath, content, "utf-8");
+    return "applied";
+  }
+  applyRemoteUpdate(change) {
+    if (!change.frontmatter || change.body === void 0) return "skipped";
+    const localNote = this.findNoteById(change.note_id);
+    if (!localNote) {
+      return this.applyRemoteCreate(change);
+    }
+    const localContent = fs9.readFileSync(localNote.filepath, "utf-8");
+    const localChecksum = computeChecksum(localContent);
+    if (localChecksum === change.checksum) return "skipped";
+    if (detectConflict(localNote, change)) {
+      resolveConflict(this.vaultRoot, localNote, change, this.deviceId);
+      const localTime = new Date(localNote.frontmatter.modified).getTime();
+      const remoteTime = new Date(change.frontmatter.modified).getTime();
+      if (remoteTime > localTime) {
+        const content2 = serializeFrontmatter(change.frontmatter, change.body);
+        fs9.writeFileSync(localNote.filepath, content2, "utf-8");
+      }
+      return "conflict";
+    }
+    const content = serializeFrontmatter(change.frontmatter, change.body);
+    fs9.writeFileSync(localNote.filepath, content, "utf-8");
+    return "applied";
+  }
+  applyRemoteDelete(change) {
+    const localNote = this.findNoteById(change.note_id);
+    if (!localNote) return "skipped";
+    if (fs9.existsSync(localNote.filepath)) {
+      fs9.unlinkSync(localNote.filepath);
+    }
+    return "applied";
+  }
+  findNoteById(noteId) {
+    const allNotes = listNotes(this.vaultRoot, this.config);
+    return allNotes.find((n) => n.frontmatter.id === noteId) ?? null;
+  }
+};
+function getSyncManager(vaultRoot, config) {
+  if (!config.sync?.enabled) return null;
+  try {
+    return new SyncManager(vaultRoot, config);
+  } catch {
+    return null;
+  }
+}
+
 // src/commands/new.ts
 function newNote(title, options) {
   const vaultRoot = requireVaultRoot();
@@ -1207,17 +1694,19 @@ function newNote(title, options) {
   if (options.source || options.status) {
     if (options.source) validateSource(options.source);
     if (options.status) validateStatus(options.status);
-    const raw = fs6.readFileSync(note.filepath, "utf-8");
+    const raw = fs10.readFileSync(note.filepath, "utf-8");
     const { frontmatter, body } = parseFrontmatter(raw);
     if (options.source) frontmatter.source = options.source;
     if (options.status) frontmatter.status = options.status;
-    fs6.writeFileSync(note.filepath, serializeFrontmatter(frontmatter, body), "utf-8");
+    fs10.writeFileSync(note.filepath, serializeFrontmatter(frontmatter, body), "utf-8");
     note.frontmatter = frontmatter;
   }
   const recommendationStrategy = typeConfig?.slug_format === "date" ? "incremental" : "rebuild";
   const recommendations = recommendNote(vaultRoot, config, note, { strategy: recommendationStrategy });
   const lines = note.body.split("\n").length;
   const overLimit = typeConfig && typeConfig.line_limit && lines > typeConfig.line_limit;
+  const sync = getSyncManager(vaultRoot, config);
+  sync?.trackAndPush(note, "create");
   if (options.json) {
     console.log(jsonSuccess({
       slug: note.slug,
@@ -1255,7 +1744,7 @@ function newNote(title, options) {
 }
 
 // src/commands/add.ts
-import fs7 from "fs";
+import fs11 from "fs";
 function addNote(text, options = {}) {
   const vaultRoot = requireVaultRoot();
   const config = loadConfig(vaultRoot);
@@ -1264,9 +1753,9 @@ function addNote(text, options = {}) {
   if (text) {
     content = text;
   } else if (!process.stdin.isTTY) {
-    content = fs7.readFileSync(0, "utf-8").trim();
+    content = fs11.readFileSync(0, "utf-8").trim();
   } else {
-    console.error('Usage: mem add "some text" or echo "text" | mem add');
+    console.error('Usage: granite add "some text" or echo "text" | granite add');
     process.exit(1);
   }
   if (!content) {
@@ -1277,6 +1766,8 @@ function addNote(text, options = {}) {
   const title = firstLine.length > 60 ? firstLine.slice(0, 60).trim() + "..." : firstLine;
   const note = createNote(vaultRoot, config, typeName, title, content + "\n");
   const recommendations = recommendNote(vaultRoot, config, note, { strategy: "incremental" });
+  const sync = getSyncManager(vaultRoot, config);
+  sync?.trackAndPush(note, "create");
   if (options.json) {
     console.log(jsonSuccess({
       slug: note.slug,
@@ -1313,7 +1804,7 @@ function openNote(slug) {
 }
 
 // src/commands/show.ts
-import fs8 from "fs";
+import fs12 from "fs";
 function showCommand(slug, options) {
   const vaultRoot = requireVaultRoot();
   const config = loadConfig(vaultRoot);
@@ -1349,12 +1840,13 @@ function showCommand(slug, options) {
   console.log(`# ${note.frontmatter.title}  (${note.slug})`);
   console.log(`# type: ${note.frontmatter.type}  |  modified: ${note.frontmatter.modified.slice(0, 10)}`);
   console.log("");
-  const content = fs8.readFileSync(note.filepath, "utf-8");
+  const content = fs12.readFileSync(note.filepath, "utf-8");
   console.log(content);
 }
 
 // src/core/search.ts
-function searchNotes(db, query) {
+function searchNotes(db, query, limit = 20) {
+  const cappedLimit = Math.max(1, Math.min(limit, 100));
   const stmt = db.prepare(`
     SELECT
       n.slug,
@@ -1365,9 +1857,9 @@ function searchNotes(db, query) {
     JOIN notes n ON n.rowid = notes_fts.rowid
     WHERE notes_fts MATCH ?
     ORDER BY rank
-    LIMIT 20
+    LIMIT ?
   `);
-  const rows = stmt.all(query);
+  const rows = stmt.all(query, cappedLimit);
   return rows.map((r) => ({
     slug: r.slug,
     title: r.title,
@@ -1506,14 +1998,14 @@ function recommendCommand(slug, options) {
 }
 
 // src/core/doctor.ts
-import fs9 from "fs";
-import path6 from "path";
+import fs13 from "fs";
+import path10 from "path";
 function runDoctor(vaultRoot, config, db) {
   const issues = [];
   const notes = listNotes(vaultRoot, config);
   for (const [name, typeConfig] of Object.entries(config.note_types)) {
-    const folder = path6.join(vaultRoot, typeConfig.folder);
-    if (!fs9.existsSync(folder)) {
+    const folder = path10.join(vaultRoot, typeConfig.folder);
+    if (!fs13.existsSync(folder)) {
       issues.push({
         level: "error",
         file: `granite.yml`,
@@ -1648,8 +2140,8 @@ ${errors.length} error(s), ${warnings.length} warning(s), ${infos.length} info(s
 // src/web/server.ts
 import { Hono } from "hono";
 import { serve } from "@hono/node-server";
-import path7 from "path";
-import fs10 from "fs";
+import path11 from "path";
+import fs14 from "fs";
 function createApp(vaultRoot, config) {
   const app = new Hono();
   app.get("/api/notes", (c) => {
@@ -1718,6 +2210,8 @@ function createApp(vaultRoot, config) {
     }
     try {
       const note = createNote(vaultRoot, config, type, title, noteBody || void 0);
+      const sync = getSyncManager(vaultRoot, config);
+      sync?.trackAndPush(note, "create");
       return c.json({
         slug: note.slug,
         title: note.frontmatter.title,
@@ -1735,17 +2229,17 @@ function createApp(vaultRoot, config) {
     db.close();
     return c.json({ nodes, edges });
   });
-  const publicDir = path7.join(import.meta.dirname, "public");
+  const publicDir = path11.join(import.meta.dirname, "public");
   app.get("/*", (c) => {
     const reqPath = c.req.path === "/" ? "/index.html" : c.req.path;
-    const filePath = path7.join(publicDir, reqPath);
-    if (!fs10.existsSync(filePath)) {
-      const indexPath = path7.join(publicDir, "index.html");
-      const html = fs10.readFileSync(indexPath, "utf-8");
+    const filePath = path11.join(publicDir, reqPath);
+    if (!fs14.existsSync(filePath)) {
+      const indexPath = path11.join(publicDir, "index.html");
+      const html = fs14.readFileSync(indexPath, "utf-8");
       return c.html(html);
     }
-    const content = fs10.readFileSync(filePath);
-    const ext = path7.extname(filePath);
+    const content = fs14.readFileSync(filePath);
+    const ext = path11.extname(filePath);
     const mimeTypes = {
       ".html": "text/html",
       ".css": "text/css",
@@ -1791,7 +2285,7 @@ function typesCommand() {
   }
   console.log(`Default type: ${config.defaults.note_type}`);
   console.log(`
-Usage: mem new <type> <title>`);
+Usage: granite new <type> <title>`);
 }
 
 // src/commands/list.ts
@@ -1881,7 +2375,7 @@ ${notes.length} note(s)`);
 }
 
 // src/commands/edit.ts
-import fs11 from "fs";
+import fs15 from "fs";
 import { execSync as execSync2 } from "child_process";
 function editCommand(slug, options) {
   const vaultRoot = requireVaultRoot();
@@ -1893,7 +2387,7 @@ function editCommand(slug, options) {
   }
   const hasFlags = options.body !== void 0 || options.append !== void 0 || options.title !== void 0 || options.tag !== void 0 || options.alias !== void 0 || options.status !== void 0 || options.source !== void 0;
   if (hasFlags) {
-    let { frontmatter, body } = parseFrontmatter(fs11.readFileSync(note.filepath, "utf-8"));
+    let { frontmatter, body } = parseFrontmatter(fs15.readFileSync(note.filepath, "utf-8"));
     if (options.title) {
       frontmatter.title = options.title;
     }
@@ -1924,24 +2418,30 @@ function editCommand(slug, options) {
       body = body.trimEnd() + "\n" + options.append + "\n";
     }
     frontmatter.modified = (/* @__PURE__ */ new Date()).toISOString();
-    fs11.writeFileSync(note.filepath, serializeFrontmatter(frontmatter, body), "utf-8");
+    fs15.writeFileSync(note.filepath, serializeFrontmatter(frontmatter, body), "utf-8");
+    const sync = getSyncManager(vaultRoot, config);
+    const updatedForSync = readNote(note.filepath);
+    sync?.trackAndPush(updatedForSync, "update");
     console.log(note.filepath);
     const recommendationStrategy = options.title !== void 0 || options.alias !== void 0 ? "rebuild" : "incremental";
     printRecommendations(vaultRoot, config, note.filepath, recommendationStrategy);
   } else {
     const editor = process.env.EDITOR || "vi";
-    const statBefore = fs11.statSync(note.filepath).mtimeMs;
+    const statBefore = fs15.statSync(note.filepath).mtimeMs;
     try {
       execSync2(`${editor} "${note.filepath}"`, { stdio: "inherit" });
     } catch {
       console.error(`Failed to open editor: ${editor}`);
       process.exit(1);
     }
-    const statAfter = fs11.statSync(note.filepath).mtimeMs;
+    const statAfter = fs15.statSync(note.filepath).mtimeMs;
     if (statAfter !== statBefore) {
-      const { frontmatter, body } = parseFrontmatter(fs11.readFileSync(note.filepath, "utf-8"));
+      const { frontmatter, body } = parseFrontmatter(fs15.readFileSync(note.filepath, "utf-8"));
       frontmatter.modified = (/* @__PURE__ */ new Date()).toISOString();
-      fs11.writeFileSync(note.filepath, serializeFrontmatter(frontmatter, body), "utf-8");
+      fs15.writeFileSync(note.filepath, serializeFrontmatter(frontmatter, body), "utf-8");
+      const sync = getSyncManager(vaultRoot, config);
+      const updatedForSync = readNote(note.filepath);
+      sync?.trackAndPush(updatedForSync, "update");
       console.log(`Updated: ${note.filepath}`);
       printRecommendations(vaultRoot, config, note.filepath, "rebuild");
     }
@@ -1959,9 +2459,1185 @@ function printRecommendations(vaultRoot, config, filepath, strategy) {
   }
 }
 
+// src/commands/mcp.ts
+import path13 from "path";
+
+// src/mcp/server.ts
+import { serve as serve2 } from "@hono/node-server";
+import { Hono as Hono2 } from "hono";
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+import * as z from "zod/v4";
+
+// src/version.ts
+var GRANITE_VERSION = "0.1.2";
+
+// src/mcp/server.ts
+var readOnlyAnnotations = {
+  readOnlyHint: true,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: false
+};
+var writeAnnotations = {
+  readOnlyHint: false,
+  destructiveHint: false,
+  idempotentHint: false,
+  openWorldHint: false
+};
+var fieldDefinitionSchema = z.object({
+  type: z.enum(["text", "date", "number", "boolean", "wikilink", "list", "enum"]),
+  of: z.string().optional(),
+  options: z.array(z.string()).optional(),
+  required: z.boolean().optional(),
+  default: z.string().optional(),
+  description: z.string().optional()
+});
+var noteTypeInfoSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  folder: z.string(),
+  line_limit: z.number(),
+  warn_only: z.boolean(),
+  slug_format: z.enum(["title", "date"]),
+  instructions: z.string().optional(),
+  fields: z.record(z.string(), fieldDefinitionSchema).optional()
+});
+var noteSummarySchema = z.object({
+  slug: z.string(),
+  title: z.string(),
+  type: z.string(),
+  created: z.string(),
+  modified: z.string(),
+  tags: z.array(z.string()),
+  aliases: z.array(z.string()),
+  status: z.enum(["inbox", "active", "archived"]),
+  source: z.enum(["human", "agent", "extraction"]),
+  filepath: z.string(),
+  resource_uri: z.string()
+});
+var wikiLinkSchema = z.object({
+  raw: z.string(),
+  target: z.string(),
+  display: z.string(),
+  resolved: z.boolean(),
+  resolved_slug: z.string().optional()
+});
+var noteDetailsSchema = noteSummarySchema.extend({
+  body: z.string(),
+  frontmatter: z.record(z.string(), z.unknown()),
+  outgoing_links: z.array(wikiLinkSchema)
+});
+var searchResultSchema = z.object({
+  slug: z.string(),
+  title: z.string(),
+  snippet: z.string(),
+  score: z.number()
+});
+var backlinkSchema = z.object({
+  source_slug: z.string(),
+  source_title: z.string(),
+  context: z.string()
+});
+var linkSuggestionSchema = z.object({
+  target_slug: z.string(),
+  target_title: z.string(),
+  mentions: z.number()
+});
+var recommendationSchema = z.object({
+  additions: z.array(z.object({ text: z.string() })),
+  links: z.array(z.object({
+    slug: z.string(),
+    title: z.string(),
+    type: z.string(),
+    reason: z.string(),
+    source: z.enum(["mention", "search"])
+  })),
+  tags: z.array(z.object({
+    tag: z.string(),
+    weight: z.number(),
+    source_slugs: z.array(z.string())
+  })),
+  next_steps: z.array(z.object({
+    type: z.string(),
+    title_hint: z.string().optional(),
+    reason: z.string()
+  }))
+});
+var doctorIssueSchema = z.object({
+  level: z.enum(["error", "warning", "info"]),
+  file: z.string(),
+  message: z.string()
+});
+var vaultOverviewSchema = z.object({
+  vault_root: z.string(),
+  vault_name: z.string(),
+  default_type: z.string(),
+  auto_rebuild: z.boolean(),
+  index_last_rebuild: z.string().optional(),
+  note_count: z.number(),
+  notes_by_type: z.record(z.string(), z.number()),
+  recent_notes: z.array(noteSummarySchema)
+});
+function createGraniteMcpServer(runtime) {
+  const server = new McpServer(
+    {
+      name: "granite",
+      version: GRANITE_VERSION,
+      title: "Granite MCP Server"
+    },
+    {
+      capabilities: { logging: {} },
+      instructions: [
+        "Granite exposes a local-first markdown vault.",
+        "Prefer read tools and resources first, then write with granite_create_note or granite_update_note.",
+        "Resources are read-only views; notes live on disk and the SQLite index is derived state.",
+        "Use granite_recommend_note_actions to preserve Granite\u2019s capture -> link -> recommend loop."
+      ].join(" ")
+    }
+  );
+  registerTools(server, runtime);
+  registerResources(server, runtime);
+  registerPrompts(server, runtime);
+  return server;
+}
+async function startGraniteMcpStdioServer(runtime) {
+  const server = createGraniteMcpServer(runtime);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error(`Granite MCP server listening on stdio for ${runtime.vaultRoot}`);
+}
+function startGraniteMcpHttpServer(runtime, options) {
+  const app = createGraniteMcpHttpApp(runtime, options);
+  console.error(`Granite MCP server listening on http://${options.host}:${options.port}/mcp`);
+  console.error(`Health check: http://${options.host}:${options.port}/health`);
+  console.error(`Vault: ${runtime.vaultRoot}`);
+  serve2({
+    fetch: app.fetch,
+    hostname: options.host,
+    port: options.port
+  });
+}
+async function withResponseCleanup(response, cleanup) {
+  let cleanedUp = false;
+  const cleanupOnce = async () => {
+    if (cleanedUp) {
+      return;
+    }
+    cleanedUp = true;
+    await cleanup();
+  };
+  if (!response.body) {
+    await cleanupOnce();
+    return response;
+  }
+  const reader = response.body.getReader();
+  const wrappedBody = new ReadableStream({
+    async pull(controller) {
+      try {
+        const { done, value } = await reader.read();
+        if (done) {
+          controller.close();
+          await cleanupOnce();
+          return;
+        }
+        controller.enqueue(value);
+      } catch (error) {
+        controller.error(error);
+        await cleanupOnce();
+      }
+    },
+    async cancel(reason) {
+      try {
+        await reader.cancel(reason);
+      } finally {
+        await cleanupOnce();
+      }
+    }
+  });
+  return new Response(wrappedBody, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+}
+function registerTools(server, runtime) {
+  server.registerTool("granite_get_vault_overview", {
+    title: "Granite Vault Overview",
+    description: "Summarize the current Granite vault, including counts by type and recent notes.",
+    inputSchema: {
+      recent_limit: z.number().int().min(1).max(20).optional().describe("How many recent notes to include. Defaults to 10.")
+    },
+    outputSchema: vaultOverviewSchema,
+    annotations: readOnlyAnnotations
+  }, async ({ recent_limit }) => {
+    const overview = runtime.getVaultOverview(recent_limit ?? 10);
+    return toolResult(
+      overview,
+      `Vault "${overview.vault_name}" with ${overview.note_count} notes.`
+    );
+  });
+  server.registerTool("granite_list_note_types", {
+    title: "Granite Note Types",
+    description: "List the note types configured in the vault.",
+    outputSchema: z.object({
+      default_type: z.string(),
+      note_types: z.array(noteTypeInfoSchema)
+    }),
+    annotations: readOnlyAnnotations
+  }, async () => {
+    const noteTypes = runtime.listNoteTypes();
+    return toolResult({
+      default_type: runtime.getDefaultNoteType(),
+      note_types: noteTypes
+    }, `Loaded ${noteTypes.length} Granite note types.`);
+  });
+  server.registerTool("granite_list_notes", {
+    title: "List Granite Notes",
+    description: "List notes from the Granite vault with optional filters.",
+    inputSchema: {
+      type: z.string().optional().describe("Filter by note type."),
+      status: z.enum(["inbox", "active", "archived"]).optional().describe("Filter by note status."),
+      source: z.enum(["human", "agent", "extraction"]).optional().describe("Filter by note source."),
+      since: z.string().optional().describe("Only notes modified on or after this ISO or YYYY-MM-DD value."),
+      limit: z.number().int().min(1).max(200).optional().describe("Maximum number of notes to return. Defaults to 25.")
+    },
+    outputSchema: z.object({
+      notes: z.array(noteSummarySchema),
+      total: z.number()
+    }),
+    annotations: readOnlyAnnotations
+  }, async (args) => {
+    const notes = runtime.listNotes(args);
+    return toolResult({
+      notes,
+      total: notes.length
+    }, `Returned ${notes.length} note(s).`);
+  });
+  server.registerTool("granite_get_note", {
+    title: "Get Granite Note",
+    description: "Read a Granite note by slug, including frontmatter, body, and resolved outgoing links.",
+    inputSchema: {
+      slug: z.string().describe("The note slug.")
+    },
+    outputSchema: noteDetailsSchema,
+    annotations: readOnlyAnnotations
+  }, async ({ slug }) => {
+    const note = runtime.getNote(slug);
+    return {
+      ...toolResult(note, `Loaded "${note.title}" (${note.slug}).`),
+      content: [
+        { type: "text", text: `Loaded "${note.title}" (${note.slug}).` },
+        createNoteResourceLink(note.title, note.resource_uri)
+      ]
+    };
+  });
+  server.registerTool("granite_search_notes", {
+    title: "Search Granite Notes",
+    description: "Run full-text search against the Granite index.",
+    inputSchema: {
+      query: z.string().describe("Full-text query for the SQLite FTS index."),
+      limit: z.number().int().min(1).max(50).optional().describe("Maximum number of search results. Defaults to 10.")
+    },
+    outputSchema: z.object({
+      query: z.string(),
+      results: z.array(searchResultSchema)
+    }),
+    annotations: readOnlyAnnotations
+  }, async ({ query, limit }) => {
+    const results = runtime.search(query, limit ?? 10);
+    return toolResult({
+      query,
+      results
+    }, `Found ${results.length} result(s) for "${query}".`);
+  });
+  server.registerTool("granite_create_note", {
+    title: "Create Granite Note",
+    description: "Create a new note in the Granite vault.",
+    inputSchema: {
+      title: z.string().describe("Note title."),
+      type: z.string().optional().describe("Note type. Defaults to the vault default type."),
+      body: z.string().optional().describe("Optional note body. If omitted, Granite uses the type template."),
+      tags: z.array(z.string()).optional().describe("Tags to add immediately."),
+      aliases: z.array(z.string()).optional().describe("Aliases to add immediately."),
+      status: z.enum(["inbox", "active", "archived"]).optional().describe("Initial note status."),
+      source: z.enum(["human", "agent", "extraction"]).optional().describe("Initial note source.")
+    },
+    outputSchema: z.object({
+      note: noteDetailsSchema,
+      recommendations: recommendationSchema
+    }),
+    annotations: writeAnnotations
+  }, async (args) => {
+    const result = runtime.createNote(args);
+    return toolResult(result, `Created "${result.note.title}" (${result.note.slug}).`);
+  });
+  server.registerTool("granite_capture_note", {
+    title: "Capture Granite Note",
+    description: "Quick-capture a note from free-form text, similar to granite add.",
+    inputSchema: {
+      text: z.string().describe("Raw capture text."),
+      type: z.string().optional().describe("Optional note type override. Defaults to the vault default type."),
+      tags: z.array(z.string()).optional().describe("Tags to add immediately."),
+      aliases: z.array(z.string()).optional().describe("Aliases to add immediately."),
+      status: z.enum(["inbox", "active", "archived"]).optional().describe("Initial note status."),
+      source: z.enum(["human", "agent", "extraction"]).optional().describe("Initial note source.")
+    },
+    outputSchema: z.object({
+      note: noteDetailsSchema,
+      recommendations: recommendationSchema
+    }),
+    annotations: writeAnnotations
+  }, async (args) => {
+    const result = runtime.captureNote(args);
+    return toolResult(result, `Captured "${result.note.title}" (${result.note.slug}).`);
+  });
+  server.registerTool("granite_update_note", {
+    title: "Update Granite Note",
+    description: "Update frontmatter or body fields for an existing Granite note.",
+    inputSchema: {
+      slug: z.string().describe("Slug of the note to update."),
+      title: z.string().optional().describe("Replace the note title."),
+      body: z.string().optional().describe("Replace the entire note body."),
+      append: z.string().optional().describe("Append text to the existing note body."),
+      tags: z.array(z.string()).optional().describe("Tags to add."),
+      aliases: z.array(z.string()).optional().describe("Aliases to add."),
+      status: z.enum(["inbox", "active", "archived"]).optional().describe("New note status."),
+      source: z.enum(["human", "agent", "extraction"]).optional().describe("New note source.")
+    },
+    outputSchema: z.object({
+      note: noteDetailsSchema,
+      recommendations: recommendationSchema
+    }),
+    annotations: writeAnnotations
+  }, async ({ slug, ...updates }) => {
+    const result = runtime.updateNote(slug, updates);
+    return toolResult(result, `Updated "${result.note.title}" (${result.note.slug}).`);
+  });
+  server.registerTool("granite_get_backlinks", {
+    title: "Granite Backlinks",
+    description: "List notes that link to a given Granite note.",
+    inputSchema: {
+      slug: z.string().describe("Slug of the target note.")
+    },
+    outputSchema: z.object({
+      slug: z.string(),
+      backlinks: z.array(backlinkSchema)
+    }),
+    annotations: readOnlyAnnotations
+  }, async ({ slug }) => {
+    const backlinks = runtime.getBacklinks(slug);
+    return toolResult({
+      slug,
+      backlinks
+    }, `Found ${backlinks.length} backlink(s) for "${slug}".`);
+  });
+  server.registerTool("granite_suggest_links", {
+    title: "Suggest Granite Links",
+    description: "Suggest missing wikilinks for a Granite note based on mentions.",
+    inputSchema: {
+      slug: z.string().describe("Slug of the note to inspect.")
+    },
+    outputSchema: z.object({
+      slug: z.string(),
+      suggestions: z.array(linkSuggestionSchema)
+    }),
+    annotations: readOnlyAnnotations
+  }, async ({ slug }) => {
+    const suggestions = runtime.suggestLinks(slug);
+    return toolResult({
+      slug,
+      suggestions
+    }, `Found ${suggestions.length} suggested link(s) for "${slug}".`);
+  });
+  server.registerTool("granite_recommend_note_actions", {
+    title: "Recommend Granite Actions",
+    description: "Recommend follow-up links, tags, additions, and next notes for a Granite note.",
+    inputSchema: {
+      slug: z.string().describe("Slug of the note to analyze.")
+    },
+    outputSchema: z.object({
+      slug: z.string(),
+      recommendations: recommendationSchema
+    }),
+    annotations: readOnlyAnnotations
+  }, async ({ slug }) => {
+    const recommendations = runtime.recommend(slug);
+    return toolResult({
+      slug,
+      recommendations
+    }, recommendationSummary(recommendations));
+  });
+  server.registerTool("granite_run_doctor", {
+    title: "Run Granite Doctor",
+    description: "Validate vault health and report structural issues.",
+    outputSchema: z.object({
+      issues: z.array(doctorIssueSchema),
+      counts: z.object({
+        errors: z.number(),
+        warnings: z.number(),
+        info: z.number()
+      })
+    }),
+    annotations: readOnlyAnnotations
+  }, async () => {
+    const result = runtime.runDoctor();
+    return toolResult(
+      result,
+      `${result.counts.errors} error(s), ${result.counts.warnings} warning(s), ${result.counts.info} info item(s).`
+    );
+  });
+}
+function registerResources(server, runtime) {
+  server.registerResource("granite-vault-config", "granite://vault/config", {
+    title: "Granite Config",
+    description: "Raw granite.yml configuration for the current vault.",
+    mimeType: "text/yaml"
+  }, async () => ({
+    contents: [{
+      uri: "granite://vault/config",
+      text: runtime.readVaultConfigRaw(),
+      mimeType: "text/yaml"
+    }]
+  }));
+  server.registerResource("granite-vault-overview", "granite://vault/overview", {
+    title: "Granite Vault Overview",
+    description: "Structured summary of the current vault.",
+    mimeType: "application/json"
+  }, async () => ({
+    contents: [{
+      uri: "granite://vault/overview",
+      text: runtime.readVaultOverviewJson(),
+      mimeType: "application/json"
+    }]
+  }));
+  server.registerResource("granite-note-types", "granite://vault/types", {
+    title: "Granite Note Types",
+    description: "Structured list of the note types configured in the current vault.",
+    mimeType: "application/json"
+  }, async () => ({
+    contents: [{
+      uri: "granite://vault/types",
+      text: runtime.readVaultTypesJson(),
+      mimeType: "application/json"
+    }]
+  }));
+  const noteTemplate = new ResourceTemplate("granite://notes/{slug}", {
+    list: void 0,
+    complete: {
+      slug: async (value) => runtime.completeSlugs(value)
+    }
+  });
+  server.registerResource("granite-note", noteTemplate, {
+    title: "Granite Note",
+    description: "Read a Granite note as markdown with YAML frontmatter.",
+    mimeType: "text/markdown"
+  }, async (uri, variables) => {
+    const variable = variables.slug;
+    const slug = Array.isArray(variable) ? variable[0] : variable;
+    if (!slug) {
+      throw new Error("Resource URI is missing the note slug.");
+    }
+    return {
+      contents: [{
+        uri: uri.toString(),
+        text: runtime.readNoteMarkdown(decodeURIComponent(slug)),
+        mimeType: "text/markdown"
+      }]
+    };
+  });
+}
+function registerPrompts(server, runtime) {
+  server.registerPrompt("granite_refine_note", {
+    title: "Refine Granite Note",
+    description: "Create a prompt for turning a note into a cleaner permanent note draft.",
+    argsSchema: {
+      slug: z.string().describe("Slug of the note to refine.")
+    }
+  }, async ({ slug }) => {
+    const note = runtime.getNote(slug);
+    return {
+      description: `Refine ${note.slug} into a durable Granite note.`,
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: [
+              "Refine the attached Granite note into a durable, well-structured permanent note.",
+              "Keep the meaning intact, avoid inventing facts, preserve useful wikilinks, and use Granite-style headings when appropriate."
+            ].join(" ")
+          }
+        },
+        {
+          role: "user",
+          content: {
+            type: "resource",
+            resource: {
+              uri: note.resource_uri,
+              text: runtime.readNoteMarkdown(slug),
+              mimeType: "text/markdown"
+            }
+          }
+        }
+      ]
+    };
+  });
+  server.registerPrompt("granite_review_connections", {
+    title: "Review Granite Connections",
+    description: "Create a prompt for improving note links, tags, and next steps.",
+    argsSchema: {
+      slug: z.string().describe("Slug of the note to inspect.")
+    }
+  }, async ({ slug }) => {
+    const note = runtime.getNote(slug);
+    const backlinks = runtime.getBacklinks(slug);
+    const recommendations = runtime.recommend(slug);
+    return {
+      description: `Review the connections around ${note.slug}.`,
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: [
+              "Review this Granite note and propose better links, tags, and the most useful follow-up note.",
+              "Prefer concrete suggestions grounded in the vault context below."
+            ].join(" ")
+          }
+        },
+        {
+          role: "user",
+          content: {
+            type: "resource",
+            resource: {
+              uri: note.resource_uri,
+              text: runtime.readNoteMarkdown(slug),
+              mimeType: "text/markdown"
+            }
+          }
+        },
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: JSON.stringify({ backlinks, recommendations }, null, 2)
+          }
+        }
+      ]
+    };
+  });
+}
+function toolResult(structuredContent, summary) {
+  return {
+    content: [{ type: "text", text: summary }],
+    structuredContent: asStructuredContent(structuredContent)
+  };
+}
+function createNoteResourceLink(name, uri) {
+  return {
+    type: "resource_link",
+    name,
+    uri,
+    mimeType: "text/markdown",
+    description: "Read the markdown resource for this note."
+  };
+}
+function recommendationSummary(recommendations) {
+  return [
+    `${recommendations.links.length} link suggestion(s)`,
+    `${recommendations.tags.length} tag suggestion(s)`,
+    `${recommendations.next_steps.length} next-step suggestion(s)`
+  ].join(", ");
+}
+function asStructuredContent(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function createGraniteMcpHttpApp(runtime, options) {
+  const app = new Hono2();
+  const allowedHosts = buildAllowedHosts(options.host, options.port);
+  const allowedOrigins = buildAllowedOrigins(options.host, options.port, options.allowedOrigins ?? []);
+  app.use("/mcp", async (c, next) => {
+    const requestHost = (c.req.header("host") ?? "").toLowerCase();
+    if (allowedHosts.size > 0 && !allowedHosts.has(requestHost)) {
+      return c.json({
+        jsonrpc: "2.0",
+        error: { code: -32e3, message: "Forbidden host header." },
+        id: null
+      }, 403);
+    }
+    const origin = c.req.header("origin");
+    if (origin && !allowedOrigins.has(origin)) {
+      return c.json({
+        jsonrpc: "2.0",
+        error: { code: -32e3, message: "Forbidden origin." },
+        id: null
+      }, 403);
+    }
+    if (c.req.method === "OPTIONS") {
+      return new Response(null, {
+        status: 204,
+        headers: corsHeaders(origin, allowedOrigins)
+      });
+    }
+    await next();
+  });
+  app.get("/health", (c) => c.json({ status: "ok", name: "granite-mcp", version: GRANITE_VERSION }));
+  app.all("/mcp", async (c) => {
+    const origin = c.req.header("origin");
+    const server = createGraniteMcpServer(runtime);
+    const transport = new WebStandardStreamableHTTPServerTransport({
+      sessionIdGenerator: void 0,
+      enableJsonResponse: options.jsonResponse ?? false
+    });
+    try {
+      await server.connect(transport);
+      const response = await transport.handleRequest(c.req.raw);
+      const managedResponse = await withResponseCleanup(response, async () => {
+        await server.close();
+      });
+      return withCors(managedResponse, origin, allowedOrigins);
+    } catch (error) {
+      await server.close();
+      throw error;
+    }
+  });
+  return app;
+}
+function buildAllowedHosts(host, port) {
+  const normalizedHost = host.toLowerCase();
+  if (normalizedHost === "0.0.0.0" || normalizedHost === "::" || normalizedHost === "[::]") {
+    return /* @__PURE__ */ new Set();
+  }
+  const allowed = /* @__PURE__ */ new Set([`${normalizedHost}:${port}`]);
+  if (normalizedHost === "127.0.0.1" || normalizedHost === "localhost") {
+    allowed.add(`127.0.0.1:${port}`);
+    allowed.add(`localhost:${port}`);
+  }
+  if (normalizedHost === "::1" || normalizedHost === "[::1]") {
+    allowed.add(`[::1]:${port}`);
+  }
+  return allowed;
+}
+function buildAllowedOrigins(host, port, extraOrigins) {
+  const allowed = new Set(extraOrigins);
+  const normalizedHost = host.toLowerCase();
+  if (normalizedHost === "::1" || normalizedHost === "[::1]") {
+    allowed.add(`http://[::1]:${port}`);
+  } else if (normalizedHost !== "0.0.0.0" && normalizedHost !== "::" && normalizedHost !== "[::]") {
+    allowed.add(`http://${normalizedHost}:${port}`);
+  }
+  if (normalizedHost === "127.0.0.1" || normalizedHost === "localhost") {
+    allowed.add(`http://127.0.0.1:${port}`);
+    allowed.add(`http://localhost:${port}`);
+  }
+  return allowed;
+}
+function withCors(response, origin, allowedOrigins) {
+  const headers = new Headers(response.headers);
+  for (const [key, value] of corsHeaders(origin, allowedOrigins)) {
+    headers.set(key, value);
+  }
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+function corsHeaders(origin, allowedOrigins) {
+  const headers = new Headers();
+  if (origin && allowedOrigins.has(origin)) {
+    headers.set("Access-Control-Allow-Origin", origin);
+    headers.set("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+    headers.set("Access-Control-Allow-Headers", "Content-Type, MCP-Protocol-Version, Last-Event-ID");
+    headers.set("Access-Control-Expose-Headers", "MCP-Session-Id, MCP-Protocol-Version");
+    headers.set("Vary", "Origin");
+  }
+  return headers;
+}
+
+// src/mcp/runtime.ts
+import fs16 from "fs";
+import path12 from "path";
+var GraniteMcpRuntime = class {
+  vaultRoot;
+  config;
+  db;
+  indexCheckIntervalMs;
+  lastSignature;
+  lastIndexCheckAt = 0;
+  constructor(vaultRoot, options = {}) {
+    this.vaultRoot = path12.resolve(vaultRoot);
+    this.config = loadConfig(this.vaultRoot);
+    this.db = openDatabase(this.vaultRoot);
+    this.indexCheckIntervalMs = options.indexCheckIntervalMs ?? 1500;
+  }
+  close() {
+    this.db.close();
+  }
+  getVaultOverview(recentLimit = 10) {
+    const notes = this.readAllNotes().sort((a, b) => b.frontmatter.modified.localeCompare(a.frontmatter.modified));
+    const byType = {};
+    for (const note of notes) {
+      byType[note.frontmatter.type] = (byType[note.frontmatter.type] ?? 0) + 1;
+    }
+    return {
+      vault_root: this.vaultRoot,
+      vault_name: this.config.vault_name,
+      default_type: this.config.defaults.note_type,
+      auto_rebuild: this.config.index.auto_rebuild,
+      index_last_rebuild: this.getMetaValue("last_rebuild"),
+      note_count: notes.length,
+      notes_by_type: byType,
+      recent_notes: notes.slice(0, clampLimit(recentLimit, 20)).map((note) => this.toNoteSummary(note))
+    };
+  }
+  listNoteTypes() {
+    return Object.entries(this.config.note_types).map(([name, typeConfig]) => ({
+      name,
+      description: typeConfig.description,
+      folder: typeConfig.folder,
+      line_limit: typeConfig.line_limit,
+      warn_only: typeConfig.warn_only,
+      slug_format: typeConfig.slug_format ?? "title",
+      instructions: typeConfig.instructions,
+      fields: typeConfig.fields
+    }));
+  }
+  getDefaultNoteType() {
+    return this.config.defaults.note_type;
+  }
+  listNotes(input = {}) {
+    let notes = this.readAllNotes();
+    if (input.type) {
+      notes = notes.filter((note) => note.frontmatter.type === input.type);
+    }
+    if (input.status) {
+      notes = notes.filter((note) => note.frontmatter.status === input.status);
+    }
+    if (input.source) {
+      notes = notes.filter((note) => note.frontmatter.source === input.source);
+    }
+    if (input.since) {
+      const since = input.since;
+      notes = notes.filter((note) => note.frontmatter.modified >= since);
+    }
+    notes.sort((a, b) => b.frontmatter.modified.localeCompare(a.frontmatter.modified));
+    return notes.slice(0, clampLimit(input.limit ?? 25, 200)).map((note) => this.toNoteSummary(note));
+  }
+  getNote(slug) {
+    const note = this.requireNote(slug);
+    const allNotes = this.readAllNotes();
+    const outgoingLinks = resolveWikilinks(parseWikilinks(note.body), allNotes);
+    return {
+      ...this.toNoteSummary(note),
+      body: note.body,
+      frontmatter: note.frontmatter,
+      outgoing_links: outgoingLinks
+    };
+  }
+  search(query, limit = 10) {
+    this.refreshIndex();
+    return searchNotes(this.db, query, clampLimit(limit, 50));
+  }
+  getBacklinks(slug) {
+    this.requireNote(slug);
+    this.refreshIndex();
+    return getBacklinks(this.db, slug);
+  }
+  suggestLinks(slug) {
+    const note = this.requireNote(slug);
+    this.refreshIndex();
+    return suggestLinks(this.db, note);
+  }
+  recommend(slug) {
+    const note = this.requireNote(slug);
+    this.refreshIndex();
+    return getRecommendations(this.db, note, this.config);
+  }
+  runDoctor() {
+    this.refreshIndex();
+    const issues = runDoctor(this.vaultRoot, this.config, this.db);
+    return {
+      counts: {
+        errors: issues.filter((issue) => issue.level === "error").length,
+        warnings: issues.filter((issue) => issue.level === "warning").length,
+        info: issues.filter((issue) => issue.level === "info").length
+      },
+      issues
+    };
+  }
+  createNote(input) {
+    const resolvedType = input.type ?? this.config.defaults.note_type;
+    const typeConfig = this.config.note_types[resolvedType];
+    if (!typeConfig) {
+      throw new Error(`Unknown note type: "${resolvedType}"`);
+    }
+    const bodyOverride = input.body !== void 0 ? ensureTrailingNewline(input.body) : typeConfig.slug_format === "date" ? ensureTrailingNewline(input.title) : void 0;
+    const created = createNote(this.vaultRoot, this.config, resolvedType, input.title, bodyOverride);
+    const metadataMutations = {
+      tags: input.tags,
+      aliases: input.aliases,
+      status: input.status,
+      source: input.source
+    };
+    if (hasMetadataMutations(metadataMutations)) {
+      this.applyMutations(created.filepath, metadataMutations);
+    }
+    return this.afterWrite(created.slug, true);
+  }
+  captureNote(input) {
+    const content = input.text.trim();
+    if (!content) {
+      throw new Error("Capture text cannot be empty.");
+    }
+    const firstLine = content.split("\n")[0] ?? "Untitled";
+    const title = firstLine.length > 60 ? `${firstLine.slice(0, 60).trim()}...` : firstLine;
+    return this.createNote({
+      title,
+      type: input.type,
+      body: ensureTrailingNewline(content),
+      tags: input.tags,
+      aliases: input.aliases,
+      status: input.status,
+      source: input.source
+    });
+  }
+  updateNote(slug, input) {
+    const note = this.requireNote(slug);
+    const needsFullRebuild = input.title !== void 0 || (input.aliases?.length ?? 0) > 0;
+    this.applyMutations(note.filepath, input);
+    if (needsFullRebuild) {
+      return this.afterWrite(slug, true);
+    }
+    this.refreshIndex();
+    const updated = readNote(note.filepath);
+    syncNoteInIndex(this.vaultRoot, this.config, this.db, updated);
+    this.captureSignature();
+    return {
+      note: this.getNote(updated.slug),
+      recommendations: getRecommendations(this.db, updated, this.config)
+    };
+  }
+  readVaultConfigRaw() {
+    return fs16.readFileSync(path12.join(this.vaultRoot, CONFIG_FILENAME), "utf-8");
+  }
+  readVaultTypesJson() {
+    return JSON.stringify({
+      default_type: this.config.defaults.note_type,
+      note_types: this.listNoteTypes()
+    }, null, 2);
+  }
+  readVaultOverviewJson() {
+    return JSON.stringify(this.getVaultOverview(), null, 2);
+  }
+  readNoteMarkdown(slug) {
+    const note = this.requireNote(slug);
+    return fs16.readFileSync(note.filepath, "utf-8");
+  }
+  completeSlugs(prefix = "") {
+    const normalizedPrefix = prefix.toLowerCase();
+    return this.readAllNotes().sort((a, b) => b.frontmatter.modified.localeCompare(a.frontmatter.modified)).map((note) => note.slug).filter((slug) => slug.toLowerCase().startsWith(normalizedPrefix)).slice(0, 25);
+  }
+  noteResourceUri(slug) {
+    return `granite://notes/${encodeURIComponent(slug)}`;
+  }
+  refreshIndex(force = false) {
+    const now = Date.now();
+    if (!force && now - this.lastIndexCheckAt < this.indexCheckIntervalMs) {
+      return;
+    }
+    const currentConfigMtimeMs = this.getConfigMtimeMs();
+    if (!this.lastSignature || currentConfigMtimeMs !== this.lastSignature.configMtimeMs) {
+      this.config = loadConfig(this.vaultRoot);
+    }
+    const signature = this.computeSignature();
+    let shouldRebuild = false;
+    if (force) {
+      shouldRebuild = true;
+    } else if (this.config.index.auto_rebuild) {
+      if (!this.lastSignature) {
+        shouldRebuild = signature.noteCount !== this.getIndexedNoteCount() || signature.latestMutationMs > this.getLastRebuildMs();
+      } else {
+        shouldRebuild = signature.noteCount !== this.lastSignature.noteCount || signature.latestMutationMs !== this.lastSignature.latestMutationMs || signature.configMtimeMs !== this.lastSignature.configMtimeMs;
+      }
+    }
+    if (shouldRebuild) {
+      rebuildIndex(this.vaultRoot, this.config, this.db);
+    }
+    this.lastSignature = signature;
+    this.lastIndexCheckAt = now;
+  }
+  readAllNotes() {
+    return listNotes(this.vaultRoot, this.config);
+  }
+  requireNote(slug) {
+    const note = findNoteBySlug(this.vaultRoot, this.config, slug);
+    if (!note) {
+      throw new Error(`Note not found: ${slug}`);
+    }
+    return note;
+  }
+  toNoteSummary(note) {
+    return {
+      slug: note.slug,
+      title: note.frontmatter.title,
+      type: note.frontmatter.type,
+      created: note.frontmatter.created,
+      modified: note.frontmatter.modified,
+      tags: note.frontmatter.tags,
+      aliases: note.frontmatter.aliases,
+      status: note.frontmatter.status,
+      source: note.frontmatter.source,
+      filepath: note.filepath,
+      resource_uri: this.noteResourceUri(note.slug)
+    };
+  }
+  applyMutations(filepath, input) {
+    const raw = fs16.readFileSync(filepath, "utf-8");
+    const { frontmatter, body: existingBody } = parseFrontmatter(raw);
+    let body = existingBody;
+    if (input.title !== void 0) {
+      frontmatter.title = input.title;
+    }
+    if (input.tags && input.tags.length > 0) {
+      frontmatter.tags = mergeUnique(frontmatter.tags, input.tags);
+    }
+    if (input.aliases && input.aliases.length > 0) {
+      frontmatter.aliases = mergeUnique(frontmatter.aliases, input.aliases);
+    }
+    if (input.status !== void 0) {
+      validateStatus(input.status);
+      frontmatter.status = input.status;
+    }
+    if (input.source !== void 0) {
+      validateSource(input.source);
+      frontmatter.source = input.source;
+    }
+    if (input.body !== void 0) {
+      body = ensureTrailingNewline(input.body);
+    }
+    if (input.append !== void 0) {
+      body = `${body.trimEnd()}
+${input.append}
+`;
+    }
+    frontmatter.modified = (/* @__PURE__ */ new Date()).toISOString();
+    fs16.writeFileSync(filepath, serializeFrontmatter(frontmatter, body), "utf-8");
+  }
+  afterWrite(slug, fullRebuild) {
+    if (fullRebuild) {
+      this.refreshIndex(true);
+    } else {
+      this.refreshIndex();
+      const note2 = this.requireNote(slug);
+      syncNoteInIndex(this.vaultRoot, this.config, this.db, note2);
+      this.captureSignature();
+    }
+    const note = this.requireNote(slug);
+    return {
+      note: this.getNote(note.slug),
+      recommendations: getRecommendations(this.db, note, this.config)
+    };
+  }
+  captureSignature() {
+    this.lastSignature = this.computeSignature();
+    this.lastIndexCheckAt = Date.now();
+  }
+  computeSignature() {
+    let noteCount = 0;
+    let latestNoteMtimeMs = 0;
+    for (const typeConfig of Object.values(this.config.note_types)) {
+      const folder = path12.join(this.vaultRoot, typeConfig.folder);
+      if (!fs16.existsSync(folder)) {
+        continue;
+      }
+      for (const entry of fs16.readdirSync(folder)) {
+        if (!entry.endsWith(".md")) {
+          continue;
+        }
+        noteCount += 1;
+        const stat = fs16.statSync(path12.join(folder, entry));
+        latestNoteMtimeMs = Math.max(latestNoteMtimeMs, stat.mtimeMs);
+      }
+    }
+    const configMtimeMs = this.getConfigMtimeMs();
+    return {
+      noteCount,
+      latestMutationMs: Math.max(latestNoteMtimeMs, configMtimeMs),
+      configMtimeMs
+    };
+  }
+  getConfigMtimeMs() {
+    const configPath = path12.join(this.vaultRoot, CONFIG_FILENAME);
+    return fs16.existsSync(configPath) ? fs16.statSync(configPath).mtimeMs : 0;
+  }
+  getLastRebuildMs() {
+    const value = this.getMetaValue("last_rebuild");
+    return value ? Date.parse(value) || 0 : 0;
+  }
+  getMetaValue(key) {
+    const row = this.db.prepare("SELECT value FROM meta WHERE key = ?").get(key);
+    return row?.value;
+  }
+  getIndexedNoteCount() {
+    const row = this.db.prepare("SELECT COUNT(*) as count FROM notes").get();
+    return row.count;
+  }
+};
+function ensureTrailingNewline(value) {
+  return value.endsWith("\n") ? value : `${value}
+`;
+}
+function clampLimit(value, max) {
+  return Math.max(1, Math.min(value, max));
+}
+function mergeUnique(existing, incoming) {
+  const merged = new Set(existing);
+  for (const value of incoming) {
+    const trimmed = value.trim();
+    if (trimmed) {
+      merged.add(trimmed);
+    }
+  }
+  return [...merged];
+}
+function hasMetadataMutations(input) {
+  return (input.tags?.length ?? 0) > 0 || (input.aliases?.length ?? 0) > 0 || input.status !== void 0 || input.source !== void 0;
+}
+
+// src/commands/mcp.ts
+async function mcpCommand(options) {
+  const transport = parseTransport(options.transport);
+  const vaultRoot = resolveVaultRoot(options.vault);
+  const runtime = new GraniteMcpRuntime(vaultRoot);
+  const shutdown = () => {
+    runtime.close();
+    process.exit(0);
+  };
+  process.once("SIGINT", shutdown);
+  process.once("SIGTERM", shutdown);
+  if (transport === "http") {
+    const port = parsePort(options.port);
+    startGraniteMcpHttpServer(runtime, {
+      host: options.host ?? "127.0.0.1",
+      port,
+      allowedOrigins: options.allowOrigin ?? [],
+      jsonResponse: options.jsonResponse ?? false
+    });
+    return;
+  }
+  await startGraniteMcpStdioServer(runtime);
+}
+function resolveVaultRoot(explicitVault) {
+  const fromEnv = process.env.GRANITE_VAULT;
+  if (explicitVault) {
+    return path13.resolve(explicitVault);
+  }
+  if (fromEnv) {
+    return path13.resolve(fromEnv);
+  }
+  return requireVaultRoot();
+}
+function parseTransport(value) {
+  const transport = value ?? "stdio";
+  if (transport !== "stdio" && transport !== "http") {
+    throw new Error(`Invalid MCP transport: ${transport}. Expected "stdio" or "http".`);
+  }
+  return transport;
+}
+function parsePort(value) {
+  const raw = (value ?? process.env.MCP_PORT ?? "3321").trim();
+  if (!/^\d+$/.test(raw)) {
+    throw new Error(`Invalid MCP port: ${raw}`);
+  }
+  const parsed = Number.parseInt(raw, 10);
+  if (parsed <= 0) {
+    throw new Error(`Invalid MCP port: ${raw}`);
+  }
+  return parsed;
+}
+
+// src/commands/sync.ts
+async function syncCommand(options) {
+  const vaultRoot = requireVaultRoot();
+  const config = loadConfig(vaultRoot);
+  const manager = new SyncManager(vaultRoot, config);
+  const result = await manager.sync();
+  if (options.json) {
+    console.log(JSON.stringify(result));
+    return;
+  }
+  console.log(`Sync complete: ${result.pushed} pushed, ${result.pulled} pulled`);
+  if (result.conflicts > 0) {
+    console.log(`  ${result.conflicts} conflict(s) resolved (backups in .granite/conflicts/)`);
+  }
+}
+async function syncStatusCommand(options) {
+  const vaultRoot = requireVaultRoot();
+  const config = loadConfig(vaultRoot);
+  const manager = new SyncManager(vaultRoot, config);
+  const status = manager.status();
+  const conflictFiles = manager.conflicts();
+  if (options.json) {
+    console.log(JSON.stringify({ ...status, conflicts: conflictFiles.length }));
+    return;
+  }
+  console.log(`Device:          ${status.device_name} (${status.device_id.slice(0, 8)}...)`);
+  console.log(`Last sync:       ${status.last_sync ?? "never"}`);
+  console.log(`Pending changes: ${status.pending_changes}`);
+  console.log(`Server seq:      ${status.server_seq}`);
+  if (conflictFiles.length > 0) {
+    console.log(`Conflicts:       ${conflictFiles.length} file(s) in .granite/conflicts/`);
+  }
+}
+async function syncDevicesCommand(options) {
+  const vaultRoot = requireVaultRoot();
+  const config = loadConfig(vaultRoot);
+  const manager = new SyncManager(vaultRoot, config);
+  const devices = await manager.devices();
+  if (options.json) {
+    console.log(JSON.stringify(devices));
+    return;
+  }
+  if (devices.length === 0) {
+    console.log("No devices registered yet.");
+    return;
+  }
+  for (const d of devices) {
+    console.log(`  ${d.device_name} (${d.device_id.slice(0, 8)}...) \u2014 last seen ${d.last_seen}`);
+  }
+}
+function syncConflictsCommand(options) {
+  const vaultRoot = requireVaultRoot();
+  if (options.clear) {
+    const cleared = clearResolvedConflicts(vaultRoot);
+    if (options.json) {
+      console.log(JSON.stringify({ cleared }));
+    } else {
+      console.log(`Cleared ${cleared} conflict file(s).`);
+    }
+    return;
+  }
+  const files = listConflicts(vaultRoot);
+  if (options.json) {
+    console.log(JSON.stringify({ conflicts: files }));
+    return;
+  }
+  if (files.length === 0) {
+    console.log("No conflicts.");
+    return;
+  }
+  console.log(`${files.length} conflict file(s):`);
+  for (const f of files) {
+    console.log(`  ${f}`);
+  }
+}
+
 // src/index.ts
 var program = new Command();
-program.name("mem").description("Granite \u2014 a local-first markdown memory system").version("0.1.0");
+program.name("granite").description("Granite \u2014 a local-first markdown memory system").version(GRANITE_VERSION);
 program.command("init").description("Initialize the default vault in ~/.granite").action(() => {
   initVault();
 });
@@ -2004,4 +3680,29 @@ program.command("doctor").description("Validate vault health").action(() => {
 program.command("serve").description("Start the local web UI").option("-p, --port <port>", "Port number", "4321").action((options) => {
   serveCommand(options);
 });
-program.parse();
+program.command("mcp").description("Start Granite as an MCP server").option("--vault <path>", "Vault root. Defaults to the current Granite vault or $GRANITE_VAULT").option("--transport <transport>", "Transport to use: stdio or http", parseTransportOption, "stdio").option("--host <host>", "Host for HTTP transport", "127.0.0.1").option("--port <port>", "Port for HTTP transport", "3321").option("--allow-origin <origin>", "Allow an HTTP Origin for browser-based HTTP clients", collectValues, []).option("--json-response", "Prefer JSON HTTP responses instead of SSE streams").action(async (options) => {
+  await mcpCommand(options);
+});
+var syncCmd = program.command("sync").description("Sync vault across devices").option("--json", "Output as JSON").action(async (options) => {
+  await syncCommand(options);
+});
+syncCmd.command("status").description("Show sync status").option("--json", "Output as JSON").action(async (options) => {
+  await syncStatusCommand(options);
+});
+syncCmd.command("devices").description("List connected devices").option("--json", "Output as JSON").action(async (options) => {
+  await syncDevicesCommand(options);
+});
+syncCmd.command("conflicts").description("List or clear conflict files").option("--clear", "Remove all conflict backup files").option("--json", "Output as JSON").action((options) => {
+  syncConflictsCommand(options);
+});
+await program.parseAsync();
+function collectValues(value, previous) {
+  return [...previous, value];
+}
+function parseTransportOption(value) {
+  try {
+    return parseTransport(value);
+  } catch (error) {
+    throw new InvalidArgumentError(error instanceof Error ? error.message : String(error));
+  }
+}