shared-things-daemon 1.1.0 → 2.0.0

package/README.md

@@ -54,12 +54,14 @@ shared-things init
 ? Things auth token: ****
 ```
 
+> **Note:** The Things project must be empty when you run `init`.
+
 > **Things auth token:** Required for syncing updates to existing todos. Find it in Things → Settings → General → Things URLs → Enable Things URLs.
 
 ### After Setup
 
 ```bash
-shared-things install   # Start daemon (auto-runs on login)
+shared-things start     # Start daemon (auto-runs on login)
 shared-things status    # Check sync status
 shared-things logs -f   # Follow sync logs
 ```
@@ -69,13 +71,16 @@ shared-things logs -f   # Follow sync logs
 | Command | Description |
 |---------|-------------|
 | `init` | Setup wizard |
-| `install` | Install launchd daemon (auto-starts on login) |
-| `uninstall` | Remove launchd daemon |
+| `start` | Start launchd daemon (auto-starts on login) |
+| `stop` | Stop launchd daemon |
 | `status` | Show sync status & last sync time |
 | `sync` | Force immediate sync |
 | `logs [-f]` | Show logs (`-f` to follow) |
-| `reset [--server]` | Reset local state (`--server` clears server too) |
-| `purge` | Remove all local config |
+| `conflicts [--all]` | Show conflict history |
+| `repair` | Diagnose state issues (no auto-fix) |
+| `reset --local` | Clear local state |
+| `reset --server` | Clear server data for this user |
+| `doctor` | Comprehensive health check |
 
 ## Server Setup
 
@@ -143,9 +148,8 @@ things.yourdomain.com {
 
 | Synced | Not Synced |
 |--------|------------|
-| Todo title, notes, due date, tags | Completed todos |
-| Headings | Checklist items |
-| | Areas |
+| Todo title, notes, due date, tags, status | Checklist items |
+|  | Headings, Areas |
 
 > **Note:** The project must exist in each user's Things app. Only items within that project sync.
 

package/dist/cli.js

@@ -10,11 +10,12 @@ import { Command } from "commander";
 import updateNotifier from "update-notifier";
 
 // src/api.ts
-var ApiClient = class {
+var ApiClient = class _ApiClient {
   constructor(serverUrl, apiKey) {
     this.serverUrl = serverUrl;
     this.apiKey = apiKey;
   }
+  static TIMEOUT_MS = 3e4;
   async request(path6, options = {}) {
     const url = `${this.serverUrl}${path6}`;
     const headers = {
@@ -22,7 +23,23 @@ var ApiClient = class {
       "Content-Type": "application/json",
       ...options.headers
     };
-    const response = await fetch(url, { ...options, headers });
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), _ApiClient.TIMEOUT_MS);
+    let response;
+    try {
+      response = await fetch(url, {
+        ...options,
+        headers,
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (error.name === "AbortError") {
+        throw new Error(`API timeout after ${_ApiClient.TIMEOUT_MS}ms`);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeout);
+    }
     if (!response.ok) {
       const error = await response.json().catch(() => ({ error: "Unknown error" }));
       throw new Error(`API error: ${error.error || response.statusText}`);
@@ -118,7 +135,7 @@ function installLaunchAgent() {
     const npmPrefix = execSync("npm prefix -g", { encoding: "utf-8" }).trim();
     binPath = path2.join(npmPrefix, "bin", "shared-things");
   }
-  const logPath = path2.join(os2.homedir(), ".shared-things", "daemon.log");
+  const logPath = path2.join(os2.homedir(), ".shared-things", "sync.log");
   let nodeBinDir;
   try {
     const nodePath = execSync("which node", { encoding: "utf-8" }).trim();
@@ -180,6 +197,30 @@ function installLaunchAgent() {
     console.warn("You may need to manually load it or restart your Mac.");
   }
 }
+function startLaunchAgent() {
+  if (!fs2.existsSync(PLIST_PATH)) {
+    installLaunchAgent();
+    return;
+  }
+  try {
+    execSync(`launchctl load "${PLIST_PATH}"`);
+    console.log("LaunchAgent started.");
+  } catch (error) {
+    console.warn(`Warning: Could not start LaunchAgent: ${error}`);
+  }
+}
+function stopLaunchAgent() {
+  if (!fs2.existsSync(PLIST_PATH)) {
+    console.log("LaunchAgent not installed.");
+    return;
+  }
+  try {
+    execSync(`launchctl unload "${PLIST_PATH}"`);
+    console.log("LaunchAgent stopped.");
+  } catch (error) {
+    console.warn(`Warning: Could not stop LaunchAgent: ${error}`);
+  }
+}
 function uninstallLaunchAgent() {
   if (!fs2.existsSync(PLIST_PATH)) {
     console.log("LaunchAgent not installed.");
@@ -212,7 +253,7 @@ function getLaunchAgentStatus() {
 // src/logger.ts
 import * as fs3 from "fs";
 import * as path3 from "path";
-var LOG_FILE = "daemon.log";
+var LOG_FILE = "sync.log";
 var MAX_LOG_SIZE = 1024 * 1024;
 function getLogPath() {
   return path3.join(getConfigDir(), LOG_FILE);
@@ -229,49 +270,60 @@ function rotateIfNeeded() {
     fs3.renameSync(logPath, oldLog);
   }
 }
-function log(message) {
+function log(level, message) {
   ensureConfigDir();
   rotateIfNeeded();
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  const line = `[${timestamp}] ${message}
+  const line = `[${timestamp}] [${level}] ${message}
 `;
   fs3.appendFileSync(getLogPath(), line);
 }
 function logError(message, error) {
   const errorMsg = error instanceof Error ? error.message : String(error);
-  log(`ERROR: ${message}${error ? ` - ${errorMsg}` : ""}`);
+  log("ERROR", `${message}${error ? ` - ${errorMsg}` : ""}`);
+}
+function logWarn(message) {
+  log("WARN", message);
+}
+function logInfo(message) {
+  log("INFO", message);
 }
