memax-cli 0.1.0-alpha.4 → 0.1.0-alpha.41

package/dist/commands/sync.js

@@ -1,8 +1,14 @@
 import chalk from "chalk";
-import { readFileSync, readdirSync, statSync, watch, existsSync, } from "node:fs";
-import { join, relative, extname, resolve, basename } from "node:path";
+import { createHash } from "node:crypto";
+import { readFileSync, writeFileSync, mkdirSync, readdirSync, statSync, watch, existsSync, } from "node:fs";
+import { join, relative, extname, resolve, dirname } from "node:path";
 import { homedir } from "node:os";
-import { apiPost } from "../lib/api.js";
+import { getClient } from "../lib/client.js";
+import { getProjectScope, resolveProjectScope, resolveClaudeProjectFolder, normalizeFilePath, readMemaxYmlConfig, detectProjectContext, isCanonicalProjectScope, } from "../lib/project-context.js";
+import { getOrCreateDeviceID, listSyncSources, updateSyncSourceRun, } from "../lib/config.js";
+import { confirm, ask, confirmDefault } from "../lib/prompt.js";
+import { moveFileToTrash } from "../lib/trash.js";
+import { syncAgentSessionsCommand } from "./agent-sessions.js";
 const DEFAULT_IGNORE = new Set([
     "node_modules",
     ".git",
@@ -37,47 +43,568 @@ const SUPPORTED_EXTENSIONS = new Set([
     ".proto",
     ".dockerfile",
 ]);
-export async function syncAgentMemoryCommand() {
-    await syncAgentMemory();
+export async function syncAgentMemoryCommand(options = {}) {
+    await syncAgentMemory(options);
 }
-export async function syncCommand(directory, options) {
-    if (options.agentMemory || directory === "agents") {
-        await syncAgentMemory();
+export async function listAgentConfigsCommand() {
+    let configs;
+    try {
+        const result = await getClient().configs.list();
+        configs = result.configs;
+    }
+    catch (err) {
+        console.error(chalk.red(`  Failed to fetch configs: ${err.message}\n`));
+        return;
+    }
+    if (!configs || configs.length === 0) {
+        console.log(chalk.yellow("  No synced configs. Run: memax agents configs sync\n"));
+        return;
+    }
+    // Group by agent
+    const byAgent = new Map();
+    for (const c of configs) {
+        const list = byAgent.get(c.agent) ?? [];
+        list.push({
+            id: c.id,
+            filePath: c.file_path,
+            scope: c.scope,
+            updatedAt: c.updated_at,
+        });
+        byAgent.set(c.agent, list);
+    }
+    console.log();
+    for (const [agent, files] of byAgent) {
+        console.log(`  ${chalk.cyan(agent)}`);
+        for (const f of files) {
+            const scopeTag = f.scope === "global"
+                ? chalk.dim("global")
+                : chalk.dim(f.scope.replace("project:", ""));
+            const age = formatAge(f.updatedAt);
+            console.log(`    ${f.filePath}  ${scopeTag}  ${chalk.dim(age)}  ${chalk.dim(f.id.slice(0, 8))}`);
+        }
+        console.log();
+    }
+    console.log(chalk.gray(`  ${configs.length} config${configs.length > 1 ? "s" : ""} synced to cloud.\n`));
+}
+export async function listDeletedAgentConfigsCommand() {
+    let deleted;
+    try {
+        deleted = await getClient().configs.listDeleted();
+    }
+    catch (err) {
+        console.error(chalk.red(`  Failed to fetch deleted configs: ${err.message}\n`));
+        return;
+    }
+    if (!deleted.configs || deleted.configs.length === 0) {
+        console.log(chalk.gray("  No recoverable deleted configs.\n"));
+        return;
+    }
+    console.log(chalk.bold("\n  Recoverable Deleted Configs\n"));
+    deleted.configs.forEach((item, index) => {
+        const scopeLabel = item.scope === "global"
+            ? chalk.dim("global")
+            : chalk.dim(item.scope.replace("project:", ""));
+        console.log(`  ${chalk.bold(String(index + 1).padStart(2, " "))}. ${chalk.cyan(item.agent)} ${item.file_path} ${scopeLabel}`);
+        console.log(chalk.gray(`      deleted ${formatAge(item.deleted_at)} · recoverable until ${item.content_expires_at ? new Date(item.content_expires_at).toLocaleString() : "expired"}`));
+    });
+    console.log();
+}
+export async function restoreDeletedAgentConfigsCommand() {
+    let deleted;
+    try {
+        deleted = await getClient().configs.listDeleted();
+    }
+    catch (err) {
+        console.error(chalk.red(`  Failed to fetch deleted configs: ${err.message}\n`));
+        return;
+    }
+    if (!deleted.configs || deleted.configs.length === 0) {
+        console.log(chalk.gray("  No recoverable deleted configs.\n"));
+        return;
+    }
+    console.log(chalk.bold("\n  Recover Deleted Configs\n"));
+    deleted.configs.forEach((item, index) => {
+        const scopeLabel = item.scope === "global" ? "global" : item.scope.replace("project:", "");
+        console.log(`    ${index + 1}. ${item.agent}/${item.file_path} ${chalk.gray(scopeLabel)}`);
+    });
+    const raw = await ask(chalk.gray("\n  Enter indexes to restore (comma-separated): "));
+    const indexes = raw
+        .split(",")
+        .map((value) => Number.parseInt(value.trim(), 10))
+        .filter((value) => Number.isInteger(value) && value > 0 && value <= deleted.configs.length);
+    if (indexes.length === 0) {
+        console.log(chalk.gray("  Cancelled.\n"));
+        return;
+    }
+    const cwd = process.cwd();
+    const deviceID = getOrCreateDeviceID();
+    const currentProjectScope = getProjectScope(cwd);
+    let restored = 0;
+    for (const index of indexes) {
+        const item = deleted.configs[index - 1];
+        try {
+            const writePath = resolveAgentConfigWritePath(item.agent, item.file_path, item.scope, {
+                cwd,
+                home: homedir(),
+                currentProjectScope,
+                findClaudeProjectDir,
+            });
+            const config = await getClient().configs.restore({
+                agent: item.agent,
+                file_path: item.file_path,
+                scope: item.scope,
+                device_id: deviceID,
+                local_path: writePath ?? undefined,
+            });
+            if (writePath && !existsSync(writePath)) {
+                mkdirSync(dirname(writePath), { recursive: true });
+                writeFileSync(writePath, config.content);
+                await getClient().configs.ack({
+                    device_id: deviceID,
+                    configs: [
+                        {
+                            agent: item.agent,
+                            file_path: item.file_path,
+                            scope: item.scope,
+                            content_hash: config.content_hash,
+                            version: config.version,
+                            local_path: writePath,
+                        },
+                    ],
+                });
+                console.log(chalk.green(`    ✓ ${item.file_path}`), chalk.gray("restored to cloud and local machine"));
+            }
+            else if (writePath && existsSync(writePath)) {
+                console.log(chalk.yellow(`    - ${item.file_path}`), chalk.gray("restored to cloud; local file already exists"));
+            }
+            else {
+                console.log(chalk.yellow(`    - ${item.file_path}`), chalk.gray("restored to cloud; no safe local path on this machine"));
+            }
+            restored++;
+        }
+        catch (err) {
+            console.log(chalk.red(`    ✗ ${item.file_path}`), chalk.gray(err.message));
+        }
+    }
+    console.log(chalk.gray(`\n  ${restored} config${restored === 1 ? "" : "s"} restored.\n`));
+}
+export function classifyAgentConfigPlacement(agent, filePath, scope, options = {}) {
+    const key = `${agent}|${normalizeFilePath(filePath)}|${scope}`;
+    const existing = options.localByKey?.get(key);
+    if (existing) {
+        return {
+            kind: "present",
+            path: existing.path,
+            reason: "present locally",
+        };
+    }
+    const cwd = options.cwd ?? process.cwd();
+    const currentProjectScope = options.currentProjectScope ?? getProjectScope(cwd);
+    if (scope.startsWith("project:") && scope !== currentProjectScope) {
+        return {
+            kind: "different_project",
+            reason: `belongs to ${scope.replace(/^project:/, "")}`,
+        };
+    }
+    const path = resolveAgentConfigWritePath(agent, filePath, scope, options);
+    if (path) {
+        return {
+            kind: "restorable",
+            path,
+            reason: "safe restore path available",
+        };
+    }
+    return {
+        kind: "unresolved",
+        reason: "no safe restore path on this machine",
+    };
+}
+export async function doctorAgentConfigsCommand() {
+    const cwd = process.cwd();
+    const home = homedir();
+    const deviceID = getOrCreateDeviceID();
+    const project = resolveProjectScope(cwd);
+    const memaxYml = readMemaxYmlConfig(cwd);
+    const locations = discoverAgentConfigs();
+    const localConfigs = locations.filter((loc) => {
+        if (!existsSync(loc.path))
+            return false;
+        try {
+            const stat = statSync(loc.path);
+            return stat.isFile() && stat.size > 0;
+        }
+        catch {
+            return false;
+        }
+    });
+    const localByKey = new Map();
+    for (const loc of localConfigs) {
+        localByKey.set(`${loc.agent}|${loc.filePath}|${loc.scope}`, loc);
+    }
+    let cloudConfigs = null;
+    try {
+        cloudConfigs = await getClient().configs.list();
+    }
+    catch (err) {
+        console.error(chalk.red(`  Failed to fetch cloud configs: ${err.message}\n`));
+    }
+    const scopeSource = project.source === "memax_yml"
+        ? ".memax.yml project_id"
+        : project.source === "git_remote"
+            ? "git origin"
+            : "no canonical project identity";
+    console.log(chalk.bold("\n  Memax Agent Config Doctor\n"));
+    console.log(chalk.white("  Device"));
+    console.log(`    ID         ${chalk.bold(deviceID)}`);
+    console.log(`    Home       ${chalk.gray(home)}`);
+    console.log();
+    console.log(chalk.white("  Project"));
+    console.log(`    CWD        ${chalk.gray(cwd)}`);
+    console.log(`    Scope      ${chalk.bold(project.scope)}`);
+    console.log(`    Source     ${chalk.gray(scopeSource)}`);
+    if (memaxYml?.hub) {
+        console.log(`    Hub        ${chalk.gray(memaxYml.hub)}`);
+    }
+    if (memaxYml?.project_id) {
+        console.log(`    project_id ${chalk.gray(memaxYml.project_id)}`);
+    }
+    if (project.warning) {
+        console.log(`    Warning    ${chalk.yellow(project.warning)}`);
+    }
+    if (project.scope === "project") {
+        console.log(`    Note       ${chalk.yellow("project-scoped cross-device restore is disabled until git origin or .memax.yml project_id is available")}`);
+    }
+    console.log();
+    const byAgent = new Map();
+    for (const loc of localConfigs) {
+        const group = byAgent.get(loc.agent) ?? [];
+        group.push(loc);
+        byAgent.set(loc.agent, group);
+    }
+    console.log(chalk.white("  Local Discovery"));
+    if (localConfigs.length === 0) {
+        console.log(`    ${chalk.gray("No local agent configs discovered.")}`);
+    }
+    else {
+        for (const [agent, group] of byAgent) {
+            console.log(`    ${chalk.cyan(formatAgentName(agent))}`);
+            for (const loc of group) {
+                const scopeLabel = loc.scope === "global"
+                    ? "global"
+                    : loc.scope.replace(/^project:/, "");
+                console.log(`      • ${loc.filePath}  ${chalk.gray(scopeLabel)}  ${chalk.gray(loc.path)}`);
+            }
+        }
+    }
+    console.log();
+    if (!cloudConfigs) {
+        console.log(chalk.gray("  Cloud inspection skipped because cloud config fetch failed.\n"));
+        return;
+    }
+    const placements = cloudConfigs.configs.map((config) => ({
+        config,
+        placement: classifyAgentConfigPlacement(config.agent, config.file_path, config.scope, {
+            cwd,
+            home,
+            currentProjectScope: project.scope,
+            localByKey,
+            findClaudeProjectDir,
+        }),
+    }));
+    const present = placements.filter((p) => p.placement.kind === "present");
+    const restorable = placements.filter((p) => p.placement.kind === "restorable");
+    const differentProject = placements.filter((p) => p.placement.kind === "different_project");
+    const unresolved = placements.filter((p) => p.placement.kind === "unresolved");
+    console.log(chalk.white("  Cloud Coverage"));
+    console.log(`    Present locally     ${chalk.bold(String(present.length))}`);
+    console.log(`    Restorable here     ${chalk.bold(String(restorable.length))}`);
+    console.log(`    Other project       ${chalk.bold(String(differentProject.length))}`);
+    console.log(`    Unresolved here     ${chalk.bold(String(unresolved.length))}`);
+    console.log();
+    printPlacementSection("  Restorable Here", chalk.cyan, restorable, (item) => [
+        item.config.agent,
+        item.config.file_path,
+        item.placement.path ?? "",
+    ]);
+    printPlacementSection("  Different Project", chalk.yellow, differentProject, (item) => [item.config.agent, item.config.file_path, item.placement.reason]);
+    printPlacementSection("  Unresolved", chalk.magenta, unresolved, (item) => [
+        item.config.agent,
+        item.config.file_path,
+        item.placement.reason,
+    ]);
+    console.log(chalk.gray("  Use this command to verify what sync can restore safely on this machine.\n"));
+}
+export async function syncAgentsCommand(options) {
+    await syncAgentMemoryCommand(options);
+    await syncAgentSessionsCommand(options);
+}
+export function registerSyncCommands(program) {
+    const syncCmd = program
+        .command("sync [directory]")
+        .description("Sync a directory or agent configs to your Memax workspace")
+        .option("-w, --watch", "Watch for changes (coming soon)")
+        .option("-b, --boundary <level>", "Visibility level: private, team, org", "private")
+        .option("-c, --category <category>", "Default category (auto-detected if omitted)")
+        .option("--ignore <patterns>", "Comma-separated directories to ignore")
+        .option("-y, --yes", "Skip confirmation for large syncs")
+        .action(syncCommand);
+    syncCmd
+        .command("status")
+        .description("Show registered memory sync sources and last run status")
+        .action(syncStatusCommand);
+    syncCmd
+        .command("agents")
+        .description("Sync agent configs and sessions (alias for: memax agents sync)")
+        .option("--push", "Force push local configs to cloud (overwrite)")
+        .option("--pull", "Force pull cloud configs to local (overwrite)")
+        .action(syncAgentsCommand);
+}
+export function registerAgentConfigCommands(agentsCmd) {
+    const agentConfigsCmd = agentsCmd
+        .command("configs")
+        .description("Manage synced agent config files");
+    agentConfigsCmd
+        .command("sync")
+        .description("Sync agent config files bidirectionally with Memax cloud")
+        .option("--push", "Force push local configs to cloud (overwrite)")
+        .option("--pull", "Force pull cloud configs to local (overwrite)")
+        .action(syncAgentMemoryCommand);
+    agentConfigsCmd
+        .command("list")
+        .description("List all synced agent configs in the cloud")
+        .action(listAgentConfigsCommand);
+    agentConfigsCmd
+        .command("deleted")
+        .description("List recoverable deleted configs retained in cloud")
+        .action(listDeletedAgentConfigsCommand);
+    agentConfigsCmd
+        .command("restore")
+        .description("Restore deleted configs retained in cloud")
+        .action(restoreDeletedAgentConfigsCommand);
+    agentConfigsCmd
+        .command("delete")
+        .description("Interactively select and delete synced configs")
+        .action(deleteAgentConfigsCommand);
+    agentConfigsCmd
+        .command("doctor")
+        .description("Explain config sync identity, discovery, and safe restore behavior on this machine")
+        .action(doctorAgentConfigsCommand);
+}
+export async function deleteAgentConfigsCommand() {
+    let configs;
+    try {
+        const result = await getClient().configs.list();
+        configs = result.configs;
+    }
+    catch (err) {
+        console.error(chalk.red(`  Failed to fetch configs: ${err.message}\n`));
+        return;
+    }
+    if (!configs || configs.length === 0) {
+        console.log(chalk.yellow("  No synced configs to delete.\n"));
+        return;
+    }
+    // Display numbered list grouped by agent
+    const items = [];
+    let currentAgent = "";
+    for (const c of configs) {
+        if (c.agent !== currentAgent) {
+            if (currentAgent)
+                console.log();
+            console.log(`  ${chalk.cyan(c.agent)}`);
+            currentAgent = c.agent;
+        }
+        items.push({
+            id: c.id,
+            agent: c.agent,
+            filePath: c.file_path,
+            scope: c.scope,
+            version: c.version,
+        });
+        const idx = chalk.dim(`${items.length}.`);
+        const scopeTag = c.scope === "global"
+            ? chalk.dim("global")
+            : chalk.dim(c.scope.replace("project:", ""));
+        console.log(`    ${idx} ${c.file_path}  ${scopeTag}`);
+    }
+    console.log();
+    const answer = await ask("  Select configs to delete (comma-separated numbers, or 'q' to quit): ");
+    if (!answer || answer.trim().toLowerCase() === "q") {
+        console.log(chalk.gray("  Cancelled.\n"));
+        return;
+    }
+    const indices = answer
+        .split(",")
+        .map((s) => parseInt(s.trim(), 10))
+        .filter((n) => !isNaN(n) && n >= 1 && n <= items.length);
+    if (indices.length === 0) {
+        console.log(chalk.gray("  No valid selections.\n"));
+        return;
+    }
+    const modeAnswer = await ask("  Delete from [l] this device only, [e] everywhere, or [s] skip? ");
+    const mode = modeAnswer.trim().toLowerCase();
+    if (mode !== "l" && mode !== "e") {
+        console.log(chalk.gray("  Cancelled.\n"));
         return;
     }
+    console.log();
+    for (const i of indices) {
+        const item = items[i - 1];
+        console.log(chalk.yellow(`    ${item.agent}/${item.filePath}`));
+    }
+    const ok = await confirm(mode === "e"
+        ? `\n  Delete ${indices.length} config${indices.length > 1 ? "s" : ""} everywhere? (y/N) `
+        : `\n  Remove ${indices.length} config${indices.length > 1 ? "s" : ""} from this device only? (y/N) `);
+    if (!ok) {
+        console.log(chalk.gray("  Cancelled.\n"));
+        return;
+    }
+    const deviceID = getOrCreateDeviceID();
+    const cwd = process.cwd();
+    const currentProjectScope = getProjectScope(cwd);
+    const locations = discoverAgentConfigs();
+    const locByKey = new Map();
+    for (const loc of locations) {
+        locByKey.set(`${loc.agent}|${loc.filePath}|${loc.scope}`, loc);
+    }
+    const resolveDeletePath = (agent, filePath, scope) => {
+        const loc = locByKey.get(`${agent}|${filePath}|${scope}`);
+        if (loc)
+            return loc.path;
+        return resolveAgentConfigWritePath(agent, filePath, scope, {
+            cwd,
+            home: homedir(),
+            currentProjectScope,
+        });
+    };
+    let deleted = 0;
+    for (const i of indices) {
+        const item = items[i - 1];
+        try {
+            const localPath = resolveDeletePath(item.agent, item.filePath, item.scope);
+            if (mode === "l") {
+                await getClient().configs.localDelete({
+                    device_id: deviceID,
+                    agent: item.agent,
+                    file_path: item.filePath,
+                    scope: item.scope,
+                    local_path: localPath ?? undefined,
+                });
+                if (localPath && existsSync(localPath)) {
+                    moveFileToTrash(localPath, "agent-configs");
+                }
+                console.log(chalk.green(`    \u2713 ${item.agent}/${item.filePath}`), chalk.gray("removed from this device (moved to Memax trash)"));
+            }
+            else {
+                await getClient().configs.delete(item.id);
+                if (localPath && existsSync(localPath)) {
+                    moveFileToTrash(localPath, "agent-configs");
+                }
+                await getClient().configs.ack({
+                    device_id: deviceID,
+                    configs: [
+                        {
+                            agent: item.agent,
+                            file_path: item.filePath,
+                            scope: item.scope,
+                            version: item.version + 1,
+                            local_path: localPath ?? undefined,
+                            deleted: true,
+                        },
+                    ],
+                });
+                console.log(chalk.green(`    \u2713 ${item.agent}/${item.filePath}`), chalk.gray("deleted everywhere (local copy moved to Memax trash)"));
+            }
+            deleted++;
+        }
+        catch (err) {
+            console.log(chalk.red(`    \u2717 ${item.agent}/${item.filePath}`), chalk.gray(err.message));
+        }
+    }
+    console.log(chalk.gray(mode === "e"
+        ? `\n  ${deleted} config${deleted > 1 ? "s" : ""} deleted everywhere.\n`
+        : `\n  ${deleted} config${deleted > 1 ? "s" : ""} removed from this device.\n`));
+}
+function formatAge(dateStr) {
+    const ms = Date.now() - new Date(dateStr).getTime();
+    const mins = Math.floor(ms / 60000);
+    if (mins < 60)
+        return `${mins}m ago`;
+    const hours = Math.floor(mins / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}
+export async function syncCommand(directory, options) {
     const dir = directory ?? ".";
+    const syncRoot = resolve(dir);
     const customIgnore = options.ignore
         ? new Set(options.ignore.split(",").map((s) => s.trim()))
         : new Set();
     const ignoreSet = new Set([...DEFAULT_IGNORE, ...customIgnore]);
+    const ignorePatterns = [...customIgnore].sort();
+    const projectContext = detectProjectContext(syncRoot);
     console.log(chalk.blue("Scanning"), dir);
-    const files = walkDir(dir, ignoreSet);
+    const files = walkDir(syncRoot, ignoreSet);
     if (files.length === 0) {
         console.log(chalk.yellow("No supported files found."));
+        updateSyncSourceRun(syncRoot, {
+            ignorePatterns,
+            defaultCategory: options.category,
+            defaultBoundary: options.boundary,
+            mode: options.watch ? "watch" : "manual",
+            scanCount: 0,
+            pushed: 0,
+            skipped: 0,
+            errors: 0,
+        });
         return;
     }
     console.log(chalk.gray(`Found ${files.length} files to sync`));
+    // Confirm if many files (>10) unless -y is passed
+    if (files.length > 10 && !options.yes) {
+        console.log(chalk.yellow(`\n  This will push ${files.length} files. Continue? (y/N) `));
+        const confirmed = await confirm("  ");
+        if (!confirmed) {
+            console.log(chalk.gray("  Cancelled.\n"));
+            return;
+        }
+    }
     console.log();
     let pushed = 0;
+    let skipped = 0;
     let errors = 0;
     for (const file of files) {
-        const result = await pushFile(file, options);
+        const result = await pushFile(file, syncRoot, projectContext, options);
         if (result === "pushed")
             pushed++;
+        else if (result === "skipped")
+            skipped++;
         else if (result === "error")
             errors++;
     }
+    updateSyncSourceRun(syncRoot, {
+        ignorePatterns,
+        defaultCategory: options.category,
+        defaultBoundary: options.boundary,
+        mode: options.watch ? "watch" : "manual",
+        scanCount: files.length,
+        pushed,
+        skipped,
+        errors,
+    });
     console.log();
-    console.log(chalk.blue(`Synced ${pushed} files`), errors > 0 ? chalk.red(`(${errors} errors)`) : "");
+    console.log(chalk.blue(`Synced ${pushed} files`), skipped > 0 ? chalk.gray(`(${skipped} skipped)`) : "", errors > 0 ? chalk.red(`(${errors} errors)`) : "");
+    console.log(chalk.gray("  Missing local files are retained in Memax until removed explicitly."));
     if (options.watch) {
-        const resolvedDir = resolve(dir);
         console.log(chalk.cyan(`\nWatching ${dir} for changes... (Ctrl+C to stop)`));
         let debounceTimer = null;
         const pendingChanges = new Set();
-        watch(resolvedDir, { recursive: true }, (_eventType, filename) => {
+        watch(syncRoot, { recursive: true }, (_eventType, filename) => {
             if (!filename)
                 return;
-            const fullPath = join(resolvedDir, filename);
+            const fullPath = join(syncRoot, filename);
             if (!isSupportedFile(filename) || isIgnored(filename, ignoreSet))
                 return;
             pendingChanges.add(fullPath);
@@ -86,37 +613,37 @@ export async function syncCommand(directory, options) {
             debounceTimer = setTimeout(async () => {
                 for (const file of pendingChanges) {
                     if (!existsSync(file)) {
-                        console.log(chalk.gray("  ~"), relative(process.cwd(), file), chalk.gray("[deleted, skipped]"));
+                        console.log(chalk.gray("  ~"), buildSyncSourcePath(syncRoot, file), chalk.gray("[deleted locally, retained in Memax]"));
                         continue;
                     }
-                    await pushFile(file, options);
+                    await pushFile(file, syncRoot, projectContext, options);
                 }
                 pendingChanges.clear();
             }, 500);
         });
     }
 }
-async function pushFile(file, options) {
+async function pushFile(file, syncRoot, projectContext, options) {
     try {
         const content = readFileSync(file, "utf-8");
         if (!content.trim())
             return "skipped";
-        const relPath = relative(process.cwd(), file);
+        const relPath = buildSyncSourcePath(syncRoot, file);
         const ext = extname(file);
         const contentType = ext === ".md"
             ? "markdown"
             : ext === ".json" || ext === ".yaml" || ext === ".yml"
                 ? "structured"
                 : "code";
-        const note = await apiPost("/v1/notes", {
-            content,
+        const memory = await getClient().push(content, {
             title: relPath,
             category: options.category ?? guessCategory(relPath),
             source: "sync",
-            source_path: relPath,
-            content_type: contentType,
+            sourcePath: relPath,
+            contentType,
+            projectContext,
         });
-        console.log(chalk.green("  +"), relPath, chalk.gray(`[${note.category}]`));
+        console.log(chalk.green("  +"), relPath, chalk.gray(`[${memory.category}]`));
         return "pushed";
     }
     catch (err) {
@@ -124,6 +651,46 @@ async function pushFile(file, options) {
         return "error";
     }
 }
+export function buildSyncSourcePath(syncRoot, file) {
+    const relativePath = relative(syncRoot, file);
+    if (!relativePath ||
+        relativePath.startsWith("..") ||
+        relativePath === "." ||
+        resolve(syncRoot, relativePath) !== resolve(file)) {
+        throw new Error("file is outside sync root");
+    }
+    return normalizeFilePath(relativePath);
+}
+export function syncStatusCommand() {
+    const sources = listSyncSources();
+    console.log(chalk.bold("\n  Memax Sync Status\n"));
+    if (sources.length === 0) {
+        console.log(chalk.gray("  No sync sources recorded yet."));
+        console.log(chalk.gray("  Run: memax sync <dir>\n"));
+        return;
+    }
+    for (const source of sources) {
+        console.log(`  ${chalk.cyan(source.root_path)}`);
+        console.log(`    kind             ${chalk.gray(source.kind)}`);
+        console.log(`    deletion policy  ${chalk.gray("retain missing files in Memax")}`);
+        if (source.default_category) {
+            console.log(`    category         ${chalk.gray(source.default_category)}`);
+        }
+        if (source.default_boundary) {
+            console.log(`    boundary         ${chalk.gray(source.default_boundary)}`);
+        }
+        if (source.ignore_patterns.length > 0) {
+            console.log(`    ignore           ${chalk.gray(source.ignore_patterns.join(", "))}`);
+        }
+        if (source.last_sync_at) {
+            console.log(`    last sync        ${chalk.gray(formatAge(source.last_sync_at))} (${chalk.gray(source.last_mode ?? "manual")})`);
+        }
+        if (source.last_scan_count !== undefined) {
+            console.log(`    last run         ${chalk.gray(`${source.last_scan_count} scanned, ${source.last_pushed ?? 0} pushed, ${source.last_skipped ?? 0} skipped, ${source.last_errors ?? 0} errors`)}`);
+        }
+        console.log();
+    }
+}
 function isSupportedFile(filename) {
     return SUPPORTED_EXTENSIONS.has(extname(filename));
 }
@@ -179,143 +746,756 @@ function guessCategory(path) {
         return "reference/config";
     return "daily/note";
 }
-function discoverAgentMemoryFiles() {
+function findClaudeProjectDir(scope) {
+    const home = homedir();
+    const claudeProjectsDir = join(home, ".claude", "projects");
+    if (!existsSync(claudeProjectsDir))
+        return null;
+    try {
+        for (const project of readdirSync(claudeProjectsDir)) {
+            const repoUrl = resolveClaudeProjectFolder(project);
+            if (repoUrl && scope === `project:${repoUrl}`) {
+                return join(claudeProjectsDir, project);
+            }
+        }
+    }
+    catch {
+        // Permission denied — skip
+    }
+    return null;
+}
+function printPlacementSection(title, color, items, format) {
+    if (items.length === 0)
+        return;
+    console.log(chalk.white(title));
+    for (const item of items) {
+        const [agent, filePath, detail] = format(item);
+        console.log(`    ${color(formatAgentName(agent))}  ${filePath}`);
+        console.log(`      ${chalk.gray(detail)}`);
+    }
+    console.log();
+}
+export function resolveAgentConfigWritePath(agent, filePath, scope, options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const home = options.home ?? homedir();
+    const currentProjectScope = options.currentProjectScope ?? getProjectScope(cwd);
+    const normalizedFilePath = normalizeFilePath(filePath);
+    if (scope === "global") {
+        switch (agent) {
+            case "claude-code":
+                return join(home, ".claude", normalizedFilePath);
+            case "codex":
+                return join(home, ".codex", normalizedFilePath);
+            case "gemini":
+                return join(home, ".gemini", normalizedFilePath);
+            case "openclaw":
+                return join(home, ".openclaw", normalizedFilePath);
+            case "opencode":
+                return join(home, ".opencode", normalizedFilePath);
+            default:
+                return null;
+        }
+    }
+    if (!scope.startsWith("project:") || scope !== currentProjectScope) {
+        return null;
+    }
+    switch (agent) {
+        case "claude-code":
+            if (normalizedFilePath === "CLAUDE.md" ||
+                normalizedFilePath === "MEMORY.md") {
+                return join(cwd, ".claude", normalizedFilePath);
+            }
+            if (normalizedFilePath.startsWith(".claude/")) {
+                return join(cwd, normalizedFilePath);
+            }
+            if (normalizedFilePath.startsWith("memory/")) {
+                const projectDir = options.findClaudeProjectDir?.(scope);
+                if (projectDir) {
+                    return join(projectDir, normalizedFilePath);
+                }
+                const mangledCwd = cwd.replace(/\//g, "-");
+                return join(home, ".claude", "projects", mangledCwd, normalizedFilePath);
+            }
+            return null;
+        case "cursor":
+            if (normalizedFilePath === ".cursorrules" ||
+                normalizedFilePath.startsWith(".cursor/")) {
+                return join(cwd, normalizedFilePath);
+            }
+            return null;
+        case "codex":
+            if (normalizedFilePath === "instructions.md") {
+                return join(cwd, ".codex", "instructions.md");
+            }
+            if (normalizedFilePath.startsWith(".codex/")) {
+                return join(cwd, normalizedFilePath);
+            }
+            return null;
+        case "gemini":
+            if (normalizedFilePath === "GEMINI.md") {
+                return join(cwd, "GEMINI.md");
+            }
+            return null;
+        case "copilot":
+            if (normalizedFilePath === "copilot-instructions.md") {
+                return join(cwd, ".github", "copilot-instructions.md");
+            }
+            if (normalizedFilePath.startsWith(".github/")) {
+                return join(cwd, normalizedFilePath);
+            }
+            return null;
+        case "windsurf":
+            if (normalizedFilePath === ".windsurfrules" ||
+                normalizedFilePath.startsWith(".windsurf/")) {
+                return join(cwd, normalizedFilePath);
+            }
+            return null;
+        case "opencode":
+            if (normalizedFilePath.startsWith(".opencode/")) {
+                return join(cwd, normalizedFilePath);
+            }
+            return join(cwd, ".opencode", normalizedFilePath);
+        case "generic":
+            if (normalizedFilePath === "AGENTS.md" ||
+                normalizedFilePath === "CLAUDE.md" ||
+                normalizedFilePath === "GEMINI.md") {
+                return join(cwd, normalizedFilePath);
+            }
+            return null;
+        default:
+            return null;
+    }
+}
+function discoverAgentConfigs() {
     const home = homedir();
     const cwd = process.cwd();
+    const projectScope = getProjectScope(cwd);
+    const canonicalProjectScope = isCanonicalProjectScope(projectScope)
+        ? projectScope
+        : null;
     const locations = [];
-    // Claude Code global memory
-    const claudeMemory = join(home, ".claude", "MEMORY.md");
-    locations.push({ label: "~/.claude/MEMORY.md", path: claudeMemory });
-    // Claude Code per-project memories: ~/.claude/projects/*/memory/*.md
+    const add = (agent, label, path, filePath, scope = "global") => locations.push({
+        agent,
+        label,
+        path,
+        filePath: normalizeFilePath(filePath),
+        scope,
+    });
+    // Claude Code — global
+    add("claude-code", "~/.claude/CLAUDE.md", join(home, ".claude", "CLAUDE.md"), "CLAUDE.md");
+    add("claude-code", "~/.claude/MEMORY.md", join(home, ".claude", "MEMORY.md"), "MEMORY.md");
+    // Claude Code — per-project memories: ~/.claude/projects/*/memory/*.md
+    // The folder name is the absolute project path with "/" replaced by "-"
+    // (e.g., "-workspaces-memax"). We resolve it to a git repo URL so the
+    // same project's memories match across machines regardless of clone path.
     const claudeProjectsDir = join(home, ".claude", "projects");
     if (existsSync(claudeProjectsDir)) {
         try {
             for (const project of readdirSync(claudeProjectsDir)) {
                 const memoryDir = join(claudeProjectsDir, project, "memory");
-                if (existsSync(memoryDir)) {
-                    try {
-                        for (const file of readdirSync(memoryDir)) {
-                            if (file.endsWith(".md")) {
-                                locations.push({
-                                    label: `~/.claude/projects/${project}/memory/${file}`,
-                                    path: join(memoryDir, file),
-                                });
-                            }
+                if (!existsSync(memoryDir))
+                    continue;
+                // Try to resolve mangled folder → git repo → canonical scope
+                const repoUrl = resolveClaudeProjectFolder(project);
+                const memoryScope = repoUrl
+                    ? `project:${repoUrl}`
+                    : undefined;
+                try {
+                    for (const file of readdirSync(memoryDir)) {
+                        if (!file.endsWith(".md"))
+                            continue;
+                        if (memoryScope) {
+                            // Canonical: filePath is just "memory/<file>", scope identifies the project
+                            add("claude-code", `~/.claude/projects/${project}/memory/${file}`, join(memoryDir, file), `memory/${file}`, memoryScope);
+                        }
+                        else {
+                            // Fallback: can't resolve project → keep legacy format with folder name
+                            add("claude-code", `~/.claude/projects/${project}/memory/${file}`, join(memoryDir, file), `projects/${project}/memory/${file}`);
                         }
                     }
-                    catch {
-                        // Permission denied or other read error — skip
-                    }
+                }
+                catch {
+                    // Permission denied — skip
                 }
             }
         }
         catch {
-            // Permission denied or other read error — skip
+            // Permission denied — skip
         }
     }
-    // Cursor rules (project-level)
-    locations.push({ label: "./.cursorrules", path: join(cwd, ".cursorrules") });
-    // Cursor scoped rules: .cursor/rules/*.mdc
-    const cursorRulesDir = join(cwd, ".cursor", "rules");
-    if (existsSync(cursorRulesDir)) {
+    // --- Project-scoped configs (only when inside a git repo) ---
+    if (canonicalProjectScope) {
+        // Claude Code — project-level
+        add("claude-code", "./.claude/CLAUDE.md", join(cwd, ".claude", "CLAUDE.md"), "CLAUDE.md", canonicalProjectScope);
+        // Cursor (project-level)
+        add("cursor", "./.cursorrules", join(cwd, ".cursorrules"), ".cursorrules", canonicalProjectScope);
+        const cursorRulesDir = join(cwd, ".cursor", "rules");
+        if (existsSync(cursorRulesDir)) {
+            try {
+                for (const file of readdirSync(cursorRulesDir)) {
+                    if (file.endsWith(".mdc")) {
+                        add("cursor", `./.cursor/rules/${file}`, join(cursorRulesDir, file), `.cursor/rules/${file}`, canonicalProjectScope);
+                    }
+                }
+            }
+            catch {
+                /* skip */
+            }
+        }
+        // Codex (project-level)
+        add("codex", "./.codex/instructions.md", join(cwd, ".codex", "instructions.md"), "instructions.md", canonicalProjectScope);
+    }
+    add("codex", "~/.codex/AGENTS.md", join(home, ".codex", "AGENTS.md"), "AGENTS.md");
+    // Gemini CLI — global
+    add("gemini", "~/.gemini/GEMINI.md", join(home, ".gemini", "GEMINI.md"), "GEMINI.md");
+    if (canonicalProjectScope) {
+        // Gemini CLI — project-level
+        add("gemini", "./GEMINI.md", join(cwd, "GEMINI.md"), "GEMINI.md", canonicalProjectScope);
+        // GitHub Copilot
+        add("copilot", "./.github/copilot-instructions.md", join(cwd, ".github", "copilot-instructions.md"), "copilot-instructions.md", canonicalProjectScope);
+        // Windsurf
+        add("windsurf", "./.windsurfrules", join(cwd, ".windsurfrules"), ".windsurfrules", canonicalProjectScope);
+        const windsurfRulesDir = join(cwd, ".windsurf", "rules");
+        if (existsSync(windsurfRulesDir)) {
+            try {
+                for (const file of readdirSync(windsurfRulesDir)) {
+                    if (file.endsWith(".md")) {
+                        add("windsurf", `./.windsurf/rules/${file}`, join(windsurfRulesDir, file), `.windsurf/rules/${file}`, canonicalProjectScope);
+                    }
+                }
+            }
+            catch {
+                /* skip */
+            }
+        }
+    }
+    // OpenClaw
+    const openclawMemoryDir = join(home, ".openclaw", "memory");
+    if (existsSync(openclawMemoryDir)) {
         try {
-            for (const file of readdirSync(cursorRulesDir)) {
-                if (file.endsWith(".mdc")) {
-                    locations.push({
-                        label: `./.cursor/rules/${file}`,
-                        path: join(cursorRulesDir, file),
-                    });
+            for (const file of readdirSync(openclawMemoryDir)) {
+                if (file.endsWith(".md") || file.endsWith(".json")) {
+                    add("openclaw", `~/.openclaw/memory/${file}`, join(openclawMemoryDir, file), `memory/${file}`);
                 }
             }
         }
         catch {
-            // Skip on error
+            /* skip */
         }
     }
-    // Codex instructions
-    locations.push({
-        label: "./.codex/instructions.md",
-        path: join(cwd, ".codex", "instructions.md"),
-    });
-    // Generic agent config files in current directory
-    locations.push({ label: "./AGENTS.md", path: join(cwd, "AGENTS.md") });
-    locations.push({ label: "./CLAUDE.md", path: join(cwd, "CLAUDE.md") });
-    return locations;
-}
-function formatFileSize(bytes) {
-    if (bytes < 1024)
-        return `${bytes} B`;
-    return `${(bytes / 1024).toFixed(1)} KB`;
-}
-async function syncAgentMemory() {
-    console.log(chalk.blue("Scanning for agent memory files..."));
-    console.log();
-    const locations = discoverAgentMemoryFiles();
-    const found = [];
-    const notFound = [];
-    for (const loc of locations) {
-        if (existsSync(loc.path)) {
+    if (canonicalProjectScope) {
+        // OpenCode (project-level)
+        const opencodePath = join(cwd, ".opencode");
+        if (existsSync(opencodePath)) {
             try {
-                const stat = statSync(loc.path);
-                if (stat.isFile() && stat.size > 0) {
-                    found.push({ label: loc.label, path: loc.path, size: stat.size });
-                }
-                else {
-                    notFound.push(loc.label);
+                for (const file of readdirSync(opencodePath)) {
+                    if (file.endsWith(".md")) {
+                        add("opencode", `./.opencode/${file}`, join(opencodePath, file), file, canonicalProjectScope);
+                    }
                 }
             }
             catch {
-                notFound.push(loc.label);
+                /* skip */
             }
         }
-        else {
-            notFound.push(loc.label);
+        // Generic project-level agent files
+        add("generic", "./AGENTS.md", join(cwd, "AGENTS.md"), "AGENTS.md", canonicalProjectScope);
+        add("generic", "./CLAUDE.md", join(cwd, "CLAUDE.md"), "CLAUDE.md", canonicalProjectScope);
+    }
+    return locations;
+}
+async function syncAgentMemory(options = {}) {
+    console.log(chalk.bold("\n  Memax Config Sync\n"));
+    const projectScopeResolution = resolveProjectScope();
+    if (projectScopeResolution.warning) {
+        console.log(chalk.yellow(`  Warning: ${projectScopeResolution.warning}`));
+        console.log(chalk.gray("  Using .memax.yml project_id as the canonical project identity.\n"));
+    }
+    // Discover local config files
+    const locations = discoverAgentConfigs();
+    const localConfigs = [];
+    for (const loc of locations) {
+        if (!existsSync(loc.path))
+            continue;
+        try {
+            const stat = statSync(loc.path);
+            if (!stat.isFile() || stat.size === 0)
+                continue;
+            const content = readFileSync(loc.path, "utf-8");
+            if (!content.trim())
+                continue;
+            const hash = createHash("sha256").update(content).digest("hex");
+            localConfigs.push({
+                loc,
+                content,
+                hash,
+                updatedAt: stat.mtime.toISOString(),
+            });
         }
+        catch {
+            // Skip unreadable files
+        }
+    }
+    const isBootstrap = localConfigs.length === 0;
+    const deviceID = getOrCreateDeviceID();
+    if (isBootstrap) {
+        console.log(chalk.gray("  No local agent configs found. Checking cloud for backups...\n"));
+    }
+    else {
+        console.log(chalk.gray(`  Found ${localConfigs.length} local config${localConfigs.length > 1 ? "s" : ""}. Syncing with cloud...\n`));
     }
-    if (found.length === 0) {
-        console.log(chalk.yellow("No agent memory files found."));
+    // Build manifest — may be empty on a new device (that's fine, we'll pull from cloud)
+    const manifest = localConfigs.map((c) => ({
+        agent: c.loc.agent,
+        file_path: c.loc.filePath,
+        scope: c.loc.scope,
+        content_hash: c.hash,
+        updated_at: c.updatedAt,
+        local_path: c.loc.path,
+    }));
+    let actions;
+    try {
+        const plan = await getClient().configs.sync({
+            device_id: deviceID,
+            configs: manifest,
+        });
+        actions = plan.actions;
+    }
+    catch (err) {
+        console.error(chalk.red(`  Sync failed: ${err.message}\n`));
         return;
     }
-    console.log("Found:");
-    for (const f of found) {
-        console.log(chalk.green("  \u2713"), f.label, chalk.gray(`(${formatFileSize(f.size)})`));
+    // Force modes: resolve ALL ambiguous actions in one direction.
+    // This includes both "conflict" AND "delete_local" (tombstone-driven
+    // deletions where the server decided local should be removed).
+    // One-sided actions (local_only push, cloud_only pull) stay as-is.
+    if (options.push) {
+        actions = actions.map((a) => {
+            if (a.action === "conflict")
+                return { ...a, action: "push" };
+            if (a.action === "delete_local")
+                return { ...a, action: "push" };
+            return a;
+        });
+    }
+    else if (options.pull) {
+        actions = actions.map((a) => {
+            if (a.action !== "conflict")
+                return a;
+            if (a.config_id)
+                return { ...a, action: "pull" };
+            return { ...a, action: "delete_local" };
+        });
     }
-    for (const label of notFound) {
-        console.log(chalk.gray("  \u2717"), chalk.gray(label), chalk.gray("(not found)"));
+    // Skip conflicts mode (used by setup): only process one-sided actions
+    // (local_only push, cloud_only pull), skip all ambiguous/destructive actions.
+    if (options.skipConflicts) {
+        const skippedCount = actions.filter((a) => a.action === "conflict" || a.action === "delete_local").length;
+        actions = actions.filter((a) => a.action !== "conflict" && a.action !== "delete_local");
+        if (skippedCount > 0) {
+            console.log(chalk.gray(`  ${skippedCount} conflict${skippedCount > 1 ? "s" : ""} skipped (resolve with: memax sync agents)\n`));
+        }
     }
-    console.log();
-    let synced = 0;
-    let unchanged = 0;
+    // Filter out project-scoped cloud-only configs that don't belong to the
+    // current project. Without this, running `memax sync agents` from ~/
+    // would dump project configs (like .cursorrules from repo X) into the
+    // home directory.
+    const currentProjectScope = projectScopeResolution.scope;
+    actions = actions.filter((a) => {
+        if (!a.scope.startsWith("project:"))
+            return true; // global → always sync
+        // Project-scoped: only sync if it matches the current project
+        if (a.scope === currentProjectScope)
+            return true;
+        // Cloud-only configs for other projects → skip silently
+        if (a.action === "pull" && a.reason === "cloud_only")
+            return false;
+        // Conflict/push for configs we have locally → keep (user is in the project)
+        return true;
+    });
+    // Index local configs by (agent, file_path, scope) for quick lookup
+    const localByKey = new Map();
+    for (const c of localConfigs) {
+        localByKey.set(`${c.loc.agent}|${c.loc.filePath}|${c.loc.scope}`, c);
+    }
+    // Index locations by (agent, file_path, scope) for pull path resolution
+    const locByKey = new Map();
+    for (const loc of locations) {
+        locByKey.set(`${loc.agent}|${loc.filePath}|${loc.scope}`, loc);
+    }
+    // Resolve a local write path for any config — even ones not discovered locally.
+    // This enables pulling configs to a brand-new device where agent dirs don't exist yet.
+    const resolveWritePath = (agent, filePath, scope) => {
+        const loc = locByKey.get(`${agent}|${filePath}|${scope}`);
+        if (loc)
+            return loc.path;
+        return resolveAgentConfigWritePath(agent, filePath, scope, {
+            cwd: process.cwd(),
+            home: homedir(),
+            currentProjectScope,
+            findClaudeProjectDir,
+        });
+    };
+    // Execute sync plan
+    let pushed = 0;
+    let pulled = 0;
+    let deletedLocal = 0;
+    let unchangedCount = 0;
+    let skipped = 0;
     let errors = 0;
-    for (const f of found) {
-        try {
-            const content = readFileSync(f.path, "utf-8");
-            if (!content.trim())
+    const ackConfigs = [];
+    // Group actions by agent for display
+    const byAgent = new Map();
+    for (const action of actions) {
+        const group = byAgent.get(action.agent) ?? [];
+        group.push(action);
+        byAgent.set(action.agent, group);
+    }
+    for (const [agent, agentActions] of byAgent) {
+        console.log(chalk.white(`  ${formatAgentName(agent)}`));
+        for (const action of agentActions) {
+            const key = `${action.agent}|${action.file_path}|${action.scope}`;
+            if (action.action === "unchanged") {
+                const local = localByKey.get(key);
+                console.log(chalk.gray(`    = ${action.file_path}`), chalk.gray("unchanged"));
+                if (local && action.version) {
+                    ackConfigs.push({
+                        agent: action.agent,
+                        file_path: action.file_path,
+                        scope: action.scope,
+                        content_hash: local.hash,
+                        version: action.version,
+                        local_path: local.loc.path,
+                    });
+                }
+                unchangedCount++;
                 continue;
-            const title = basename(f.path);
-            await apiPost("/v1/notes", {
-                content,
-                title,
-                source: "sync",
-                source_path: f.path,
-                content_type: "markdown",
-                category: "",
+            }
+            if (action.action === "push") {
+                const local = localByKey.get(key);
+                if (!local) {
+                    console.log(chalk.red(`    \u2717 ${action.file_path}`), chalk.gray("local file not found for push"));
+                    errors++;
+                    continue;
+                }
+                try {
+                    await getClient().configs.upsert({
+                        agent: action.agent,
+                        file_path: action.file_path,
+                        scope: action.scope,
+                        content: local.content,
+                        device_id: deviceID,
+                        local_path: local.loc.path,
+                    });
+                    console.log(chalk.green(`    \u2191 ${action.file_path}`), chalk.gray(action.reason === "local_only"
+                        ? "pushing (new)"
+                        : "pushing (local newer)"));
+                    pushed++;
+                }
+                catch (err) {
+                    console.log(chalk.red(`    \u2717 ${action.file_path}`), chalk.gray(err.message));
+                    errors++;
+                }
+                continue;
+            }
+            if (action.action === "pull") {
+                if (!action.config_id) {
+                    console.log(chalk.red(`    \u2717 ${action.file_path}`), chalk.gray("missing config ID from server"));
+                    errors++;
+                    continue;
+                }
+                try {
+                    const writePath = resolveWritePath(action.agent, action.file_path, action.scope);
+                    if (!writePath) {
+                        console.log(chalk.yellow(`    ? ${action.file_path}`), chalk.gray(action.scope !== "global" &&
+                            action.scope !== currentProjectScope
+                            ? "different project \u2014 skipped"
+                            : "unknown agent \u2014 skipped"));
+                        skipped++;
+                        continue;
+                    }
+                    // For new files (not updates), ask user before writing
+                    const isNewLocally = action.reason === "cloud_only" && !existsSync(writePath);
+                    if (isNewLocally && !options.pull) {
+                        console.log(chalk.cyan(`    New file: ${action.file_path}`));
+                        console.log(chalk.gray(`    → ${writePath}`));
+                        const accept = await confirmDefault(`    Download? [Y/n] `);
+                        if (!accept) {
+                            console.log(chalk.gray(`    - ${action.file_path}`), chalk.gray("skipped"));
+                            skipped++;
+                            continue;
+                        }
+                    }
+                    const config = await getClient().configs.get(action.config_id);
+                    mkdirSync(dirname(writePath), { recursive: true });
+                    writeFileSync(writePath, config.content);
+                    if (action.version) {
+                        ackConfigs.push({
+                            agent: action.agent,
+                            file_path: action.file_path,
+                            scope: action.scope,
+                            content_hash: config.content_hash,
+                            version: action.version,
+                            local_path: writePath,
+                        });
+                    }
+                    console.log(chalk.cyan(`    \u2193 ${action.file_path}`), chalk.gray(isNewLocally ? "restored" : "pulling (cloud newer)"));
+                    pulled++;
+                }
+                catch (err) {
+                    console.log(chalk.red(`    \u2717 ${action.file_path}`), chalk.gray(err.message));
+                    errors++;
+                }
+                continue;
+            }
+            if (action.action === "delete_local") {
+                if (!options.pull) {
+                    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+                        console.log(chalk.yellow(`    - ${action.file_path}`), chalk.gray("cloud deleted this config \u2014 skipped in non-interactive mode"));
+                        skipped++;
+                        continue;
+                    }
+                    const resolution = await promptCloudDeletion(action.file_path);
+                    if (resolution === "skip") {
+                        console.log(chalk.gray(`    - ${action.file_path}`), chalk.gray("skipped"));
+                        skipped++;
+                        continue;
+                    }
+                    if (resolution === "local") {
+                        const local = localByKey.get(key);
+                        if (!local) {
+                            console.log(chalk.yellow(`    - ${action.file_path}`), chalk.gray("local file missing \u2014 skipped"));
+                            skipped++;
+                            continue;
+                        }
+                        try {
+                            await getClient().configs.upsert({
+                                agent: action.agent,
+                                file_path: action.file_path,
+                                scope: action.scope,
+                                content: local.content,
+                                device_id: deviceID,
+                                local_path: local.loc.path,
+                            });
+                            console.log(chalk.green(`    \u2191 ${action.file_path}`), chalk.gray("kept local and restored to cloud"));
+                            pushed++;
+                        }
+                        catch (err) {
+                            console.log(chalk.red(`    \u2717 ${action.file_path}`), chalk.gray(err.message));
+                            errors++;
+                        }
+                        continue;
+                    }
+                }
+                try {
+                    const writePath = resolveWritePath(action.agent, action.file_path, action.scope);
+                    if (writePath && existsSync(writePath)) {
+                        moveFileToTrash(writePath, "agent-configs");
+                    }
+                    if (action.version) {
+                        ackConfigs.push({
+                            agent: action.agent,
+                            file_path: action.file_path,
+                            scope: action.scope,
+                            version: action.version,
+                            local_path: writePath ?? undefined,
+                            deleted: true,
+                        });
+                    }
+                    console.log(chalk.yellow(`    - ${action.file_path}`), chalk.gray("deleted locally (moved to Memax trash)"));
+                    deletedLocal++;
+                }
+                catch (err) {
+                    console.log(chalk.red(`    \u2717 ${action.file_path}`), chalk.gray(err.message));
+                    errors++;
+                }
+                continue;
+            }
+            if (action.action === "conflict") {
+                if (!process.stdin.isTTY || !process.stdout.isTTY) {
+                    console.log(chalk.yellow(`    - ${action.file_path}`), chalk.gray("conflict skipped in non-interactive mode"));
+                    skipped++;
+                    continue;
+                }
+                const resolution = await promptConflict(agent, action.file_path);
+                if (resolution === "local") {
+                    const local = localByKey.get(key);
+                    if (local) {
+                        try {
+                            await getClient().configs.upsert({
+                                agent: action.agent,
+                                file_path: action.file_path,
+                                scope: action.scope,
+                                content: local.content,
+                                device_id: deviceID,
+                                local_path: local.loc.path,
+                            });
+                            console.log(chalk.green(`    \u2191 ${action.file_path}`), chalk.gray("kept local"));
+                            pushed++;
+                        }
+                        catch (err) {
+                            console.log(chalk.red(`    \u2717 ${action.file_path}`), chalk.gray(err.message));
+                            errors++;
+                        }
+                    }
+                }
+                else if (resolution === "cloud" && action.config_id) {
+                    try {
+                        const writePath = resolveWritePath(action.agent, action.file_path, action.scope);
+                        if (writePath) {
+                            const config = await getClient().configs.get(action.config_id);
+                            mkdirSync(dirname(writePath), { recursive: true });
+                            writeFileSync(writePath, config.content);
+                            if (action.version) {
+                                ackConfigs.push({
+                                    agent: action.agent,
+                                    file_path: action.file_path,
+                                    scope: action.scope,
+                                    content_hash: config.content_hash,
+                                    version: action.version,
+                                    local_path: writePath,
+                                });
+                            }
+                            console.log(chalk.cyan(`    \u2193 ${action.file_path}`), chalk.gray("used cloud"));
+                            pulled++;
+                        }
+                    }
+                    catch (err) {
+                        console.log(chalk.red(`    \u2717 ${action.file_path}`), chalk.gray(err.message));
+                        errors++;
+                    }
+                }
+                else if (resolution === "merge" && action.config_id) {
+                    const local = localByKey.get(key);
+                    if (local) {
+                        try {
+                            const cloudConfig = await getClient().configs.get(action.config_id);
+                            console.log(chalk.gray(`    Merging with LLM...`));
+                            const merged = await mergeConfigs(action.agent, action.file_path, local.content, cloudConfig.content);
+                            if (merged) {
+                                // Write merged to local
+                                const writePath = resolveWritePath(action.agent, action.file_path, action.scope);
+                                if (writePath) {
+                                    mkdirSync(dirname(writePath), { recursive: true });
+                                    writeFileSync(writePath, merged);
+                                }
+                                // Push merged to cloud
+                                await getClient().configs.upsert({
+                                    agent: action.agent,
+                                    file_path: action.file_path,
+                                    scope: action.scope,
+                                    content: merged,
+                                    device_id: deviceID,
+                                    local_path: writePath ?? undefined,
+                                });
+                                console.log(chalk.magenta(`    \u2194 ${action.file_path}`), chalk.gray("merged (LLM)"));
+                                pushed++;
+                            }
+                            else {
+                                skipped++;
+                            }
+                        }
+                        catch (err) {
+                            console.log(chalk.red(`    \u2717 ${action.file_path}`), chalk.gray(err.message));
+                            errors++;
+                        }
+                    }
+                }
+                else {
+                    console.log(chalk.gray(`    - ${action.file_path}`), chalk.gray("skipped"));
+                    skipped++;
+                }
+            }
+        }
+    }
+    if (ackConfigs.length > 0) {
+        try {
+            await getClient().configs.ack({
+                device_id: deviceID,
+                configs: ackConfigs,
             });
-            synced++;
         }
         catch (err) {
-            const msg = err.message;
-            if (msg.includes("unchanged") ||
-                msg.includes("duplicate") ||
-                msg.includes("exists")) {
-                unchanged++;
-            }
-            else {
-                errors++;
-                console.log(chalk.red("  Error syncing"), f.label, chalk.gray(msg));
-            }
+            console.log(chalk.yellow("\n  Warning: failed to persist sync state"), chalk.gray(err.message));
         }
     }
-    console.log(chalk.blue(`Synced ${found.length} files to Memax`), chalk.gray(`(${synced} new, ${unchanged} unchanged${errors > 0 ? `, ${errors} errors` : ""})`));
+    // Summary
+    if (pushed === 0 &&
+        pulled === 0 &&
+        unchangedCount === 0 &&
+        skipped === 0 &&
+        errors === 0) {
+        console.log(chalk.gray("  No configs in cloud yet. Push some first from a device that has them.\n"));
+        return;
+    }
+    const parts = [];
+    if (pushed > 0)
+        parts.push(`${pushed} pushed`);
+    if (pulled > 0)
+        parts.push(`${pulled} restored`);
+    if (deletedLocal > 0)
+        parts.push(`${deletedLocal} deleted locally`);
+    if (unchangedCount > 0)
+        parts.push(`${unchangedCount} unchanged`);
+    if (skipped > 0)
+        parts.push(`${skipped} skipped`);
+    if (errors > 0)
+        parts.push(`${errors} errors`);
+    console.log(chalk.bold(`\n  Done: ${parts.join(", ")}`));
+    if (pulled > 0) {
+        console.log(chalk.gray("  Restart your agents for restored configs to take effect."));
+    }
+    console.log();
+}
+function formatAgentName(id) {
+    const names = {
+        "claude-code": "Claude Code",
+        cursor: "Cursor",
+        codex: "Codex",
+        gemini: "Gemini CLI",
+        copilot: "GitHub Copilot",
+        windsurf: "Windsurf",
+        openclaw: "OpenClaw",
+        opencode: "OpenCode",
+        generic: "Generic",
+    };
+    return names[id] ?? id;
+}
+async function promptConflict(_agent, filePath) {
+    const answer = await ask(chalk.yellow(`\n    ${filePath} has changes on both sides.\n` +
+        `    [l] Keep local  [c] Use cloud  [m] Merge (LLM)  [s] Skip: `));
+    const a = answer.toLowerCase();
+    if (a === "l")
+        return "local";
+    if (a === "c")
+        return "cloud";
+    if (a === "m")
+        return "merge";
+    return "skip";
+}
+async function promptCloudDeletion(filePath) {
+    const answer = await ask(chalk.yellow(`\n    ${filePath} was deleted in cloud.\n` +
+        `    [d] Delete local copy  [k] Keep local and restore cloud  [s] Skip: `));
+    const normalized = answer.toLowerCase();
+    if (normalized === "d")
+        return "delete";
+    if (normalized === "k")
+        return "local";
+    return "skip";
+}
+async function mergeConfigs(agent, filePath, localContent, cloudContent) {
+    try {
+        const result = await getClient().configs.merge({
+            local_content: localContent,
+            cloud_content: cloudContent,
+            file_path: filePath,
+            agent,
+        });
+        return result.merged_content;
+    }
+    catch (err) {
+        console.log(chalk.red(`    Merge failed: ${err.message}`));
+        return null;
+    }
 }
 //# sourceMappingURL=sync.js.map