@gobi-ai/cli 0.6.14 → 0.6.16

package/README.md

@@ -44,7 +44,7 @@ gobi space warp
 gobi brain search --query "machine learning"
 
 # Ask a brain a question
-gobi brain ask --vault-slug my-vault --space-slug my-space --question "What is RAG?"
+gobi brain ask --vault-slug my-vault --question "What is RAG?"
 ```
 
 ## Commands
@@ -62,27 +62,35 @@ gobi brain ask --vault-slug my-vault --space-slug my-space --question "What is R
 | Command | Description |
 |---------|-------------|
 | `gobi init` | Log in (if needed) and select or create a vault |
-| `gobi space warp` | Select the active space |
+| `gobi space list` | List spaces you are a member of |
+| `gobi space warp [spaceSlug]` | Select the active space (interactive if slug omitted) |
 
 ### Brains
 
 | Command | Description |
 |---------|-------------|
-| `gobi brain search --query <q>` | Search brains across all your spaces |
-| `gobi brain ask --vault-slug <slug> --space-slug <slug> --question <q>` | Ask a brain a question (creates a 1:1 session) |
+| `gobi brain search --query <q>` | Search public brains by text and semantic similarity |
+| `gobi brain ask --vault-slug <slug> --question <q>` | Ask a brain a question (creates a 1:1 session) |
 | `gobi brain publish` | Upload `BRAIN.md` to your vault |
 | `gobi brain unpublish` | Remove `BRAIN.md` from your vault |
 
+Public brains are accessible at `https://gobispace.com/@{vaultSlug}`.
+
+`brain ask` also accepts `--rich-text <json>` (mutually exclusive with `--question`) and `--mode <auto|manual>`.
+
 ### Brain Updates
 
 | Command | Description |
 |---------|-------------|
-| `gobi brain list-updates` | List brain updates for your vault |
+| `gobi brain list-updates` | List brain updates |
 | `gobi brain list-updates --mine` | List only your own brain updates |
 | `gobi brain post-update --title <t> --content <c>` | Post a brain update |
-| `gobi brain edit-update <id> --title <t>` | Edit a brain update |
+| `gobi brain edit-update <id> [--title <t>] [--content <c>]` | Edit a brain update (at least one required) |
 | `gobi brain delete-update <id>` | Delete a brain update |
 
+`list-updates` also accepts `--space-slug <slug>` to scope to a space, and `--limit`/`--cursor` for pagination.
+`post-update` and `edit-update` accept `--auto-attachments` to upload wiki-linked `[[files]]` before posting.
+
 ### Threads
 
 | Command | Description |
@@ -90,7 +98,7 @@ gobi brain ask --vault-slug my-vault --space-slug my-space --question "What is R
 | `gobi space list-threads` | List threads in the current space |
 | `gobi space get-thread <id>` | Get a thread and its replies |
 | `gobi space create-thread --title <t> --content <c>` | Create a thread |
-| `gobi space edit-thread <id> --title <t>` | Edit a thread |
+| `gobi space edit-thread <id> [--title <t>] [--content <c>]` | Edit a thread (at least one required) |
 | `gobi space delete-thread <id>` | Delete a thread |
 
 ### Replies
@@ -108,15 +116,44 @@ gobi brain ask --vault-slug my-vault --space-slug my-space --question "What is R
 | `gobi session list` | List your sessions |
 | `gobi session get <id>` | Get a session and its messages |
 | `gobi session reply <id> --content <c>` | Send a message in a session |
-| `gobi session update <id> --mode <mode>` | Set session mode (auto/manual) |
 
-### Global options
+`session reply` also accepts `--rich-text <json>` (mutually exclusive with `--content`).
+
+### Sense
+
+| Command | Description |
+|---------|-------------|
+| `gobi sense activities --start-time <iso> --end-time <iso>` | Fetch activity records in a time range |
+| `gobi sense transcriptions --start-time <iso> --end-time <iso>` | Fetch transcription records in a time range |
+
+Times are ISO 8601 UTC (e.g. `2026-03-20T00:00:00Z`).
+
+### Sync
+
+| Command | Description |
+|---------|-------------|
+| `gobi sync` | Sync local vault files with Gobi Webdrive |
 
 | Option | Description |
 |--------|-------------|
