memax-cli 0.1.0-alpha.26 → 0.1.0-alpha.28

package/dist/commands/sync.js

@@ -1,10 +1,11 @@
 import chalk from "chalk";
 import { createHash } from "node:crypto";
-import { readFileSync, writeFileSync, mkdirSync, readdirSync, statSync, watch, existsSync, } from "node:fs";
+import { readFileSync, writeFileSync, mkdirSync, rmSync, readdirSync, statSync, watch, existsSync, } from "node:fs";
 import { join, relative, extname, resolve, dirname } from "node:path";
 import { homedir } from "node:os";
 import { getClient } from "../lib/client.js";
-import { getProjectScope, resolveClaudeProjectFolder, normalizeFilePath, } from "../lib/project-context.js";
+import { getProjectScope, resolveProjectScope, resolveClaudeProjectFolder, normalizeFilePath, readMemaxYmlConfig, detectProjectContext, } from "../lib/project-context.js";
+import { getOrCreateDeviceID, listSyncSources, updateSyncSourceRun, } from "../lib/config.js";
 import { confirm, ask, confirmDefault } from "../lib/prompt.js";
 const DEFAULT_IGNORE = new Set([
     "node_modules",
@@ -83,6 +84,154 @@ export async function listAgentConfigsCommand() {
     }
     console.log(chalk.gray(`  ${configs.length} config${configs.length > 1 ? "s" : ""} synced to cloud.\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 !== "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 deleteAgentConfigsCommand() {
     let configs;
     try {
@@ -112,6 +261,7 @@ export async function deleteAgentConfigsCommand() {
             agent: c.agent,
             filePath: c.file_path,
             scope: c.scope,
+            version: c.version,
         });
         const idx = chalk.dim(`${items.length}.`);
         const scopeTag = c.scope === "global"
@@ -133,30 +283,89 @@ export async function deleteAgentConfigsCommand() {
         console.log(chalk.gray("  No valid selections.\n"));
         return;
     }
-    // Confirm
+    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(`\n  Delete ${indices.length} config${indices.length > 1 ? "s" : ""}? (y/N) `);
+    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 {
-            await getClient().configs.delete(item.id);
-            console.log(chalk.green(`    \u2713 ${item.agent}/${item.filePath}`), chalk.gray("deleted"));
+            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)) {
+                    rmSync(localPath);
+                }
+                console.log(chalk.green(`    \u2713 ${item.agent}/${item.filePath}`), chalk.gray("removed from this device"));
+            }
+            else {
+                await getClient().configs.delete(item.id);
+                if (localPath && existsSync(localPath)) {
+                    rmSync(localPath);
+                }
+                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"));
+            }
             deleted++;
         }
         catch (err) {
             console.log(chalk.red(`    \u2717 ${item.agent}/${item.filePath}`), chalk.gray(err.message));
         }
     }
-    console.log(chalk.gray(`\n  ${deleted} config${deleted > 1 ? "s" : ""} deleted.\n`));
+    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();
@@ -171,14 +380,27 @@ function formatAge(dateStr) {
 }
 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`));
@@ -193,25 +415,38 @@ export async function syncCommand(directory, options) {
     }
     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);
@@ -220,22 +455,22 @@ 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"
@@ -248,6 +483,7 @@ async function pushFile(file, options) {
             source: "sync",
             sourcePath: relPath,
             contentType,
+            projectContext,
         });
         console.log(chalk.green("  +"), relPath, chalk.gray(`[${memory.category}]`));
         return "pushed";
@@ -257,6 +493,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));
 }
@@ -312,6 +588,126 @@ function guessCategory(path) {
         return "reference/config";
     return "daily/note";
 }
+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();
@@ -448,6 +844,11 @@ function discoverAgentConfigs() {
 }
 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 = [];
@@ -474,6 +875,7 @@ async function syncAgentMemory(options = {}) {
         }
     }
     const isBootstrap = localConfigs.length === 0;
+    const deviceID = getOrCreateDeviceID();
     if (isBootstrap) {
         console.log(chalk.gray("  No local agent configs found. Checking cloud for backups...\n"));
     }
