granite-mem 0.1.4 → 0.1.5

package/README.md

@@ -81,48 +81,48 @@ npm link
 Create the default vault in `~/.granite` and start capturing:
 
 ```bash
-mem init
-mem add "Talked to Alice about local-first sync tradeoffs"
-mem new "Local-first sync tradeoffs" --type permanent
-mem list
-mem search "sync"
+granite init
+granite add "Talked to Alice about local-first sync tradeoffs"
+granite new "Local-first sync tradeoffs" --type permanent
+granite list
+granite search "sync"
 ```
 
 Start one long-running interface when you need it:
 
 ```bash
-mem serve   # local web UI
-mem mcp     # MCP server for agent clients
+granite serve   # local web UI
+granite mcp     # MCP server for agent clients
 ```
 
-`mem new` does more than create a file. It can immediately suggest related links, tags, and the next note to create, which is the core of Granite's value loop.
+`granite new` does more than create a file. It can immediately suggest related links, tags, and the next note to create, which is the core of Granite's value loop.
 
 ## Example Workflow
 
 Capture something quickly:
 
 ```bash
-mem add "Users want fewer note types, but stronger defaults."
+granite add "Users want fewer note types, but stronger defaults."
 ```
 
 Turn it into a durable note:
 
 ```bash
-mem new "Strong defaults beat infinite flexibility" --type permanent
+granite new "Strong defaults beat infinite flexibility" --type permanent
 ```
 
 Find connections:
 
 ```bash
-mem suggest-links strong-defaults-beat-infinite-flexibility
-mem recommend strong-defaults-beat-infinite-flexibility
-mem backlinks strong-defaults-beat-infinite-flexibility
+granite suggest-links strong-defaults-beat-infinite-flexibility
+granite recommend strong-defaults-beat-infinite-flexibility
+granite backlinks strong-defaults-beat-infinite-flexibility
 ```
 
 Open the local UI:
 
 ```bash
-mem serve
+granite serve
 ```
 
 Then browse notes, search the vault, inspect backlinks, and explore the graph locally.
@@ -172,12 +172,12 @@ This keeps the system transparent, portable, and inspectable.
 Many commands support JSON output:
 
 ```bash
-mem new "Sync constraints" --type permanent --json
-mem list --json
-mem show sync-constraints --json
-mem search "constraints" --json
-mem backlinks sync-constraints --json
-mem recommend sync-constraints --json
+granite new "Sync constraints" --type permanent --json
+granite list --json
+granite show sync-constraints --json
+granite search "constraints" --json
+granite backlinks sync-constraints --json
+granite recommend sync-constraints --json
 ```
 
 That makes Granite a useful substrate for local workflows, scripts, and agent memory.
@@ -189,13 +189,13 @@ Granite ships with an MCP server so LLM clients can control the vault directly t
 Start it over stdio for local MCP clients:
 
 ```bash
-mem mcp --vault /path/to/vault
+granite mcp --vault /path/to/vault
 ```
 
 Start it over Streamable HTTP:
 
 ```bash
-mem mcp --transport http --host 127.0.0.1 --port 3321
+granite mcp --transport http --host 127.0.0.1 --port 3321
 ```
 
 The server exposes:
@@ -208,7 +208,7 @@ Example stdio client configuration:
 
 ```json
 {
-  "command": "mem",
+  "command": "granite",
   "args": ["mcp", "--vault", "/path/to/vault"]
 }
 ```
@@ -216,21 +216,21 @@ Example stdio client configuration:
 ## Commands
 
 ```bash
-mem init
-mem new <title> [--type <type>] [--json]
-mem add [text] [--json]
-mem list [--type <type>] [--json]
-mem edit <slug>
-mem open <slug>
-mem show <slug> [--json] [--body]
-mem search <query> [--json]
-mem backlinks <slug> [--json]
-mem suggest-links <slug> [--json]
-mem recommend <slug> [--json]
-mem types
-mem doctor
-mem serve [-p <port>]
-mem mcp [--vault <path>] [--transport <stdio|http>]
+granite init
+granite new <title> [--type <type>] [--json]
+granite add [text] [--json]
+granite list [--type <type>] [--json]
+granite edit <slug>
+granite open <slug>
+granite show <slug> [--json] [--body]
+granite search <query> [--json]
+granite backlinks <slug> [--json]
+granite suggest-links <slug> [--json]
+granite recommend <slug> [--json]
+granite types
+granite doctor
+granite serve [-p <port>]
+granite mcp [--vault <path>] [--transport <stdio|http>]
 ```
 
 ## Development

package/dist/index.js

@@ -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";
@@ -1200,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();
@@ -1211,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,
@@ -1259,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);
@@ -1268,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) {
@@ -1281,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,
@@ -1317,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);
@@ -1353,7 +1840,7 @@ 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);
 }
 