-| `--json` | Output results as JSON |
-| `--space-slug <slug>` | Override the default space (on `space` commands); required on `brain ask`, optional filter on `session list` |
-| `--vault-slug <slug>` | Override the default vault (on `brain list-updates` and `brain post-update`) |
+| `--upload-only` | Only upload local changes to server |
+| `--download-only` | Only download server changes to local |
+| `--conflict <strategy>` | Conflict resolution: `ask` (default), `server`, `client`, `skip` |
+| `--dir <path>` | Local vault directory (default: current directory) |
+| `--dry-run` | Preview changes without making them |
+| `--full` | Full sync: ignore cursor and hash cache, re-check every file |
+| `--path <path>` | Restrict sync to specific file/folder (repeatable) |
+| `--plan-file <path>` | Write dry-run plan to file, or read plan to execute |
+| `--execute` | Execute a previously written plan file (requires `--plan-file`) |
+| `--conflict-choices <json>` | Per-file conflict resolutions as JSON (use with `--execute`) |
+
+### Global options
+
+| Option | Scope | Description |
+|--------|-------|-------------|
+| `--json` | All commands | Output results as JSON |
+| `--space-slug <slug>` | `space` commands | Override the default space (from `.gobi/settings.yaml`) |
+| `--vault-slug <slug>` | Per-command | Override the default vault; available on `brain list-updates`, `brain post-update`, `brain edit-update`, `space create-thread`, `space edit-thread`, `space edit-reply` |
 
 ## Configuration
 
@@ -124,7 +161,7 @@ gobi brain ask --vault-slug my-vault --space-slug my-space --question "What is R
 
 | Variable | Default | Description |
 |----------|---------|-------------|
-| `GOBI_BASE_URL` | `https://backend.joingobi.com` | API server URL |
+| `GOBI_BASE_URL` | `https://api.joingobi.com` | API server URL |
 | `GOBI_WEBDRIVE_BASE_URL` | `https://webdrive.joingobi.com` | File storage URL |
 
 ### Files

package/dist/commands/sync.js