-function logSync(pushed, pulled, isFirstSync) {
+function logDebug(message) {
+  log("DEBUG", message);
+}
+function logSync(pushed, pulled, isFirstSync, conflicts) {
   if (isFirstSync) {
-    log(`First sync completed: pushed=${pushed}, pulled=${pulled}`);
-  } else if (pushed > 0 || pulled > 0) {
-    log(`Sync: pushed=${pushed}, pulled=${pulled}`);
+    logInfo(
+      `Sync complete (first): pushed=${pushed}, pulled=${pulled}, conflicts=${conflicts}`
+    );
+  } else if (pushed > 0 || pulled > 0 || conflicts > 0) {
+    logInfo(
+      `Sync complete: pushed=${pushed}, pulled=${pulled}, conflicts=${conflicts}`
+    );
   } else {
-    log("Sync: no changes");
+    logDebug("Sync: no changes");
   }
 }
 function logMapping(serverId, thingsId) {
-  log(`Mapped server ${serverId} -> local ${thingsId}`);
+  logDebug(`Mapped server ${serverId} -> local ${thingsId}`);
 }
 function logTodoCreated(title) {
-  log(`Created todo: "${title}"`);
+  logInfo(`Created todo: "${title}"`);
 }
 function logTodoUpdated(thingsId, title) {
-  log(`Updated todo ${thingsId}: "${title}"`);
-}
-function logDaemonStart() {
-  log("Daemon started");
-}
-function logDaemonStop() {
-  log("Daemon stopped");
+  logInfo(`Updated todo ${thingsId}: "${title}"`);
 }
 
 // src/sync.ts
+import { execSync as execSync3 } from "child_process";
 import * as fs4 from "fs";
 import * as path4 from "path";
 
 // src/things.ts
 import { execSync as execSync2 } from "child_process";
+var PIPE_TOKEN = "{{PIPE}}";
+var CARET_TOKEN = "{{CARET}}";
+var MAX_URL_LENGTH = 2e3;
 function runAppleScript(script) {
   try {
     return execSync2(`osascript -e '${script.replace(/'/g, `'"'"'`)}'`, {
@@ -285,22 +337,34 @@ function runAppleScript(script) {
 }
 function getTodosFromProject(projectName) {
   const script = `
+    on replaceText(findText, replaceText, theText)
+      set AppleScript's text item delimiters to findText
+      set theItems to every text item of theText
+      set AppleScript's text item delimiters to replaceText
+      set theText to theItems as string
+      set AppleScript's text item delimiters to ""
+      return theText
+    end replaceText
+
+    on escapeText(t)
+      if t is missing value then return ""
+      set t to my replaceText("|||", "${PIPE_TOKEN}", t as string)
+      set t to my replaceText("^^^", "${CARET_TOKEN}", t as string)
+      return t
+    end escapeText
+
     tell application "Things3"
       set todoList to {}
       set proj to project "${projectName}"
       repeat with t in to dos of proj
         set todoId to id of t
-        set todoTitle to name of t
-        set todoNotes to notes of t
+        set todoTitle to my escapeText(name of t)
+        set todoNotes to my escapeText(notes of t)
         set todoStatus to status of t
         set todoDue to due date of t
-        set todoTags to tag names of t
-
-        -- Get heading if any
-        set todoHeading to ""
-        try
-          set todoHeading to id of (get area of t)
-        end try
+        set AppleScript's text item delimiters to ", "
+        set todoTags to my escapeText((tag names of t) as string)
+        set AppleScript's text item delimiters to ""
 
         -- Format due date
         set dueDateStr to ""
@@ -318,7 +382,7 @@ function getTodosFromProject(projectName) {
           set statusStr to "canceled"
         end if
 
-        set end of todoList to todoId & "|||" & todoTitle & "|||" & todoNotes & "|||" & dueDateStr & "|||" & todoTags & "|||" & statusStr & "|||" & todoHeading
+        set end of todoList to todoId & "|||" & todoTitle & "|||" & todoNotes & "|||" & dueDateStr & "|||" & todoTags & "|||" & statusStr
       end repeat
 
       set AppleScript's text item delimiters to "^^^"
@@ -328,18 +392,24 @@ function getTodosFromProject(projectName) {
   const result = runAppleScript(script);
   if (!result) return [];
   return result.split("^^^").map((line) => {
-    const [thingsId, title, notes, dueDate, tags, status, headingThingsId] = line.split("|||");
+    const [thingsId, title, notes, dueDate, tags, status] = line.split("|||");
+    const decodedTitle = unescapeField(title);
+    const decodedNotes = unescapeField(notes);
+    const decodedTags = unescapeField(tags);
     return {
       thingsId,
-      title: title || "",
-      notes: notes || "",
+      title: decodedTitle || "",
+      notes: decodedNotes || "",
       dueDate: dueDate || null,
-      tags: tags ? tags.split(", ").filter(Boolean) : [],
-      status: status || "open",
-      headingThingsId: headingThingsId || null
+      tags: decodedTags ? decodedTags.split(", ").filter(Boolean) : [],
+      status: status || "open"
     };
   });
 }
+function unescapeField(value) {
+  if (!value) return "";
+  return value.replaceAll(PIPE_TOKEN, "|||").replaceAll(CARET_TOKEN, "^^^");
+}
 function createTodo(projectName, todo) {
   const params = new URLSearchParams();
   params.set("title", todo.title);
@@ -347,7 +417,19 @@ function createTodo(projectName, todo) {
   if (todo.dueDate) params.set("when", todo.dueDate);
   if (todo.tags?.length) params.set("tags", todo.tags.join(","));
   params.set("list", projectName);
-  const url = `things:///add?${params.toString().replace(/\+/g, "%20")}`;
+  let url = `things:///add?${params.toString().replace(/\+/g, "%20")}`;
+  if (url.length > MAX_URL_LENGTH && todo.notes) {
+    const originalNotes = todo.notes;
+    let truncated = originalNotes;
+    while (truncated.length > 0 && url.length > MAX_URL_LENGTH) {
+      truncated = truncated.slice(0, Math.max(0, truncated.length - 200));
+      params.set("notes", truncated);
+      url = `things:///add?${params.toString().replace(/\+/g, "%20")}`;
+    }
+    logWarn(
+      `Create URL exceeded ${MAX_URL_LENGTH} chars; notes truncated from ${originalNotes.length} to ${truncated.length}`
+    );
+  }
   execSync2(`open -g "${url}"`);
 }
 function updateTodo(authToken, thingsId, updates) {
@@ -393,139 +475,411 @@ function listProjects() {
 
 // src/sync.ts
 var STATE_FILE = path4.join(getConfigDir(), "state.json");
+var STATE_BAK_FILE = path4.join(getConfigDir(), "state.json.bak");
+var LOCK_FILE = path4.join(getConfigDir(), "sync.lock");
+var CONFLICTS_FILE = path4.join(getConfigDir(), "conflicts.json");
 function loadLocalState() {
   if (!fs4.existsSync(STATE_FILE)) {
-    return {
-      lastSyncedAt: (/* @__PURE__ */ new Date(0)).toISOString(),
-      todos: /* @__PURE__ */ new Map(),
-      serverIdToThingsId: /* @__PURE__ */ new Map()
-    };
+    throw new Error('State file missing. Run "shared-things init" first.');
   }
+  ensureConfigDir();
+  fs4.copyFileSync(STATE_FILE, STATE_BAK_FILE);
+  const raw = fs4.readFileSync(STATE_FILE, "utf-8");
+  let data;
   try {
-    const content = fs4.readFileSync(STATE_FILE, "utf-8");
-    const data = JSON.parse(content);
-    return {
-      lastSyncedAt: data.lastSyncedAt,
-      todos: new Map(Object.entries(data.todos || {})),
-      serverIdToThingsId: new Map(
-        Object.entries(data.serverIdToThingsId || {})
-      )
-    };
+    data = JSON.parse(raw);
   } catch {
-    return {
-      lastSyncedAt: (/* @__PURE__ */ new Date(0)).toISOString(),
-      todos: /* @__PURE__ */ new Map(),
-      serverIdToThingsId: /* @__PURE__ */ new Map()
-    };
+    throw new Error("State file is corrupted (invalid JSON).");
   }
+  if (typeof data !== "object" || data === null) {
+    throw new Error("State file is corrupted (invalid structure).");
+  }
+  const obj = data;
+  const lastSyncedAt = typeof obj.lastSyncedAt === "string" ? obj.lastSyncedAt : null;
+  const todos = typeof obj.todos === "object" && obj.todos !== null ? obj.todos : null;
+  const serverIdToThingsId = typeof obj.serverIdToThingsId === "object" && obj.serverIdToThingsId !== null ? obj.serverIdToThingsId : null;
+  const dirtyObj = typeof obj.dirty === "object" && obj.dirty !== null ? obj.dirty : null;
+  if (!lastSyncedAt || !todos || !serverIdToThingsId) {
+    throw new Error("State file is corrupted (missing fields).");
+  }
+  const dirty = {
+    upserted: Array.isArray(dirtyObj?.upserted) ? dirtyObj?.upserted : [],
+    deleted: {}
+  };
+  if (dirtyObj?.deleted) {
+    if (Array.isArray(dirtyObj.deleted)) {
+      for (const serverId of dirtyObj.deleted) {
+        if (typeof serverId === "string") {
+          dirty.deleted[serverId] = (/* @__PURE__ */ new Date()).toISOString();
+        }
+      }
+    } else if (typeof dirtyObj.deleted === "object" && dirtyObj.deleted !== null) {
+      for (const [serverId, deletedAt] of Object.entries(
+        dirtyObj.deleted
+      )) {
+        if (typeof deletedAt === "string") {
+          dirty.deleted[serverId] = deletedAt;
+        }
+      }
+    }
+  }
+  for (const [thingsId, todo] of Object.entries(todos)) {
+    if (!todo.editedAt) {
+      todos[thingsId] = {
+        thingsId,
+        title: todo.title || "",
+        notes: todo.notes || "",
+        dueDate: todo.dueDate ?? null,
+        tags: Array.isArray(todo.tags) ? todo.tags : [],
+        status: todo.status || "open",
+        position: typeof todo.position === "number" && Number.isFinite(todo.position) ? todo.position : 0,
+        editedAt: lastSyncedAt
+      };
+    } else if (typeof todo.position !== "number" || !Number.isFinite(todo.position)) {
+      todos[thingsId] = {
+        ...todo,
+        position: 0
+      };
+    }
+  }
+  validateMapping(todos, serverIdToThingsId);
+  return {
+    lastSyncedAt,
+    todos,
+    serverIdToThingsId,
+    dirty
+  };
 }
 function saveLocalState(state) {
-  const data = {
-    lastSyncedAt: state.lastSyncedAt,
-    todos: Object.fromEntries(state.todos),
-    serverIdToThingsId: Object.fromEntries(state.serverIdToThingsId)
-  };
-  fs4.writeFileSync(STATE_FILE, JSON.stringify(data, null, 2));
+  ensureConfigDir();
+  const tempFile = `${STATE_FILE}.tmp-${process.pid}`;
+  const data = JSON.stringify(state, null, 2);
+  fs4.writeFileSync(tempFile, data);
+  fs4.renameSync(tempFile, STATE_FILE);
+}
+function acquireLock() {
+  ensureConfigDir();
+  if (fs4.existsSync(LOCK_FILE)) {
+    const pid = parseInt(fs4.readFileSync(LOCK_FILE, "utf-8"), 10);
+    if (pid) {
+      try {
+        process.kill(pid, 0);
+        return false;
+      } catch {
+        fs4.unlinkSync(LOCK_FILE);
+      }
+    }
+  }
+  fs4.writeFileSync(LOCK_FILE, String(process.pid));
+  return true;
+}
+function releaseLock() {
+  if (fs4.existsSync(LOCK_FILE)) {
+    fs4.unlinkSync(LOCK_FILE);
+  }
+}
+function appendConflicts(entries) {
+  if (entries.length === 0) return;
+  ensureConfigDir();
+  let existing = [];
+  if (fs4.existsSync(CONFLICTS_FILE)) {
+    try {
+      const raw = fs4.readFileSync(CONFLICTS_FILE, "utf-8");
+      existing = JSON.parse(raw);
+    } catch {
+      existing = [];
+    }
+  }
+  const next = [...existing, ...entries];
+  const tempFile = `${CONFLICTS_FILE}.tmp-${process.pid}`;
+  fs4.writeFileSync(tempFile, JSON.stringify(next, null, 2));
+  fs4.renameSync(tempFile, CONFLICTS_FILE);
+}
+function notifyConflicts(count) {
+  if (count <= 0) return;
+  try {
+    const message = `Sync complete. ${count} conflict${count === 1 ? "" : "s"} resolved (your edits were older).`;
+    const safeMessage = message.replace(/"/g, '\\"');
+    const cmd = `osascript -e 'display notification "${safeMessage}" with title "shared-things"'`;
+    execSync3(cmd);
+  } catch {
+  }
 }
 async function runSync() {
   const config = loadConfig();
   if (!config) {
     throw new Error('Not configured. Run "shared-things init" first.');
   }
+  if (!acquireLock()) {
+    logWarn("Sync skipped: another sync process is running.");
+    return {
+      pushed: 0,
+      pulled: 0,
+      isFirstSync: false,
+      skipped: true,
+      conflicts: 0
+    };
+  }
+  let localState;
+  try {
+    localState = loadLocalState();
+  } catch (error) {
+    releaseLock();
+    throw error;
+  }
+  logDebug(
+    `Loaded state: todos=${Object.keys(localState.todos).length}, mappings=${Object.keys(localState.serverIdToThingsId).length}, dirtyUpserted=${localState.dirty.upserted.length}, dirtyDeleted=${Object.keys(localState.dirty.deleted).length}`
+  );
+  logInfo("Sync started");
   const api = new ApiClient(config.serverUrl, config.apiKey);
-  const localState = loadLocalState();
-  const isFirstSync = localState.lastSyncedAt === (/* @__PURE__ */ new Date(0)).toISOString();
-  const currentTodos = getTodosFromProject(config.projectName);
-  const currentTodosMap = new Map(currentTodos.map((t) => [t.thingsId, t]));
-  const localChanges = {
-    upserted: [],
-    deleted: []
-  };
-  for (const [thingsId, todo] of currentTodosMap) {
-    const prev = localState.todos.get(thingsId);
-    if (!prev || hasChanged(prev, todo)) {
-      localChanges.upserted.push(todo);
+  const isFirstSync = Object.keys(localState.todos).length === 0 && Object.keys(localState.serverIdToThingsId).length === 0;
+  let pushed = 0;
+  let pulled = 0;
+  let conflictCount = 0;
+  try {
+    const currentTodos = getTodosFromProject(config.projectName);
+    logDebug(`Read Things: todos=${currentTodos.length}`);
+    const positionMap = new Map(
+      currentTodos.map((todo, idx) => [todo.thingsId, idx])
+    );
+    const currentTodosMap = new Map(currentTodos.map((t) => [t.thingsId, t]));
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const dirtyUpserted = new Set(localState.dirty.upserted);
+    for (const [thingsId, todo] of currentTodosMap) {
+      const prev = localState.todos[thingsId];
+      const position = positionMap.get(thingsId) ?? 0;
+      if (!prev) {
+        localState.todos[thingsId] = {
+          thingsId,
+          title: todo.title,
+          notes: todo.notes,
+          dueDate: todo.dueDate,
+          tags: todo.tags,
+          status: todo.status,
+          position,
+          editedAt: now
+        };
+        dirtyUpserted.add(thingsId);
+        continue;
+      }
+      if (hasChanged(prev, todo, position)) {
+        localState.todos[thingsId] = {
+          ...prev,
+          title: todo.title,
+          notes: todo.notes,
+          dueDate: todo.dueDate,
+          tags: todo.tags,
+          status: todo.status,
+          position,
+          editedAt: now
+        };
+        dirtyUpserted.add(thingsId);
+      }
     }
+    for (const thingsId of Object.keys(localState.todos)) {
+      if (!currentTodosMap.has(thingsId)) {
+        const serverId = findServerId(localState.serverIdToThingsId, thingsId);
+        if (serverId) {
+          if (!localState.dirty.deleted[serverId]) {
+            localState.dirty.deleted[serverId] = now;
+          }
+        }
+        delete localState.todos[thingsId];
+      }
+    }
+    localState.dirty.upserted = Array.from(dirtyUpserted);
+    localState.dirty.upserted = localState.dirty.upserted.filter(
+      (id) => currentTodosMap.has(id)
+    );
+    logDebug(
+      `Local changes: upserted=${localState.dirty.upserted.length}, deleted=${Object.keys(localState.dirty.deleted).length}`
+    );
+    const pushUpserts = buildUpserts(currentTodosMap, localState);
+    const pushDeletes = buildDeletes(currentTodosMap, localState);
+    logDebug(
+      `Push payload: upserted=${pushUpserts.length}, deleted=${pushDeletes.length}`
+    );
+    if (pushUpserts.length > 0 || pushDeletes.length > 0) {
+      logDebug(
+        `Push payload body: ${JSON.stringify({
+          todos: { upserted: pushUpserts, deleted: pushDeletes },
+          lastSyncedAt: localState.lastSyncedAt
+        })}`
+      );
+    }
+    if (pushUpserts.length > 0 || pushDeletes.length > 0) {
+      const pushResponse = await api.push({
+        todos: {
+          upserted: pushUpserts,
+          deleted: pushDeletes
+        },
+        lastSyncedAt: localState.lastSyncedAt
+      });
+      pushed = pushUpserts.length + pushDeletes.length;
+      processPushMappings(localState, pushResponse);
+      const conflictEntries = conflictsFromPush(pushResponse);
+      logDebug(
+        `Push response: conflicts=${conflictEntries.length}, mappings=${pushResponse.mappings?.length ?? 0}`
+      );
+      conflictCount += conflictEntries.length;
+      appendConflicts(conflictEntries);
+      localState.dirty = { upserted: [], deleted: {} };
+    }
+    const delta = await getServerDelta(api, localState, currentTodos);
+    logDebug(
+      `Delta response: upserted=${delta.todos.upserted.length}, deleted=${delta.todos.deleted.length}, syncedAt=${delta.syncedAt}`
+    );
+    const remoteResult = await applyRemoteChanges(
+      config.thingsAuthToken,
+      config.projectName,
+      delta.todos.upserted,
+      delta.todos.deleted,
+      currentTodosMap,
+      localState
+    );
+    pulled += remoteResult.applied;
+    conflictCount += remoteResult.conflicts.length;
+    appendConflicts(remoteResult.conflicts);
+    localState.lastSyncedAt = delta.syncedAt;
+    saveLocalState(localState);
+    logSync(pushed, pulled, isFirstSync, conflictCount);
+    if (conflictCount > 0) {
+      notifyConflicts(conflictCount);
+    }
+  } catch (error) {
+    logError("Sync failed", error);
+    saveLocalState(localState);
+    throw error;
+  } finally {
+    releaseLock();
+  }
+  return { pushed, pulled, isFirstSync, conflicts: conflictCount };
+}
+function hasChanged(prev, curr, position) {
+  return prev.title !== curr.title || prev.notes !== curr.notes || prev.dueDate !== curr.dueDate || prev.status !== curr.status || prev.position !== position || JSON.stringify(prev.tags) !== JSON.stringify(curr.tags);
+}
+function buildUpserts(currentTodosMap, state) {
+  const thingsIdToServerId = invertMapping(state.serverIdToThingsId);
+  const upserts = [];
+  for (const thingsId of state.dirty.upserted) {
+    const todo = currentTodosMap.get(thingsId);
+    const stored = state.todos[thingsId];
+    if (!todo || !stored) continue;
+    upserts.push({
+      serverId: thingsIdToServerId.get(thingsId),
+      clientId: thingsId,
+      title: stored.title,
+      notes: stored.notes,
+      dueDate: stored.dueDate,
+      tags: stored.tags,
+      status: stored.status,
+      position: stored.position,
+      editedAt: stored.editedAt
+    });
   }
-  for (const thingsId of localState.todos.keys()) {
-    if (!currentTodosMap.has(thingsId)) {
-      localChanges.deleted.push(thingsId);
+  return upserts;
+}
+function buildDeletes(currentTodosMap, state) {
+  const deletes = [];
+  for (const [serverId, deletedAt] of Object.entries(state.dirty.deleted)) {
+    const thingsId = state.serverIdToThingsId[serverId];
+    if (thingsId && currentTodosMap.has(thingsId)) {
+      delete state.dirty.deleted[serverId];
+      continue;
     }
+    deletes.push({ serverId, deletedAt });
   }
-  const thingsIdToServerId = /* @__PURE__ */ new Map();
-  for (const [serverId, thingsId] of localState.serverIdToThingsId) {
-    thingsIdToServerId.set(thingsId, serverId);
+  return deletes;
+}
+function processPushMappings(state, response) {
+  if (!response.mappings) return;
+  for (const mapping of response.mappings) {
+    if (!mapping.clientId) continue;
+    setMapping(state, mapping.serverId, mapping.clientId);
   }
-  let pushed = 0;
-  if (localChanges.upserted.length > 0 || localChanges.deleted.length > 0) {
-    const pushRequest = {
-      headings: { upserted: [], deleted: [] },
+}
+function conflictsFromPush(response) {
+  if (!response.conflicts || response.conflicts.length === 0) return [];
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  return response.conflicts.map((conflict) => ({
+    timestamp,
+    serverId: conflict.serverId,
+    title: conflict.clientTodo?.title || conflict.serverTodo?.title || "Unknown",
+    yourVersion: conflict.clientTodo ? {
+      title: conflict.clientTodo.title,
+      editedAt: conflict.clientTodo.editedAt
+    } : conflict.clientDeletedAt ? { deletedAt: conflict.clientDeletedAt } : {},
+    winningVersion: conflict.serverTodo ? {
+      title: conflict.serverTodo.title,
+      editedAt: conflict.serverTodo.editedAt
+    } : conflict.clientDeletedAt ? { deletedAt: conflict.clientDeletedAt } : {},
+    reason: conflict.reason
+  }));
+}
+async function getServerDelta(api, state, currentTodos) {
+  const shouldBootstrap = Object.keys(state.todos).length === 0 && Object.keys(state.serverIdToThingsId).length === 0 && currentTodos.length === 0;
+  if (shouldBootstrap) {
+    const fullState = await api.getState();
+    return {
       todos: {
-        upserted: localChanges.upserted.map((t, idx) => ({
-          // Include serverId if we know it (for updates)
-          serverId: thingsIdToServerId.get(t.thingsId),
-          thingsId: t.thingsId,
-          title: t.title,
-          notes: t.notes,
-          dueDate: t.dueDate,
-          tags: t.tags,
-          status: t.status,
-          headingId: t.headingThingsId,
-          position: idx
-        })),
-        // Convert thingsIds to serverIds for deletions
-        deleted: localChanges.deleted.map((thingsId) => thingsIdToServerId.get(thingsId)).filter((id) => id !== void 0)
+        upserted: fullState.todos,
+        deleted: []
       },
-      lastSyncedAt: localState.lastSyncedAt
+      syncedAt: fullState.syncedAt
     };
-    const pushResponse = await api.push(pushRequest);
-    pushed = localChanges.upserted.length + localChanges.deleted.length;
-    for (const serverTodo of pushResponse.state.todos) {
-      const localTodo = currentTodosMap.get(serverTodo.thingsId);
-      if (localTodo) {
-        localState.serverIdToThingsId.set(serverTodo.id, localTodo.thingsId);
-      }
-    }
   }
-  const delta = await api.getDelta(localState.lastSyncedAt);
-  let pulled = 0;
-  for (const remoteTodo of delta.todos.upserted) {
-    const localThingsId = localState.serverIdToThingsId.get(remoteTodo.id);
-    const localTodo = localThingsId ? currentTodosMap.get(localThingsId) : null;
-    if (!localTodo) {
-      const beforeTodos = new Set(currentTodosMap.keys());
-      createTodo(config.projectName, {
+  return api.getDelta(state.lastSyncedAt);
+}
+async function applyRemoteChanges(authToken, projectName, upserted, deleted, currentTodosMap, state) {
+  let applied = 0;
+  const conflicts = [];
+  for (const remoteTodo of upserted) {
+    const localThingsId = state.serverIdToThingsId[remoteTodo.id];
+    const localTodo = localThingsId ? currentTodosMap.get(localThingsId) : void 0;
+    const localStateTodo = localThingsId ? state.todos[localThingsId] : void 0;
+    if (!localTodo || !localThingsId) {
+      const before = new Set(currentTodosMap.keys());
+      createTodo(projectName, {
         title: remoteTodo.title,
         notes: remoteTodo.notes,
         dueDate: remoteTodo.dueDate || void 0,
         tags: remoteTodo.tags
       });
       logTodoCreated(remoteTodo.title);
-      let newTodo;
-      for (let attempt = 0; attempt < 3; attempt++) {
-        await new Promise((resolve) => setTimeout(resolve, 500));
-        const afterTodos = getTodosFromProject(config.projectName);
-        newTodo = afterTodos.find(
-          (t) => !beforeTodos.has(t.thingsId) && t.title === remoteTodo.title
-        );
-        if (!newTodo) {
-          newTodo = afterTodos.find((t) => !beforeTodos.has(t.thingsId));
-        }
-        if (newTodo) break;
-      }
+      const newTodo = await findNewTodo(projectName, before, remoteTodo.title);
       if (newTodo) {
-        localState.serverIdToThingsId.set(remoteTodo.id, newTodo.thingsId);
+        setMapping(state, remoteTodo.id, newTodo.thingsId);
+        state.todos[newTodo.thingsId] = {
+          thingsId: newTodo.thingsId,
+          title: remoteTodo.title,
+          notes: remoteTodo.notes,
+          dueDate: remoteTodo.dueDate,
+          tags: remoteTodo.tags,
+          status: remoteTodo.status,
+          position: remoteTodo.position,
+          editedAt: remoteTodo.editedAt
+        };
         currentTodosMap.set(newTodo.thingsId, newTodo);
-        logMapping(remoteTodo.id, newTodo.thingsId);
+        if (remoteTodo.status !== "open") {
+          try {
+            updateTodo(authToken, newTodo.thingsId, {
+              completed: remoteTodo.status === "completed",
+              canceled: remoteTodo.status === "canceled"
+            });
+          } catch (error) {
+            logWarn(
+              `Failed to set status for ${newTodo.thingsId}: ${String(error)}`
+            );
+          }
+        }
       } else {
-        logError(
-          `Failed to find newly created todo for server ${remoteTodo.id}`,
-          remoteTodo.title
-        );
+        logWarn(`Failed to locate created todo for server ${remoteTodo.id}`);
       }
-      pulled++;
-    } else if (hasRemoteChanged(localTodo, remoteTodo)) {
-      updateTodo(config.thingsAuthToken, localTodo.thingsId, {
+      applied += 1;
+      continue;
+    }
+    if (!localStateTodo || compareIso(remoteTodo.editedAt, localStateTodo.editedAt) >= 0) {
+      updateTodo(authToken, localTodo.thingsId, {
         title: remoteTodo.title,
         notes: remoteTodo.notes,
         dueDate: remoteTodo.dueDate || void 0,
@@ -533,25 +887,101 @@ async function runSync() {
         canceled: remoteTodo.status === "canceled"
       });
       logTodoUpdated(localTodo.thingsId, remoteTodo.title);
-      pulled++;
+      state.todos[localTodo.thingsId] = {
+        thingsId: localTodo.thingsId,
+        title: remoteTodo.title,
+        notes: remoteTodo.notes,
+        dueDate: remoteTodo.dueDate,
+        tags: remoteTodo.tags,
+        status: remoteTodo.status,
+        position: remoteTodo.position,
+        editedAt: remoteTodo.editedAt
+      };
+      applied += 1;
     }
   }
-  if (delta.todos.deleted.length > 0) {
-    log(
-      `Remote deletions (manual action needed): ${delta.todos.deleted.join(", ")}`
-    );
+  for (const deletion of deleted) {
+    const localThingsId = state.serverIdToThingsId[deletion.serverId];
+    if (!localThingsId) continue;
+    const existsInThings = currentTodosMap.has(localThingsId);
+    const localStateTodo = state.todos[localThingsId];
+    if (!existsInThings && !localStateTodo) {
+      delete state.serverIdToThingsId[deletion.serverId];
+      continue;
+    }
+    if (!localStateTodo) continue;
+    if (compareIso(deletion.deletedAt, localStateTodo.editedAt) < 0) {
+      continue;
+    }
+    conflicts.push({
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      serverId: deletion.serverId,
+      title: localStateTodo.title,
+      yourVersion: {
+        title: localStateTodo.title,
+        editedAt: localStateTodo.editedAt
+      },
+      winningVersion: { deletedAt: deletion.deletedAt },
+      reason: "Remote delete was newer (manual delete required)"
+    });
   }
-  localState.lastSyncedAt = delta.syncedAt;
-  localState.todos = currentTodosMap;
-  saveLocalState(localState);
-  logSync(pushed, pulled, isFirstSync);
-  return { pushed, pulled, isFirstSync };
+  return { applied, conflicts };
 }
-function hasChanged(prev, curr) {
-  return prev.title !== curr.title || prev.notes !== curr.notes || prev.dueDate !== curr.dueDate || prev.status !== curr.status || JSON.stringify(prev.tags) !== JSON.stringify(curr.tags);
+function invertMapping(mapping) {
+  const result = /* @__PURE__ */ new Map();
+  for (const [serverId, thingsId] of Object.entries(mapping)) {
+    result.set(thingsId, serverId);
+  }
+  return result;
 }
-function hasRemoteChanged(local, remote) {
-  return local.title !== remote.title || local.notes !== remote.notes || local.dueDate !== remote.dueDate || local.status !== remote.status || JSON.stringify(local.tags) !== JSON.stringify(remote.tags);
+function findServerId(mapping, thingsId) {
+  for (const [serverId, mappedThingsId] of Object.entries(mapping)) {
+    if (mappedThingsId === thingsId) return serverId;
+  }
+  return void 0;
+}
+function setMapping(state, serverId, thingsId) {
+  const existing = state.serverIdToThingsId[serverId];
+  if (existing && existing !== thingsId) {
+    if (state.todos[existing]) {
+      throw new Error(
+        `Duplicate mapping detected for serverId ${serverId} (${existing} vs ${thingsId})`
+      );
+    }
+  }
+  for (const [sid, tid] of Object.entries(state.serverIdToThingsId)) {
+    if (tid === thingsId && sid !== serverId) {
+      throw new Error(
+        `Duplicate mapping detected for thingsId ${thingsId} (${sid} vs ${serverId})`
+      );
+    }
+  }
+  state.serverIdToThingsId[serverId] = thingsId;
+  logMapping(serverId, thingsId);
+}
+function validateMapping(todos, mapping) {
+  const thingsIds = new Set(Object.values(mapping));
+  if (thingsIds.size !== Object.values(mapping).length) {
+    throw new Error("Invalid mapping detected: duplicate thingsId entries.");
+  }
+  for (const thingsId of Object.values(mapping)) {
+    if (!todos[thingsId]) {
+    }
+  }
+}
+function compareIso(a, b) {
+  return new Date(a).getTime() - new Date(b).getTime();
+}
+async function findNewTodo(projectName, before, title) {
+  for (let attempt = 0; attempt < 3; attempt++) {
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    const after = getTodosFromProject(projectName);
+    const found = after.find(
+      (t) => !before.has(t.thingsId) && t.title === title
+    );
+    if (found) return found;
+  }
+  return void 0;
 }
 
 // src/cli.ts
@@ -664,10 +1094,14 @@ program.command("init").description("Setup wizard").action(async () => {
   });
   console.log("\n\u23F3 Checking Things project...");
   const todos = getTodosFromProject(projectName);
-  console.log(
-    `\u2705 Found ${todos.length} todo${todos.length === 1 ? "" : "s"} in "${projectName}"
-`
-  );
+  if (todos.length > 0) {
+    console.error(
+      `\u274C Project "${projectName}" must be empty for first sync (found ${todos.length}).`
+    );
+    process.exit(1);
+  }
+  console.log(`\u2705 Project "${projectName}" is empty.
+`);
   console.log("\u{1F4CB} Find your Things Auth Token in:");
   console.log("   Things \u2192 Settings \u2192 General \u2192 Things URLs \u2192 Manage\n");
   const thingsAuthToken = await password({
@@ -685,19 +1119,42 @@ program.command("init").description("Setup wizard").action(async () => {
     pollInterval: 30,
     thingsAuthToken
   });
+  writeState({
+    lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    todos: {},
+    serverIdToThingsId: {},
+    dirty: { upserted: [], deleted: {} }
+  });
   console.log("\n\u2705 Configuration saved!\n");
-  console.log("Next steps:");
-  console.log('  1. Run "shared-things install" to start the daemon');
-  console.log('  2. Or run "shared-things sync" for a one-time sync\n');
+  const install = await confirm({
+    message: "Install LaunchAgent to run sync automatically on login?",
+    default: true
+  });
+  if (install) {
+    installLaunchAgent();
+  }
+  console.log("\nNext steps:");
+  console.log('  1. Run "shared-things sync" for a one-time sync');
+  console.log('  2. Or run "shared-things start" to run the daemon\n');
+});
+program.command("start").description("Start the sync daemon (launchd)").action(() => {
+  if (!configExists()) {
+    console.error('Not configured. Run "shared-things init" first.');
+    process.exit(1);
+  }
+  startLaunchAgent();
+});
+program.command("stop").description("Stop the sync daemon (launchd)").action(() => {
+  stopLaunchAgent();
 });
-program.command("install").description("Install launchd daemon (auto-start at login)").action(() => {
+program.command("install").description("Install launchd daemon (deprecated)").action(() => {
   if (!configExists()) {
     console.error('Not configured. Run "shared-things init" first.');
     process.exit(1);
   }
   installLaunchAgent();
 });
-program.command("uninstall").description("Remove launchd daemon").action(() => {
+program.command("uninstall").description("Remove launchd daemon (deprecated)").action(() => {
   uninstallLaunchAgent();
 });
 program.command("status").description("Show sync status").action(async () => {
@@ -728,15 +1185,23 @@ program.command("status").description("Show sync status").action(async () => {
   console.log(
     `${chalk.dim("Daemon:")}    ${isRunning ? chalk.green("\u25CF running") : chalk.red("\u25CB stopped")}`
   );
-  const statePath = path5.join(getConfigDir(), "state.json");
-  if (fs5.existsSync(statePath)) {
-    const state = JSON.parse(fs5.readFileSync(statePath, "utf-8"));
+  const state = readState();
+  if (state) {
     const lastSync = new Date(state.lastSyncedAt);
     const ago = formatTimeAgo(lastSync);
     console.log(`${chalk.dim("Last sync:")} ${ago}`);
+    console.log(
+      `${chalk.dim("Dirty:")}    upserted=${state.dirty.upserted.length}, deleted=${Object.keys(state.dirty.deleted).length}`
+    );
   } else {
     console.log(`${chalk.dim("Last sync:")} ${chalk.yellow("never")}`);
   }
+  const conflicts = readConflicts();
+  if (conflicts.length > 0) {
+    console.log(
+      `${chalk.dim("Conflicts:")} ${chalk.yellow(conflicts.length)} (run "shared-things conflicts")`
+    );
+  }
   console.log();
 });
 function formatTimeAgo(date) {
@@ -756,12 +1221,15 @@ program.command("sync").description("Manual one-time sync").action(async () => {
   }
   try {
     const result = await runSync();
-    if (result.isFirstSync) {
-      console.log(chalk.cyan("\u{1F4E5} First sync completed!"));
+    if (result.skipped) {
+      console.log(chalk.yellow("\u26A0\uFE0F  Sync skipped (another sync is running)."));
+      return;
     }
+    if (result.isFirstSync)
+      console.log(chalk.cyan("\u{1F4E5} First sync completed!"));
     console.log(
       chalk.green(
-        `\u2705 Done! Pushed: ${result.pushed}, Pulled: ${result.pulled}`
+        `\u2705 Done! Pushed: ${result.pushed}, Pulled: ${result.pulled}, Conflicts: ${result.conflicts}`
       )
     );
   } catch (error) {
@@ -776,18 +1244,18 @@ program.command("daemon").description("Run sync daemon (used by launchd)").actio
     process.exit(1);
   }
   const config = loadConfig();
-  logDaemonStart();
-  log(`Polling interval: ${config.pollInterval}s`);
+  logInfo("Daemon started");
+  logInfo(`Polling interval: ${config.pollInterval}s`);
   console.log(`Daemon started. Syncing every ${config.pollInterval}s...`);
   const shutdown = () => {
-    logDaemonStop();
+    logInfo("Daemon stopped");
     process.exit(0);
   };
   process.on("SIGTERM", shutdown);
   process.on("SIGINT", shutdown);
   try {
     await runSync();
-    log("Initial sync complete");
+    logInfo("Initial sync complete");
   } catch (error) {
     logError("Initial sync failed", error);
   }
@@ -799,8 +1267,8 @@ program.command("daemon").description("Run sync daemon (used by launchd)").actio
     }
   }, config.pollInterval * 1e3);
 });
-program.command("logs").description("Show daemon logs").option("-f, --follow", "Follow log output").action((options) => {
-  const logPath = path5.join(getConfigDir(), "daemon.log");
+program.command("logs").description("Show sync logs").option("-f, --follow", "Follow log output").action((options) => {
+  const logPath = path5.join(getConfigDir(), "sync.log");
   if (!fs5.existsSync(logPath)) {
     console.log("No logs yet.");
     return;
@@ -812,24 +1280,34 @@ program.command("logs").description("Show daemon logs").option("-f, --follow", "
     console.log(logs);
   }
 });
-program.command("reset").description("Reset sync state (next sync will be a fresh start)").option("-s, --server", "Also delete all data on the server").action(async (options) => {
+program.command("reset").description("Reset sync state").option("--local", "Clear local state (re-sync from server)").option("--server", "Clear server data for this user").action(async (options) => {
   if (!configExists()) {
     console.log(chalk.yellow("Not configured. Nothing to reset."));
     return;
   }
-  const statePath = path5.join(getConfigDir(), "state.json");
-  const hasLocalState = fs5.existsSync(statePath);
-  if (!hasLocalState && !options.server) {
-    console.log(chalk.yellow("No sync state to reset."));
+  if (!options.local && !options.server) {
+    console.log(chalk.yellow("Specify --local and/or --server to reset."));
     return;
   }
-  let message = "This will clear your local sync state.";
-  if (options.server) {
-    message = "This will clear your local sync state AND delete all your data on the server.";
+  const config = loadConfig();
+  const statePath = path5.join(getConfigDir(), "state.json");
+  const hasLocalState = fs5.existsSync(statePath);
+  if (options.local) {
+    try {
+      const todos = getTodosFromProject(config.projectName);
+      if (todos.length > 0) {
+        console.error(
+          `\u274C Project "${config.projectName}" must be empty to reset local state.`
+        );
+        return;
+      }
+    } catch (error) {
+      console.error(`\u274C Failed to read Things project: ${error}`);
+      return;
+    }
   }
-  message += " Continue?";
   const confirmed = await confirm({
-    message,
+    message: "This action cannot be undone. Continue?",
     default: false
   });
   if (!confirmed) {
@@ -837,18 +1315,13 @@ program.command("reset").description("Reset sync state (next sync will be a fres
     return;
   }
   if (options.server) {
-    const config = loadConfig();
     const api = new ApiClient(config.serverUrl, config.apiKey);
     try {
       console.log(chalk.dim("Deleting server data..."));
       const result = await api.reset();
-      log(
-        `Server reset: deleted ${result.deleted.todos} todos, ${result.deleted.headings} headings`
-      );
+      logInfo(`Server reset: deleted ${result.deleted.todos} todos`);
       console.log(
-        chalk.green(
-          `\u2705 Server data deleted (${result.deleted.todos} todos, ${result.deleted.headings} headings)`
-        )
+        chalk.green(`\u2705 Server data deleted (${result.deleted.todos} todos)`)
       );
     } catch (error) {
       logError("Server reset failed", error);
@@ -856,9 +1329,19 @@ program.command("reset").description("Reset sync state (next sync will be a fres
       return;
     }
   }
-  if (hasLocalState) {
-    fs5.unlinkSync(statePath);
-    log("Sync state reset by user");
+  if (options.local) {
+    if (hasLocalState) {
+      fs5.unlinkSync(statePath);
+    }
+    const conflictsPath = path5.join(getConfigDir(), "conflicts.json");
+    if (fs5.existsSync(conflictsPath)) fs5.unlinkSync(conflictsPath);
+    writeState({
+      lastSyncedAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+      todos: {},
+      serverIdToThingsId: {},
+      dirty: { upserted: [], deleted: {} }
+    });
+    logInfo("Local sync state reset by user");
   }
   console.log(
     chalk.green(
@@ -866,32 +1349,121 @@ program.command("reset").description("Reset sync state (next sync will be a fres
     )
   );
 });
-program.command("purge").description("Remove all local data (config, state, logs)").action(async () => {
-  const configDir = getConfigDir();
-  if (!fs5.existsSync(configDir)) {
-    console.log(chalk.yellow("Nothing to purge."));
+program.command("conflicts").description("Show conflict history").option("--all", "Show all conflicts").action((options) => {
+  const conflicts = readConflicts();
+  if (conflicts.length === 0) {
+    console.log("No conflicts recorded.");
     return;
   }
-  const daemonStatus = getLaunchAgentStatus();
-  if (daemonStatus === "running") {
+  const shown = options.all ? conflicts : conflicts.slice(-10);
+  console.log(chalk.bold(`
+\u26A0\uFE0F  Conflicts (${shown.length})
+`));
+  for (const conflict of shown) {
     console.log(
-      chalk.yellow("\u26A0\uFE0F  Daemon is still running. Stopping it first...")
+      `${chalk.dim(conflict.timestamp)} ${chalk.white(conflict.title)} (${conflict.serverId})`
     );
-    uninstallLaunchAgent();
+    console.log(`  ${chalk.dim("Reason:")} ${conflict.reason}`);
+    if (conflict.yourVersion.editedAt || conflict.yourVersion.deletedAt) {
+      console.log(
+        `  ${chalk.dim("Yours:")} ${formatConflictVersion(conflict.yourVersion)}`
+      );
+    }
+    if (conflict.winningVersion.editedAt || conflict.winningVersion.deletedAt) {
+      console.log(
+        `  ${chalk.dim("Winner:")} ${formatConflictVersion(conflict.winningVersion)}`
+      );
+    }
+    console.log();
   }
-  const confirmed = await confirm({
-    message: `This will delete all local data in ${configDir}. You will need to run "init" again. Continue?`,
-    default: false
-  });
-  if (!confirmed) {
-    console.log(chalk.dim("Cancelled."));
+});
+program.command("repair").description("Diagnose state issues (no auto-fix)").action(() => {
+  const issues = [];
+  if (!configExists()) {
+    issues.push("Missing config.json (run init)");
+  }
+  const state = readState();
+  if (!state) {
+    issues.push("Missing or invalid state.json");
+  }
+  if (issues.length === 0) {
+    console.log(chalk.green("No issues detected."));
+  } else {
+    console.log(chalk.yellow("Issues detected:"));
+    for (const issue of issues) {
+      console.log(`- ${issue}`);
+    }
+  }
+});
+program.command("doctor").description("Comprehensive health check").action(async () => {
+  console.log(chalk.bold("\n\u{1FA7A} shared-things Doctor\n"));
+  if (!configExists()) {
+    console.log(chalk.red("Config: missing (run init)"));
     return;
   }
-  fs5.rmSync(configDir, { recursive: true, force: true });
+  const config = loadConfig();
+  console.log(chalk.green("Config: ok"));
+  const state = readState();
   console.log(
-    chalk.green(
-      '\u2705 All local data removed. Run "shared-things init" to start fresh.'
-    )
+    state ? chalk.green("State: ok") : chalk.red("State: missing/invalid")
   );
+  if (!isThingsRunning()) {
+    console.log(chalk.yellow("Things 3: not running"));
+  } else {
+    console.log(chalk.green("Things 3: running"));
+  }
+  const projects = listProjects();
+  if (!projects.includes(config.projectName)) {
+    console.log(chalk.red(`Project: "${config.projectName}" not found`));
+  } else {
+    console.log(chalk.green(`Project: ${config.projectName}`));
+  }
+  const api = new ApiClient(config.serverUrl, config.apiKey);
+  try {
+    await api.health();
+    console.log(chalk.green("Server: reachable"));
+  } catch {
+    console.log(chalk.red("Server: unreachable"));
+  }
+  const daemonStatus = getLaunchAgentStatus();
+  console.log(chalk.green(`Daemon: ${daemonStatus}`));
+  console.log();
 });
+function readState() {
+  const statePath = path5.join(getConfigDir(), "state.json");
+  if (!fs5.existsSync(statePath)) return null;
+  try {
+    const raw = fs5.readFileSync(statePath, "utf-8");
+    const data = JSON.parse(raw);
+    return {
+      lastSyncedAt: data.lastSyncedAt,
+      dirty: {
+        upserted: data.dirty?.upserted ?? [],
+        deleted: data.dirty?.deleted ?? {}
+      }
+    };
+  } catch {
+    return null;
+  }
+}
+function readConflicts() {
+  const conflictsPath = path5.join(getConfigDir(), "conflicts.json");
+  if (!fs5.existsSync(conflictsPath)) return [];
+  try {
+    return JSON.parse(fs5.readFileSync(conflictsPath, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function formatConflictVersion(version) {
+  if (version.deletedAt) return `deletedAt=${version.deletedAt}`;
+  if (version.editedAt) return `editedAt=${version.editedAt}`;
+  return "unknown";
+}
+function writeState(state) {
+  const statePath = path5.join(getConfigDir(), "state.json");
+  const temp = `${statePath}.tmp-${process.pid}`;
+  fs5.writeFileSync(temp, JSON.stringify(state, null, 2));
+  fs5.renameSync(temp, statePath);
+}
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shared-things-daemon",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "description": "Sync Things 3 projects between multiple macOS users",
   "type": "module",
   "main": "./dist/cli.js",