@@ -1511,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`,
@@ -1653,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) => {
@@ -1723,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,
@@ -1740,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",
@@ -1796,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
@@ -1886,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();
@@ -1898,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;
     }
@@ -1929,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");
     }
@@ -1965,7 +2460,7 @@ function printRecommendations(vaultRoot, config, filepath, strategy) {
 }
 
 // src/commands/mcp.ts
-import path9 from "path";
+import path13 from "path";
 
 // src/mcp/server.ts
 import { serve as serve2 } from "@hono/node-server";
@@ -2280,7 +2775,7 @@ function registerTools(server, runtime) {
   });
   server.registerTool("granite_capture_note", {
     title: "Capture Granite Note",
-    description: "Quick-capture a note from free-form text, similar to mem add.",
+    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."),
@@ -2663,8 +3158,8 @@ function corsHeaders(origin, allowedOrigins) {
 }
 
 // src/mcp/runtime.ts
-import fs12 from "fs";
-import path8 from "path";
+import fs16 from "fs";
+import path12 from "path";
 var GraniteMcpRuntime = class {
   vaultRoot;
   config;
@@ -2673,7 +3168,7 @@ var GraniteMcpRuntime = class {
   lastSignature;
   lastIndexCheckAt = 0;
   constructor(vaultRoot, options = {}) {
-    this.vaultRoot = path8.resolve(vaultRoot);
+    this.vaultRoot = path12.resolve(vaultRoot);
     this.config = loadConfig(this.vaultRoot);
     this.db = openDatabase(this.vaultRoot);
     this.indexCheckIntervalMs = options.indexCheckIntervalMs ?? 1500;
@@ -2826,7 +3321,7 @@ var GraniteMcpRuntime = class {
     };
   }
   readVaultConfigRaw() {
-    return fs12.readFileSync(path8.join(this.vaultRoot, CONFIG_FILENAME), "utf-8");
+    return fs16.readFileSync(path12.join(this.vaultRoot, CONFIG_FILENAME), "utf-8");
   }
   readVaultTypesJson() {
     return JSON.stringify({
@@ -2839,7 +3334,7 @@ var GraniteMcpRuntime = class {
   }
   readNoteMarkdown(slug) {
     const note = this.requireNote(slug);
-    return fs12.readFileSync(note.filepath, "utf-8");
+    return fs16.readFileSync(note.filepath, "utf-8");
   }
   completeSlugs(prefix = "") {
     const normalizedPrefix = prefix.toLowerCase();
@@ -2900,7 +3395,7 @@ var GraniteMcpRuntime = class {
     };
   }
   applyMutations(filepath, input) {
-    const raw = fs12.readFileSync(filepath, "utf-8");
+    const raw = fs16.readFileSync(filepath, "utf-8");
     const { frontmatter, body: existingBody } = parseFrontmatter(raw);
     let body = existingBody;
     if (input.title !== void 0) {
@@ -2929,7 +3424,7 @@ ${input.append}
 `;
     }
     frontmatter.modified = (/* @__PURE__ */ new Date()).toISOString();
-    fs12.writeFileSync(filepath, serializeFrontmatter(frontmatter, body), "utf-8");
+    fs16.writeFileSync(filepath, serializeFrontmatter(frontmatter, body), "utf-8");
   }
   afterWrite(slug, fullRebuild) {
     if (fullRebuild) {
@@ -2954,16 +3449,16 @@ ${input.append}
     let noteCount = 0;
     let latestNoteMtimeMs = 0;
     for (const typeConfig of Object.values(this.config.note_types)) {
-      const folder = path8.join(this.vaultRoot, typeConfig.folder);
-      if (!fs12.existsSync(folder)) {
+      const folder = path12.join(this.vaultRoot, typeConfig.folder);
+      if (!fs16.existsSync(folder)) {
         continue;
       }
-      for (const entry of fs12.readdirSync(folder)) {
+      for (const entry of fs16.readdirSync(folder)) {
         if (!entry.endsWith(".md")) {
           continue;
         }
         noteCount += 1;
-        const stat = fs12.statSync(path8.join(folder, entry));
+        const stat = fs16.statSync(path12.join(folder, entry));
         latestNoteMtimeMs = Math.max(latestNoteMtimeMs, stat.mtimeMs);
       }
     }
@@ -2975,8 +3470,8 @@ ${input.append}
     };
   }
   getConfigMtimeMs() {
-    const configPath = path8.join(this.vaultRoot, CONFIG_FILENAME);
-    return fs12.existsSync(configPath) ? fs12.statSync(configPath).mtimeMs : 0;
+    const configPath = path12.join(this.vaultRoot, CONFIG_FILENAME);
+    return fs16.existsSync(configPath) ? fs16.statSync(configPath).mtimeMs : 0;
   }
   getLastRebuildMs() {
     const value = this.getMetaValue("last_rebuild");
@@ -3038,10 +3533,10 @@ async function mcpCommand(options) {
 function resolveVaultRoot(explicitVault) {
   const fromEnv = process.env.GRANITE_VAULT;
   if (explicitVault) {
-    return path9.resolve(explicitVault);
+    return path13.resolve(explicitVault);
   }
   if (fromEnv) {
-    return path9.resolve(fromEnv);
+    return path13.resolve(fromEnv);
   }
   return requireVaultRoot();
 }
@@ -3064,9 +3559,85 @@ function parsePort(value) {
   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(GRANITE_VERSION);
+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();
 });
@@ -3112,6 +3683,18 @@ program.command("serve").description("Start the local web UI").option("-p, --por
 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];

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "granite-mem",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "A local-first markdown memory system for humans and agents",
   "type": "module",
   "bin": {
-    "mem": "./dist/index.js"
+    "granite": "./dist/index.js"
   },
   "files": [
     "dist"