@@ -487,10 +889,14 @@ async function syncAgentMemory(options = {}) {
         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(manifest);
+        const plan = await getClient().configs.sync({
+            device_id: deviceID,
+            configs: manifest,
+        });
         actions = plan.actions;
     }
     catch (err) {
@@ -512,7 +918,7 @@ async function syncAgentMemory(options = {}) {
     // current project. Without this, running `memax sync agents` from ~/
     // would dump project configs (like .cursorrules from repo X) into the
     // home directory.
-    const currentProjectScope = getProjectScope();
+    const currentProjectScope = projectScopeResolution.scope;
     actions = actions.filter((a) => {
         if (!a.scope.startsWith("project:"))
             return true; // global → always sync
@@ -540,76 +946,24 @@ async function syncAgentMemory(options = {}) {
     // 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) => {
-        // First check if we have a known location from local discovery
         const loc = locByKey.get(`${agent}|${filePath}|${scope}`);
         if (loc)
             return loc.path;
-        const home = homedir();
-        // Global configs: reconstruct from agent dir + filePath
-        if (scope === "global") {
-            const agentDirs = {
-                "claude-code": join(home, ".claude"),
-                cursor: join(home, ".cursor"),
-                codex: join(home, ".codex"),
-                gemini: join(home, ".gemini"),
-                copilot: join(home, ".copilot"),
-                windsurf: join(home, ".windsurf"),
-                openclaw: join(home, ".openclaw"),
-                opencode: join(home, ".opencode"),
-            };
-            const dir = agentDirs[agent];
-            if (dir)
-                return join(dir, filePath);
-        }
-        // Project-scoped configs — ONLY write if we're in the matching project.
-        // This is the safety net: never write project files to the wrong directory.
-        if (scope.startsWith("project")) {
-            // Verify this scope matches the current project
-            if (scope !== "project" && scope !== currentProjectScope) {
-                return null; // Wrong project — refuse to write
-            }
-            // Claude per-project memories: filePath like "memory/feedback.md"
-            if (agent === "claude-code" && filePath.startsWith("memory/")) {
-                const projectDir = findClaudeProjectDir(scope);
-                if (projectDir)
-                    return join(projectDir, filePath);
-                // Fallback: use mangled cwd path
-                const mangledCwd = process.cwd().replace(/\//g, "-");
-                return join(home, ".claude", "projects", mangledCwd, filePath);
-            }
-            // Regular project configs: write relative to cwd
-            return join(process.cwd(), filePath);
-        }
-        return null;
+        return resolveAgentConfigWritePath(agent, filePath, scope, {
+            cwd: process.cwd(),
+            home: homedir(),
+            currentProjectScope,
+            findClaudeProjectDir,
+        });
     };
-    /**
-     * Find the local ~/.claude/projects/<mangled> directory that corresponds
-     * to a given project scope (e.g., "project:github.com/memaxlabs/memax").
-     */
-    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;
-    }
     // Execute sync plan
     let pushed = 0;
     let pulled = 0;
+    let deletedLocal = 0;
     let unchangedCount = 0;
     let skipped = 0;
     let errors = 0;
+    const ackConfigs = [];
     // Group actions by agent for display
     const byAgent = new Map();
     for (const action of actions) {
@@ -622,7 +976,18 @@ async function syncAgentMemory(options = {}) {
         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;
             }
@@ -639,6 +1004,8 @@ async function syncAgentMemory(options = {}) {
                         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)"
@@ -682,6 +1049,16 @@ async function syncAgentMemory(options = {}) {
                     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++;
                 }
@@ -691,6 +1068,31 @@ async function syncAgentMemory(options = {}) {
                 }
                 continue;
             }
+            if (action.action === "delete_local") {
+                try {
+                    const writePath = resolveWritePath(action.agent, action.file_path, action.scope);
+                    if (writePath && existsSync(writePath)) {
+                        rmSync(writePath);
+                    }
+                    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 (cloud removed everywhere)"));
+                    deletedLocal++;
+                }
+                catch (err) {
+                    console.log(chalk.red(`    \u2717 ${action.file_path}`), chalk.gray(err.message));
+                    errors++;
+                }
+                continue;
+            }
             if (action.action === "conflict") {
                 const resolution = await promptConflict(agent, action.file_path);
                 if (resolution === "local") {
@@ -702,6 +1104,8 @@ async function syncAgentMemory(options = {}) {
                                 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++;
@@ -719,6 +1123,16 @@ async function syncAgentMemory(options = {}) {
                             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++;
                         }
@@ -748,6 +1162,8 @@ async function syncAgentMemory(options = {}) {
                                     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++;
@@ -769,6 +1185,17 @@ async function syncAgentMemory(options = {}) {
             }
         }
     }
+    if (ackConfigs.length > 0) {
+        try {
+            await getClient().configs.ack({
+                device_id: deviceID,
+                configs: ackConfigs,
+            });
+        }
+        catch (err) {
+            console.log(chalk.yellow("\n  Warning: failed to persist sync state"), chalk.gray(err.message));
+        }
+    }
     // Summary
     if (pushed === 0 &&
         pulled === 0 &&
@@ -783,6 +1210,8 @@ async function syncAgentMemory(options = {}) {
         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)