@@ -343,8 +343,12 @@ function matchesPaths(filePath, paths) {
 async function performSync(baseUrl, vaultSlug, state, syncfilesChanges, privatefilesChanges, localFiles, opts, token) {
     const body = {
         cursor: state.cursor,
-        // dryRun: don't mutate server-side syncfiles/privatefiles
-        syncfilesChanges: opts.dryRun ? { added: [], removed: [] } : syncfilesChanges,
+        // dryRun: suppress removes (destructive) but send adds so the server can
+        // compute the correct file scope for the preview. Privatefiles are fully
+        // suppressed — they don't affect file actions and should never mutate in dry-run.
+        syncfilesChanges: opts.dryRun
+            ? { added: syncfilesChanges.added, removed: [] }
+            : syncfilesChanges,
         privatefilesChanges: opts.dryRun ? { added: [], removed: [] } : privatefilesChanges,
         clientFiles: localFiles,
         uploadOnly: opts.uploadOnly,
@@ -357,6 +361,10 @@ export async function runSync(opts) {
     const baseUrl = opts.webdriveUrl ?? WEBDRIVE_BASE_URL;
     const gobiDir = join(vaultDir, ".gobi");
     mkdirSync(gobiDir, { recursive: true });
+    const token = opts.authToken ?? (await getValidToken());
+    if (opts.execute) {
+        return executeSyncPlan(opts, baseUrl, token, gobiDir);
+    }
     const state = loadSyncState(gobiDir);
     // --full: treat this run as a first-time sync (re-check every file against the server)
     if (opts.full) {
@@ -365,7 +373,6 @@ export async function runSync(opts) {
         if (!jsonMode)
             console.log("Full sync: ignoring cursor and hash cache.");
     }
-    const token = opts.authToken ?? (await getValidToken());
     // Read syncfiles whitelist
     const syncfilesExistsLocally = existsSync(join(gobiDir, "syncfiles"));
     const { patterns: currPatterns, contentHash: currSyncfilesHash } = readSyncfiles(gobiDir);
@@ -474,6 +481,26 @@ export async function runSync(opts) {
     }
     if (!jsonMode)
         console.log(` ${syncResp.files.length} action(s).`);
+    // Write plan file if requested (dry-run + --plan-file)
+    if (opts.dryRun && opts.planFile) {
+        const offlineDeletions = Object.keys(state.hashCache).filter((p) => !localPathSet.has(p) && !existsSync(join(vaultDir, p)));
+        const plan = {
+            vaultSlug,
+            syncCursor: syncResp.cursor,
+            syncfilesHash: syncResp.syncfilesHash || null,
+            privatefilesHash: syncResp.privatefilesHash || null,
+            downloadSyncfiles: !!(syncResp.syncfilesHash &&
+                (syncResp.syncfilesHash !== state.syncfilesHash || !syncfilesExistsLocally)),
+            downloadPrivatefiles: !!(syncResp.privatefilesHash &&
+                (syncResp.privatefilesHash !== state.privatefilesHash || !privatefilesExistsLocally)),
+            actions: syncResp.files.filter((f) => matchesPaths(f.path, opts.paths ?? [])),
+            offlineDeletions,
+            createdAt: new Date().toISOString(),
+        };
+        await writeFile(opts.planFile, JSON.stringify(plan, null, 2));
+        if (!jsonMode)
+            console.log(`Plan written to ${opts.planFile}`);
+    }
     // Process actions
     let uploaded = 0, downloaded = 0, deletedLocally = 0, conflicts = 0, skipped = 0, errors = 0;
     const errorDetails = [];
@@ -633,15 +660,17 @@ export async function runSync(opts) {
     }
     // Persist state (always, even on partial failures)
     const finalCursor = Math.max(syncResp.cursor, maxMutationCursor !== null ? maxMutationCursor : 0);
-    state.cursor = finalCursor;
-    state.syncfilesHash = syncResp.syncfilesHash || currSyncfilesHash;
-    // If the server returned an empty syncfilesHash the vault was deleted server-side
-    // (empty patterns path). Reset patterns so the next sync re-registers them as "added",
-    // which lets the 409 retry resurrect the vault.
-    state.patterns = syncResp.syncfilesHash === "" ? [] : effectivePatterns;
-    state.privatePatterns = effectivePrivatePatterns;
-    state.privatefilesHash = syncResp.privatefilesHash || state.privatefilesHash;
-    saveSyncState(gobiDir, state);
+    if (!opts.dryRun) {
+        state.cursor = finalCursor;
+        state.syncfilesHash = syncResp.syncfilesHash || currSyncfilesHash;
+        // If the server returned an empty syncfilesHash the vault was deleted server-side
+        // (empty patterns path). Reset patterns so the next sync re-registers them as "added",
+        // which lets the 409 retry resurrect the vault.
+        state.patterns = syncResp.syncfilesHash === "" ? [] : effectivePatterns;
+        state.privatePatterns = effectivePrivatePatterns;
+        state.privatefilesHash = syncResp.privatefilesHash || state.privatefilesHash;
+        saveSyncState(gobiDir, state);
+    }
     // Output summary
     const result = {
         uploaded,
@@ -672,6 +701,184 @@ export async function runSync(opts) {
             process.exitCode = 1;
         }
     }
+    return result;
+}
+// ─── Execute Plan ─────────────────────────────────────────────────────────────
+async function executeSyncPlan(opts, baseUrl, token, gobiDir) {
+    const { vaultSlug, dir: vaultDir, jsonMode } = opts;
+    if (!opts.planFile)
+        throw new GobiError("--execute requires --plan-file", "INVALID_OPTION");
+    if (!existsSync(opts.planFile))
+        throw new GobiError(`Plan file not found: ${opts.planFile}`, "PLAN_NOT_FOUND");
+    const plan = JSON.parse(readFileSync(opts.planFile, "utf-8"));
+    if (plan.vaultSlug !== vaultSlug)
+        throw new GobiError(`Plan is for vault "${plan.vaultSlug}", not "${vaultSlug}"`, "PLAN_MISMATCH");
+    // Validate conflict coverage upfront
+    const conflictActions = plan.actions.filter((a) => a.action === "conflict");
+    const canFallback = opts.conflict && opts.conflict !== "ask";
+    const unresolvedConflicts = conflictActions
+        .filter((a) => !opts.conflictChoices?.[a.path])
+        .map((a) => a.path);
+    if (unresolvedConflicts.length > 0 && !canFallback) {
+        throw new GobiError(`Unresolved conflicts — pass --conflict or add to --conflict-choices:\n${unresolvedConflicts.map((p) => `  ${p}`).join("\n")}`, "UNRESOLVED_CONFLICTS");
+    }
+    const state = loadSyncState(gobiDir);
+    // Execute offline deletions
+    let maxMutationCursor = null;
+    for (const path of plan.offlineDeletions) {
+        if (opts.downloadOnly)
+            continue;
+        if (!jsonMode)
+            console.log(`  Deleting remote (offline deletion): ${path}`);
+        try {
+            const cursor = await webdriveDelete(baseUrl, vaultSlug, path, token);
+            if (cursor !== null && (maxMutationCursor === null || cursor > maxMutationCursor))
+                maxMutationCursor = cursor;
+        }
+        catch (err) {
+            if (!jsonMode)
+                console.error(`  Error deleting remote ${path}: ${err.message}`);
+        }
+        delete state.hashCache[path];
+    }
+    // Execute actions from plan
+    let uploaded = 0, downloaded = 0, deletedLocally = 0, conflicts = 0, skipped = 0, errors = 0;
+    const errorDetails = [];
+    for (const entry of plan.actions) {
+        try {
+            const absPath = join(vaultDir, entry.path);
+            if (entry.action === "upload") {
+                if (opts.downloadOnly)
+                    continue;
+                const content = readFileSync(absPath);
+                const hash = md5Hex(content);
+                const cursor = await webdrivePut(baseUrl, vaultSlug, entry.path, content, hash, token);
+                if (cursor !== null && (maxMutationCursor === null || cursor > maxMutationCursor))
+                    maxMutationCursor = cursor;
+                state.hashCache[entry.path] = { hash, mtime: statSync(absPath).mtimeMs, size: content.length };
+                if (!jsonMode)
+                    console.log(`  Uploaded: ${entry.path}`);
+                uploaded++;
+            }
+            else if (entry.action === "download") {
+                if (opts.uploadOnly)
+                    continue;
+                const content = await webdriveGet(baseUrl, vaultSlug, entry.path, token);
+                mkdirSync(dirname(absPath), { recursive: true });
+                await writeFile(absPath, content);
+                const hash = md5Hex(content);
+                state.hashCache[entry.path] = { hash, mtime: statSync(absPath).mtimeMs, size: content.length };
+                if (!jsonMode)
+                    console.log(`  Downloaded: ${entry.path}`);
+                downloaded++;
+            }
+            else if (entry.action === "delete_local") {
+                if (opts.uploadOnly)
+                    continue;
+                if (!existsSync(absPath))
+                    continue;
+                await trash(absPath);
+                delete state.hashCache[entry.path];
+                if (!jsonMode)
+                    console.log(`  Deleted local (moved to trash): ${entry.path}`);
+                deletedLocally++;
+            }
+            else if (entry.action === "conflict") {
+                conflicts++;
+                const choice = opts.conflictChoices?.[entry.path] ?? opts.conflict ?? "skip";
+                if (choice === "server") {
+                    const content = await webdriveGet(baseUrl, vaultSlug, entry.path, token);
+                    mkdirSync(dirname(absPath), { recursive: true });
+                    await writeFile(absPath, content);
+                    const hash = md5Hex(content);
+                    state.hashCache[entry.path] = { hash, mtime: statSync(absPath).mtimeMs, size: content.length };
+                    if (!jsonMode)
+                        console.log(`  Conflict resolved (server): ${entry.path}`);
+                    downloaded++;
+                }
+                else if (choice === "client") {
+                    if (!jsonMode)
+                        console.log(`  Conflict resolved (local kept): ${entry.path}`);
+                }
+                else {
+                    skipped++;
+                    if (!jsonMode)
+                        console.log(`  Conflict skipped: ${entry.path}`);
+                }
+            }
+        }
+        catch (err) {
+            errors++;
+            const msg = err.message;
+            errorDetails.push({ path: entry.path, action: entry.action, error: msg });
+            if (!jsonMode)
+                console.error(`  Error [${entry.action}] ${entry.path}: ${msg}`);
+        }
+    }
+    // Download syncfiles/privatefiles as indicated by plan
+    const { patterns: currPatterns } = readSyncfiles(gobiDir);
+    let effectivePatterns = currPatterns;
+    if (plan.downloadSyncfiles) {
+        try {
+            const content = await webdriveGet(baseUrl, vaultSlug, ".gobi/syncfiles", token);
+            await writeFile(join(gobiDir, "syncfiles"), content);
+            effectivePatterns = readSyncfiles(gobiDir).patterns;
+            if (!jsonMode)
+                console.log("  Updated local syncfiles from server.");
+        }
+        catch (err) {
+            if (!jsonMode)
+                console.error(`Warning: Failed to download syncfiles: ${err.message}`);
+        }
+    }
+    let effectivePrivatePatterns = readPrivatefiles(gobiDir);
+    if (plan.downloadPrivatefiles) {
+        try {
+            const content = await webdriveGet(baseUrl, vaultSlug, ".gobi/privatefiles", token);
+            await writeFile(join(gobiDir, "privatefiles"), content);
+            effectivePrivatePatterns = readPrivatefiles(gobiDir);
+            if (!jsonMode)
+                console.log("  Updated local privatefiles from server.");
+        }
+        catch (err) {
+            if (!jsonMode)
+                console.error(`Warning: Failed to download privatefiles: ${err.message}`);
+        }
+    }
+    // Save state
+    const finalCursor = Math.max(plan.syncCursor, maxMutationCursor ?? 0);
+    state.cursor = finalCursor;
+    state.syncfilesHash = plan.syncfilesHash ?? state.syncfilesHash;
+    state.patterns = effectivePatterns;
+    state.privatePatterns = effectivePrivatePatterns;
+    state.privatefilesHash = plan.privatefilesHash ?? state.privatefilesHash;
+    saveSyncState(gobiDir, state);
+    // Delete plan file after successful execution
+    rmSync(opts.planFile, { force: true });
+    const result = {
+        uploaded,
+        downloaded,
+        deletedLocally,
+        conflicts,
+        skipped,
+        errors,
+        cursor: finalCursor,
+        errorDetails,
+    };
+    if (jsonMode) {
+        jsonOut(result);
+    }
+    else {
+        console.log("\nSync complete.");
+        console.log(`  Uploaded:      ${uploaded}`);
+        console.log(`  Downloaded:    ${downloaded}`);
+        console.log(`  Deleted local: ${deletedLocally}`);
+        console.log(`  Conflicts:     ${conflicts}`);
+        console.log(`  Errors:        ${errors}`);
+        if (errors > 0)
+            process.exitCode = 1;
+    }
+    return result;
 }
 // ─── Commander Registration ───────────────────────────────────────────────────
 export function registerSyncCommand(program) {
@@ -685,14 +892,29 @@ export function registerSyncCommand(program) {
         .option("--dry-run", "Preview changes without making them")
         .option("--full", "Full sync: ignore cursor and hash cache, re-check every file")
         .option("--path <path>", "Restrict sync to a specific file or folder (repeatable)", (v, prev) => prev.concat(v), [])
+        .option("--plan-file <path>", "Write dry-run plan to file (use with --dry-run) or read plan to execute (use with --execute)")
+        .option("--execute", "Execute a previously written plan file (requires --plan-file)")
+        .option("--conflict-choices <json>", "Per-file conflict resolutions as JSON object, e.g. '{\"file.md\":\"server\"}' (use with --execute)")
         .action(async function (opts) {
         if (opts.uploadOnly && opts.downloadOnly) {
             throw new GobiError("--upload-only and --download-only are mutually exclusive.", "INVALID_OPTION");
         }
+        if (opts.execute && !opts.planFile) {
+            throw new GobiError("--execute requires --plan-file", "INVALID_OPTION");
+        }
         const validStrategies = ["ask", "server", "client", "skip"];
         if (!validStrategies.includes(opts.conflict)) {
             throw new GobiError(`Invalid --conflict value "${opts.conflict}". Use: ask|server|client|skip`, "INVALID_OPTION");
         }
+        let conflictChoices;
+        if (opts.conflictChoices) {
+            try {
+                conflictChoices = JSON.parse(opts.conflictChoices);
+            }
+            catch {
+                throw new GobiError("--conflict-choices must be valid JSON", "INVALID_OPTION");
+            }
+        }
         const vaultSlug = getVaultSlug();
         const dir = opts.dir ? pathResolve(opts.dir) : process.cwd();
         await runSync({
@@ -704,6 +926,9 @@ export function registerSyncCommand(program) {
             dryRun: !!opts.dryRun,
             full: !!opts.full,
             paths: opts.path ?? [],
+            planFile: opts.planFile,
+            execute: !!opts.execute,
+            conflictChoices,
             jsonMode: isJsonMode(this),
         });
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gobi-ai/cli",
-  "version": "0.6.14",
+  "version": "0.6.16",
   "description": "CLI client for the Gobi collaborative knowledge platform",
   "license": "MIT",
   "type": "module",

package/skills/gobi/SKILL.md

@@ -10,12 +10,12 @@ description: >-
 allowed-tools: Bash(gobi:*)
 metadata:
   author: gobi-ai
-  version: "0.6.13"
+  version: "0.6.16"
 ---
 
 # gobi-cli
 
-A CLI client for the Gobi collaborative knowledge platform (v0.6.13).
+A CLI client for the Gobi collaborative knowledge platform (v0.6.16).
 
 ## Prerequisites
 
@@ -98,11 +98,11 @@ gobi auth status
 
 ## Gobi Brain — Knowledge Management
 
-`gobi brain` commands manage your vault's brain: search across all spaces, ask brains questions, and publish/unpublish your BRAIN.md.
+`gobi brain` commands manage your vault's brain: search across all spaces, ask brains questions, and publish/unpublish your BRAIN.md. Public brains are accessible at `https://gobispace.com/@{vaultSlug}`.
 
 ## Gobi Session — Conversations
 
-`gobi session` commands manage your conversations: list, read, reply to, and update sessions.
+`gobi session` commands manage your conversations: list, read, and reply to sessions.
 
 ## Important: JSON Mode
 
@@ -192,6 +192,8 @@ gobi auth --help
 gobi space --help
 gobi brain --help
 gobi session --help
+gobi sense --help
+gobi sync --help
 ```
 
 ## Configuration Files
@@ -206,5 +208,5 @@ gobi session --help
 
 | Variable | Default | Description |
 |----------|---------|-------------|
-| `GOBI_BASE_URL` | `https://backend.joingobi.com` | API server URL |
+| `GOBI_BASE_URL` | `https://api.joingobi.com` | API server URL |
 | `GOBI_WEBDRIVE_BASE_URL` | `https://webdrive.joingobi.com` | File storage URL |

package/skills/gobi/SKILL.template.md

@@ -98,11 +98,11 @@ gobi auth status
 
 ## Gobi Brain — Knowledge Management
 
-`gobi brain` commands manage your vault's brain: search across all spaces, ask brains questions, and publish/unpublish your BRAIN.md.
+`gobi brain` commands manage your vault's brain: search across all spaces, ask brains questions, and publish/unpublish your BRAIN.md. Public brains are accessible at `https://gobispace.com/@{vaultSlug}`.
 
 ## Gobi Session — Conversations
 
-`gobi session` commands manage your conversations: list, read, reply to, and update sessions.
+`gobi session` commands manage your conversations: list, read, and reply to sessions.
 
 ## Important: JSON Mode
 
@@ -154,6 +154,8 @@ gobi auth --help
 gobi space --help
 gobi brain --help
 gobi session --help
+gobi sense --help
+gobi sync --help
 ```
 
 ## Configuration Files
@@ -168,5 +170,5 @@ gobi session --help
 
 | Variable | Default | Description |
 |----------|---------|-------------|
-| `GOBI_BASE_URL` | `https://backend.joingobi.com` | API server URL |
+| `GOBI_BASE_URL` | `https://api.joingobi.com` | API server URL |
 | `GOBI_WEBDRIVE_BASE_URL` | `https://webdrive.joingobi.com` | File storage URL |

package/skills/gobi/references/sync.md

@@ -6,12 +6,15 @@ Usage: gobi sync [options]
 Sync local vault files with Gobi Webdrive.
 
 Options:
-  --upload-only          Only upload local changes to server
-  --download-only        Only download server changes to local
-  --conflict <strategy>  Conflict resolution strategy: ask|server|client|skip (default: "ask")
-  --dir <path>           Local vault directory (default: current directory)
-  --dry-run              Preview changes without making them
-  --full                 Full sync: ignore cursor and hash cache, re-check every file
-  --path <path>          Restrict sync to a specific file or folder (repeatable) (default: [])
-  -h, --help             display help for command
+  --upload-only              Only upload local changes to server
+  --download-only            Only download server changes to local
+  --conflict <strategy>      Conflict resolution strategy: ask|server|client|skip (default: "ask")
+  --dir <path>               Local vault directory (default: current directory)
+  --dry-run                  Preview changes without making them
+  --full                     Full sync: ignore cursor and hash cache, re-check every file
+  --path <path>              Restrict sync to a specific file or folder (repeatable) (default: [])
+  --plan-file <path>         Write dry-run plan to file (use with --dry-run) or read plan to execute (use with --execute)
+  --execute                  Execute a previously written plan file (requires --plan-file)
+  --conflict-choices <json>  Per-file conflict resolutions as JSON object, e.g. '{"file.md":"server"}' (use with --execute)
+  -h, --help                 display help for command
 ```