@letta-ai/letta-code 0.14.2 → 0.14.3

package/letta.js

@@ -3108,7 +3108,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.14.2",
+    version: "0.14.3",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -5671,10 +5671,10 @@ Your memory blocks are synchronized with a filesystem tree at \`~/.letta/agents/
 ### Sync Behavior
 - **Startup**: Automatic sync when the CLI starts
 - **After memory edits**: Automatic sync after using memory tools
-- **Manual**: Run \`/memfs-sync\` to sync on demand
+- **Manual**: Run \`/memfs sync\` to sync on demand
 - **Conflict detection**: After each turn, the system checks for conflicts (both file and block changed since last sync)
 - **Agent-driven resolution**: If conflicts are detected, you'll receive a system reminder with the conflicting labels and instructions to resolve them using the \`syncing-memory-filesystem\` skill scripts
-- **User fallback**: The user can also run \`/memfs-sync\` to resolve conflicts manually via an interactive prompt
+- **User fallback**: The user can also run \`/memfs sync\` to resolve conflicts manually via an interactive prompt
 
 ### How It Works
 1. Each \`.md\` file path maps to a block label (e.g., \`system/persona/git_safety.md\` → label \`persona/git_safety\`)
@@ -61137,6 +61137,10 @@ function ensureMemoryFilesystemDirs(agentId, homeDir = homedir10()) {
 function hashContent(content) {
   return createHash3("sha256").update(content).digest("hex");
 }
+function hashFileBody(content) {
+  const { body } = parseMdxFrontmatter(content);
+  return hashContent(body);
+}
 function loadSyncState(agentId, homeDir = homedir10()) {
   const statePath = getMemoryStatePath(agentId, homeDir);
   const emptyState = {
@@ -61246,6 +61250,49 @@ async function writeMemoryFile(dir, label, content) {
   await ensureFilePath(filePath);
   await writeFile5(filePath, content, "utf-8");
 }
+function renderBlockToFileContent(block) {
+  const lines = ["---"];
+  if (block.description) {
+    const desc = block.description.includes(":") || block.description.includes(`
+`) ? `"${block.description.replace(/"/g, "\\\"")}"` : block.description;
+    lines.push(`description: ${desc}`);
+  }
+  if (block.limit) {
+    lines.push(`limit: ${block.limit}`);
+  }
+  if (block.read_only === true) {
+    lines.push("read_only: true");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push(block.value || "");
+  return lines.join(`
+`);
+}
+function parseBlockUpdateFromFileContent(fileContent, defaultLabel) {
+  const { frontmatter, body } = parseMdxFrontmatter(fileContent);
+  const label = frontmatter.label || defaultLabel;
+  const hasDescription = Object.hasOwn(frontmatter, "description");
+  const hasLimit = Object.hasOwn(frontmatter, "limit");
+  const hasReadOnly = Object.hasOwn(frontmatter, "read_only");
+  let limit2;
+  if (hasLimit && frontmatter.limit) {
+    const parsed = Number.parseInt(frontmatter.limit, 10);
+    if (!Number.isNaN(parsed) && parsed > 0) {
+      limit2 = parsed;
+    }
+  }
+  return {
+    label,
+    value: body,
+    ...hasDescription && { description: frontmatter.description },
+    ...hasLimit && limit2 !== undefined && { limit: limit2 },
+    ...hasReadOnly && { read_only: frontmatter.read_only === "true" },
+    hasDescription,
+    hasLimit,
+    hasReadOnly
+  };
+}
 async function deleteMemoryFile(dir, label) {
   const filePath = join19(dir, `${label}.md`);
   if (existsSync10(filePath)) {
@@ -61388,7 +61435,7 @@ async function syncMemoryFilesystem(agentId, options = {}) {
   const detachedBlockMap = new Map;
   for (const block of detachedBlocks) {
     if (block.label && block.id) {
-      if (MANAGED_BLOCK_LABELS.has(block.label)) {
+      if (MEMFS_MANAGED_LABELS.has(block.label)) {
         continue;
       }
       if (systemBlockMap.has(block.label)) {
@@ -61408,7 +61455,7 @@ async function syncMemoryFilesystem(agentId, options = {}) {
   const allBlocksMap = new Map;
   const allFilesMap = new Map;
   for (const label of Array.from(allLabels).sort()) {
-    if (MANAGED_BLOCK_LABELS.has(label)) {
+    if (MEMFS_MANAGED_LABELS.has(label)) {
       continue;
     }
     const systemFile = systemFiles.get(label);
@@ -61421,6 +61468,7 @@ async function syncMemoryFilesystem(agentId, options = {}) {
     const isAttached = !!attachedBlock;
     const fileDir = fileInSystem ? systemDir : detachedDir;
     const fileHash = fileEntry ? hashContent(fileEntry.content) : null;
+    const fileBodyHash = fileEntry ? hashFileBody(fileEntry.content) : null;
     const blockHash = blockEntry ? hashContent(blockEntry.value || "") : null;
     const lastFileHash = lastState.fileHashes[label] || null;
     const lastBlockHash = lastState.blockHashes[label] || null;
@@ -61440,6 +61488,12 @@ async function syncMemoryFilesystem(agentId, options = {}) {
         allFilesMap.delete(label);
         continue;
       }
+      if (READ_ONLY_BLOCK_LABELS.includes(label)) {
+        await deleteMemoryFile(fileDir, label);
+        deletedFiles.push(label);
+        allFilesMap.delete(label);
+        continue;
+      }
       const blockData = parseBlockFromFileContent(fileEntry.content, label);
       const createdBlock = await client.blocks.create({
         ...blockData,
@@ -61460,6 +61514,14 @@ async function syncMemoryFilesystem(agentId, options = {}) {
       continue;
     }
     if (!fileEntry && blockEntry) {
+      if (blockEntry.read_only) {
+        const targetDir2 = isAttached ? systemDir : detachedDir;
+        const fileContent2 = renderBlockToFileContent(blockEntry);
+        await writeMemoryFile(targetDir2, label, fileContent2);
+        createdFiles.push(label);
+        allFilesMap.set(label, { content: fileContent2 });
+        continue;
+      }
       if (lastFileHash && !blockChanged) {
         if (blockEntry.id) {
           try {
@@ -61482,16 +61544,17 @@ async function syncMemoryFilesystem(agentId, options = {}) {
         continue;
       }
       const targetDir = isAttached ? systemDir : detachedDir;
-      await writeMemoryFile(targetDir, label, blockEntry.value || "");
+      const fileContent = renderBlockToFileContent(blockEntry);
+      await writeMemoryFile(targetDir, label, fileContent);
       createdFiles.push(label);
-      allFilesMap.set(label, { content: blockEntry.value || "" });
+      allFilesMap.set(label, { content: fileContent });
       continue;
     }
     if (!fileEntry || !blockEntry) {
       continue;
     }
     const locationMismatch = fileInSystem && !isAttached || !fileInSystem && isAttached;
-    if (fileHash === blockHash) {
+    if (fileBodyHash === blockHash) {
       if (locationMismatch && blockEntry.id) {
         if (fileInSystem && !isAttached) {
           await client.agents.blocks.attach(blockEntry.id, {
@@ -61506,9 +61569,10 @@ async function syncMemoryFilesystem(agentId, options = {}) {
       continue;
     }
     if (fileChanged && blockChanged && resolution && resolution.resolution === "block") {
-      await writeMemoryFile(fileDir, label, blockEntry.value || "");
+      const fileContent = renderBlockToFileContent(blockEntry);
+      await writeMemoryFile(fileDir, label, fileContent);
       updatedFiles.push(label);
-      allFilesMap.set(label, { content: blockEntry.value || "" });
+      allFilesMap.set(label, { content: fileContent });
       if (locationMismatch && blockEntry.id) {
         if (fileInSystem && !isAttached) {
           await client.agents.blocks.attach(blockEntry.id, {
@@ -61523,9 +61587,10 @@ async function syncMemoryFilesystem(agentId, options = {}) {
       continue;
     }
     if (resolution?.resolution === "block") {
-      await writeMemoryFile(fileDir, label, blockEntry.value || "");
+      const fileContent = renderBlockToFileContent(blockEntry);
+      await writeMemoryFile(fileDir, label, fileContent);
       updatedFiles.push(label);
-      allFilesMap.set(label, { content: blockEntry.value || "" });
+      allFilesMap.set(label, { content: fileContent });
       if (locationMismatch && blockEntry.id) {
         if (fileInSystem && !isAttached) {
           await client.agents.blocks.attach(blockEntry.id, {
@@ -61540,14 +61605,31 @@ async function syncMemoryFilesystem(agentId, options = {}) {
       continue;
     }
     if (fileChanged) {
+      if (blockEntry.read_only) {
+        const fileContent = renderBlockToFileContent(blockEntry);
+        await writeMemoryFile(fileDir, label, fileContent);
+        updatedFiles.push(label);
+        allFilesMap.set(label, { content: fileContent });
+        continue;
+      }
       if (blockEntry.id) {
         try {
-          const blockData = parseBlockFromFileContent(fileEntry.content, label);
-          const updatePayload = isAttached ? { value: blockData.value } : { value: blockData.value, label };
+          const parsed = parseBlockUpdateFromFileContent(fileEntry.content, label);
+          const updatePayload = {
+            value: parsed.value
+          };
+          if (parsed.hasDescription)
+            updatePayload.description = parsed.description;
+          if (parsed.hasLimit)
+            updatePayload.limit = parsed.limit;
+          if (parsed.hasReadOnly)
+            updatePayload.read_only = parsed.read_only;
+          if (!isAttached)
+            updatePayload.label = label;
           await client.blocks.update(blockEntry.id, updatePayload);
           updatedBlocks.push(label);
           allBlocksMap.set(label, {
-            value: blockData.value,
+            value: parsed.value,
             id: blockEntry.id
           });
           if (locationMismatch) {
@@ -61588,9 +61670,10 @@ async function syncMemoryFilesystem(agentId, options = {}) {
       continue;
     }
     if (blockChanged) {
-      await writeMemoryFile(fileDir, label, blockEntry.value || "");
+      const fileContent = renderBlockToFileContent(blockEntry);
+      await writeMemoryFile(fileDir, label, fileContent);
       updatedFiles.push(label);
-      allFilesMap.set(label, { content: blockEntry.value || "" });
+      allFilesMap.set(label, { content: fileContent });
       if (locationMismatch && blockEntry.id) {
         if (fileInSystem && !isAttached) {
           await client.agents.blocks.attach(blockEntry.id, {
@@ -61633,8 +61716,14 @@ ${tree}`;
   const memfsBlock = blocks.find((block) => block.label === MEMORY_FILESYSTEM_BLOCK_LABEL);
   if (memfsBlock?.id) {
     await client.blocks.update(memfsBlock.id, { value: content });
+    const fileContent = renderBlockToFileContent({
+      value: content,
+      description: memfsBlock.description,
+      limit: memfsBlock.limit,
+      read_only: memfsBlock.read_only
+    });
+    await writeMemoryFile(systemDir, MEMORY_FILESYSTEM_BLOCK_LABEL, fileContent);
   }
-  await writeMemoryFile(systemDir, MEMORY_FILESYSTEM_BLOCK_LABEL, content);
 }
 async function ensureMemoryFilesystemBlock(agentId) {
   const client = await getClient2();
@@ -61702,7 +61791,7 @@ async function checkMemoryFilesystemStatus(agentId, options) {
   const detachedBlockMap = new Map;
   for (const block of detachedBlocks) {
     if (block.label) {
-      if (MANAGED_BLOCK_LABELS.has(block.label)) {
+      if (MEMFS_MANAGED_LABELS.has(block.label)) {
         continue;
       }
       if (systemBlockMap.has(block.label)) {
@@ -61720,7 +61809,7 @@ async function checkMemoryFilesystemStatus(agentId, options) {
     ...Object.keys(lastState.fileHashes)
   ]);
   for (const label of Array.from(allLabels).sort()) {
-    if (MANAGED_BLOCK_LABELS.has(label))
+    if (MEMFS_MANAGED_LABELS.has(label))
       continue;
     const systemFile = systemFiles.get(label);
     const detachedFile = detachedFiles.get(label);
@@ -61758,6 +61847,9 @@ function classifyLabel(label, fileContent, blockValue, lastFileHash, lastBlockHa
     if (lastBlockHash && !fileChanged) {
       return;
     }
+    if (READ_ONLY_BLOCK_LABELS.includes(label)) {
+      return;
+    }
     newFiles.push(label);
     return;
   }
@@ -61790,14 +61882,11 @@ async function detachMemoryFilesystemBlock(agentId) {
     await client.agents.blocks.detach(memfsBlock.id, { agent_id: agentId });
   }
 }
-var MEMORY_FILESYSTEM_BLOCK_LABEL = "memory_filesystem", MEMORY_FS_ROOT = ".letta", MEMORY_FS_AGENTS_DIR = "agents", MEMORY_FS_MEMORY_DIR = "memory", MEMORY_SYSTEM_DIR = "system", MEMORY_FS_STATE_FILE = ".sync-state.json", MANAGED_BLOCK_LABELS;
+var MEMORY_FILESYSTEM_BLOCK_LABEL = "memory_filesystem", MEMORY_FS_ROOT = ".letta", MEMORY_FS_AGENTS_DIR = "agents", MEMORY_FS_MEMORY_DIR = "memory", MEMORY_SYSTEM_DIR = "system", MEMORY_FS_STATE_FILE = ".sync-state.json", MEMFS_MANAGED_LABELS;
 var init_memoryFilesystem = __esm(async () => {
   init_memory();
   await init_client2();
-  MANAGED_BLOCK_LABELS = new Set([
-    MEMORY_FILESYSTEM_BLOCK_LABEL,
-    ...ISOLATED_BLOCK_LABELS
-  ]);
+  MEMFS_MANAGED_LABELS = new Set([MEMORY_FILESYSTEM_BLOCK_LABEL]);
 });
 
 // src/agent/message.ts
@@ -73563,17 +73652,10 @@ var init_registry = __esm(() => {
         return "Opening memory viewer...";
       }
     },
-    "/memfs-sync": {
-      desc: "Sync memory blocks with filesystem (requires memFS enabled)",
-      order: 15.5,
-      handler: () => {
-        return "Syncing memory filesystem...";
-      }
-    },
     "/memfs": {
-      desc: "Enable/disable filesystem-backed memory (/memfs [enable|disable])",
-      args: "[enable|disable]",
-      order: 15.6,
+      desc: "Manage filesystem-backed memory (/memfs [enable|disable|sync|reset])",
+      args: "[enable|disable|sync|reset]",
+      order: 15.5,
       handler: () => {
         return "Managing memory filesystem...";
       }
@@ -88957,8 +89039,8 @@ var exports_App = {};
 __export(exports_App, {
   default: () => App2
 });
-import { existsSync as existsSync16, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "node:fs";
-import { homedir as homedir15 } from "node:os";
+import { existsSync as existsSync16, readFileSync as readFileSync8, renameSync, writeFileSync as writeFileSync5 } from "node:fs";
+import { homedir as homedir15, tmpdir as tmpdir3 } from "node:os";
 import { join as join28 } from "node:path";
 function getErrorHintForStopReason(stopReason, currentModelId) {
   if (currentModelId === "opus" && stopReason === "llm_api_error" && getModelInfo("bedrock-opus")) {
@@ -89355,7 +89437,7 @@ function App2({
   const [memorySyncConflicts, setMemorySyncConflicts] = import_react88.useState(null);
   const memorySyncProcessedToolCallsRef = import_react88.useRef(new Set);
   const memorySyncCommandIdRef = import_react88.useRef(null);
-  const memorySyncCommandInputRef = import_react88.useRef("/memfs-sync");
+  const memorySyncCommandInputRef = import_react88.useRef("/memfs sync");
   const memorySyncInFlightRef = import_react88.useRef(false);
   const memoryFilesystemInitializedRef = import_react88.useRef(false);
   const pendingMemfsConflictsRef = import_react88.useRef(null);
@@ -89868,7 +89950,7 @@ function App2({
       });
     }
   }, [refreshDerived, currentModelId]);
-  const updateMemorySyncCommand = import_react88.useCallback((commandId, output, success, input = "/memfs-sync", keepRunning = false) => {
+  const updateMemorySyncCommand = import_react88.useCallback((commandId, output, success, input = "/memfs sync", keepRunning = false) => {
     buffersRef.current.byId.set(commandId, {
       kind: "command",
       id: commandId,
@@ -89899,7 +89981,7 @@ function App2({
           setMemorySyncConflicts(result.conflicts);
           setActiveOverlay("memfs-sync");
           if (commandId) {
-            updateMemorySyncCommand(commandId, `Memory sync paused — resolve ${result.conflicts.length} conflict${result.conflicts.length === 1 ? "" : "s"} to continue.`, false, "/memfs-sync", true);
+            updateMemorySyncCommand(commandId, `Memory sync paused — resolve ${result.conflicts.length} conflict${result.conflicts.length === 1 ? "" : "s"} to continue.`, false, "/memfs sync", true);
           }
         } else {
           debugLog("memfs", `${source} sync found ${result.conflicts.length} conflict(s), queuing for agent`);
@@ -90028,7 +90110,7 @@ function App2({
     const commandId = memorySyncCommandIdRef.current;
     const commandInput = memorySyncCommandInputRef.current;
     memorySyncCommandIdRef.current = null;
-    memorySyncCommandInputRef.current = "/memfs-sync";
+    memorySyncCommandInputRef.current = "/memfs sync";
     const resolutions = memorySyncConflicts.map((conflict) => {
       const answer = answers[`Conflict for ${conflict.label}`];
       return {
@@ -90077,7 +90159,7 @@ ${resolutionSummary}`, true, commandInput);
     const commandId = memorySyncCommandIdRef.current;
     const commandInput = memorySyncCommandInputRef.current;
     memorySyncCommandIdRef.current = null;
-    memorySyncCommandInputRef.current = "/memfs-sync";
+    memorySyncCommandInputRef.current = "/memfs sync";
     memorySyncInFlightRef.current = false;
     setMemorySyncConflicts(null);
     setActiveOverlay(null);
@@ -92624,46 +92706,32 @@ Press Enter to continue, or type anything to cancel.`, false, "running");
         }
         return { submitted: true };
       }
-      if (trimmed === "/memfs-sync") {
-        if (!settingsManager.isMemfsEnabled(agentId)) {
-          const cmdId2 = uid4("cmd");
-          buffersRef.current.byId.set(cmdId2, {
+      if (trimmed.startsWith("/memfs")) {
+        const [, subcommand] = trimmed.split(/\s+/);
+        const cmdId = uid4("cmd");
+        if (!subcommand || subcommand === "help") {
+          const output = [
+            "memfs commands:",
+            "- /memfs status  — show status",
+            "- /memfs enable  — enable filesystem-backed memory",
+            "- /memfs disable — disable filesystem-backed memory",
+            "- /memfs sync    — sync blocks and files now",
+            "- /memfs reset   — move local memfs to /tmp and recreate dirs"
+          ].join(`
+`);
+          buffersRef.current.byId.set(cmdId, {
             kind: "command",
-            id: cmdId2,
+            id: cmdId,
             input: msg,
-            output: "Memory filesystem is disabled. Run `/memfs enable` first.",
+            output,
             phase: "finished",
-            success: false
+            success: true
           });
-          buffersRef.current.order.push(cmdId2);
+          buffersRef.current.order.push(cmdId);
           refreshDerived();
           return { submitted: true };
         }
-        const cmdId = uid4("cmd");
-        buffersRef.current.byId.set(cmdId, {
-          kind: "command",
-          id: cmdId,
-          input: msg,
-          output: "Syncing memory filesystem...",
-          phase: "running"
-        });
-        buffersRef.current.order.push(cmdId);
-        refreshDerived();
-        setCommandRunning(true);
-        try {
-          await runMemoryFilesystemSync("command", cmdId);
-        } catch (error) {
-          const errorText = error instanceof Error ? error.message : String(error);
-          updateMemorySyncCommand(cmdId, `Failed: ${errorText}`, false);
-        } finally {
-          setCommandRunning(false);
-        }
-        return { submitted: true };
-      }
-      if (trimmed.startsWith("/memfs")) {
-        const [, subcommand] = trimmed.split(/\s+/);
-        const cmdId = uid4("cmd");
-        if (!subcommand || subcommand === "status") {
+        if (subcommand === "status") {
           const enabled = settingsManager.isMemfsEnabled(agentId);
           let output;
           if (enabled) {
@@ -92725,6 +92793,71 @@ ${formatMemorySyncSummary(result2)}`, true, msg);
           }
           return { submitted: true };
         }
+        if (subcommand === "sync") {
+          if (!settingsManager.isMemfsEnabled(agentId)) {
+            buffersRef.current.byId.set(cmdId, {
+              kind: "command",
+              id: cmdId,
+              input: msg,
+              output: "Memory filesystem is disabled. Run `/memfs enable` first.",
+              phase: "finished",
+              success: false
+            });
+            buffersRef.current.order.push(cmdId);
+            refreshDerived();
+            return { submitted: true };
+          }
+          buffersRef.current.byId.set(cmdId, {
+            kind: "command",
+            id: cmdId,
+            input: msg,
+            output: "Syncing memory filesystem...",
+            phase: "running"
+          });
+          buffersRef.current.order.push(cmdId);
+          refreshDerived();
+          setCommandRunning(true);
+          try {
+            await runMemoryFilesystemSync("command", cmdId);
+          } catch (error) {
+            const errorText = error instanceof Error ? error.message : String(error);
+            updateMemorySyncCommand(cmdId, `Failed: ${errorText}`, false);
+          } finally {
+            setCommandRunning(false);
+          }
+          return { submitted: true };
+        }
+        if (subcommand === "reset") {
+          buffersRef.current.byId.set(cmdId, {
+            kind: "command",
+            id: cmdId,
+            input: msg,
+            output: "Resetting memory filesystem...",
+            phase: "running"
+          });
+          buffersRef.current.order.push(cmdId);
+          refreshDerived();
+          setCommandRunning(true);
+          try {
+            const memoryDir = getMemoryFilesystemRoot(agentId);
+            if (!existsSync16(memoryDir)) {
+              updateMemorySyncCommand(cmdId, "No local memory filesystem found to reset.", true, msg);
+              return { submitted: true };
+            }
+            const backupDir = join28(tmpdir3(), `letta-memfs-reset-${agentId}-${Date.now()}`);
+            renameSync(memoryDir, backupDir);
+            ensureMemoryFilesystemDirs(agentId);
+            updateMemorySyncCommand(cmdId, `Memory filesystem reset.
+Backup moved to ${backupDir}
+Run \`/memfs sync\` to repopulate from API.`, true, msg);
+          } catch (error) {
+            const errorText = error instanceof Error ? error.message : String(error);
+            updateMemorySyncCommand(cmdId, `Failed to reset memfs: ${errorText}`, false, msg);
+          } finally {
+            setCommandRunning(false);
+          }
+          return { submitted: true };
+        }
         if (subcommand === "disable") {
           buffersRef.current.byId.set(cmdId, {
             kind: "command",
@@ -92767,7 +92900,7 @@ Files on disk have been kept.`, true, msg);
           kind: "command",
           id: cmdId,
           input: msg,
-          output: `Unknown subcommand: ${subcommand}. Use /memfs, /memfs enable, or /memfs disable.`,
+          output: `Unknown subcommand: ${subcommand}. Use /memfs, /memfs enable, /memfs disable, /memfs sync, or /memfs reset.`,
           phase: "finished",
           success: false
         });
@@ -100954,4 +101087,4 @@ Error during initialization: ${message}`);
 }
 main();
 
-//# debugId=5D585D67D2BE412A64756E2164756E21
+//# debugId=B77A56113A42C53064756E2164756E21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@letta-ai/letta-code",
-  "version": "0.14.2",
+  "version": "0.14.3",
   "description": "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
   "type": "module",
   "bin": {

package/skills/syncing-memory-filesystem/SKILL.md

@@ -5,7 +5,7 @@ description: Manage memory filesystem sync conflicts with git-like commands. Loa
 
 # Memory Filesystem Sync
 
-When memFS is enabled, your memory blocks are mirrored as `.md` files on disk at `~/.letta/agents/<agent-id>/memory/`. Changes to blocks or files are detected via content hashing and synced at startup and on manual `/memfs-sync`.
+When memFS is enabled, your memory blocks are mirrored as `.md` files on disk at `~/.letta/agents/<agent-id>/memory/`. Changes to blocks or files are detected via content hashing and synced at startup and on manual `/memfs sync`.
 
 **Conflicts** occur when both the file and the block are modified since the last sync (e.g., user edits a file in their editor while the block is also updated manually by the user via the API). Non-conflicting changes (only one side changed) are resolved automatically during the next sync.
 
@@ -96,5 +96,5 @@ npx tsx <SKILL_DIR>/scripts/memfs-resolve.ts $LETTA_AGENT_ID --resolutions '[{"l
 ## Notes
 
 - Non-conflicting changes (only one side modified) are resolved automatically during the next sync — you only need to intervene for true conflicts
-- The `/memfs-sync` command is still available for users to manually trigger sync and resolve conflicts via the CLI overlay
+- The `/memfs sync` command is still available for users to manually trigger sync and resolve conflicts via the CLI overlay
 - After resolving, the sync state is updated so the same conflicts won't reappear