@innominatum/agentforge-cli 1.1.3 → 1.1.22

package/src/index.ts

@@ -314,9 +314,106 @@ const deployCmd = program
   .command("deploy")
   .description("Faz o deploy de entidades para a plataforma GoClaw");
 
+async function deploySkill(slug: string, config: any, basePath: string) {
+  const skillPath = path.join(basePath, "skills", slug);
+  const exportsPath = path.join(basePath, "exports");
+  const safeSlug = slug.replace(/[\\\/]/g, '_');
+  const zipPath = path.join(exportsPath, `${safeSlug}.zip`);
+
+  if (!(await fs.pathExists(skillPath))) {
+    console.error(`❌ A skill "${slug}" não foi encontrada em skills/${slug}.`);
+    return;
+  }
+  
+  await fs.ensureDir(exportsPath);
+  const zip = new AdmZip();
+  zip.addLocalFolder(skillPath, "");
+  zip.writeZip(zipPath);
+  
+  console.log(`🚀 Fazendo upload da skill "${slug}" para o GoClaw...`);
+  const form = new FormData();
+  form.append("file", fs.createReadStream(zipPath));
+
+  try {
+    const url = `${config.goclaw.api_url}/v1/skills/upload`;
+    const response = await axios.post(url, form, {
+      headers: {
+        ...form.getHeaders(),
+        Authorization: `Bearer ${config.goclaw.token}`, "X-GoClaw-User-Id": config.goclaw.username || "system"
+      }
+    });
+    const data = response.data;
+    if (data && data.version) {
+      console.log(`✅ Arquivos da skill "${slug}" atualizados (versão ${data.version}).`);
+    } else {
+      console.log(`✅ Arquivos da skill "${slug}" atualizados.`);
+    }
+
+    // Sincronizar metadados (visibility, description, tags, etc)
+    const skillsListRes = await axios.get(`${config.goclaw.api_url}/v1/skills`, {
+      headers: { Authorization: `Bearer ${config.goclaw.token}`, "X-GoClaw-User-Id": config.goclaw.username || "system" }
+    });
+    const remoteSkill = skillsListRes.data.skills?.find((s: any) => s.slug === slug);
+    
+    if (remoteSkill) {
+      const metadataPath = path.join(skillPath, "metadata.json");
+      if (await fs.pathExists(metadataPath)) {
+        console.log(`🚀 Sincronizando metadados da skill "${slug}"...`);
+        const metadata = await fs.readJson(metadataPath);
+        
+        // Remover campos que não devem ser enviados no PUT
+        const payload = { ...metadata };
+        delete payload.id;
+        delete payload.slug;
+        delete payload.name;
+        
+        await axios.put(`${config.goclaw.api_url}/v1/skills/${remoteSkill.id}`, payload, {
+          headers: { Authorization: `Bearer ${config.goclaw.token}`, "X-GoClaw-User-Id": config.goclaw.username || "system" }
+        });
+        console.log(`✅ Metadados sincronizados com sucesso.`);
+      }
+
+      // Sincronizar permissões (grants)
+      const grantsPath = path.join(skillPath, "grants.jsonl");
+      if (await fs.pathExists(grantsPath)) {
+        console.log(`🚀 Sincronizando permissões (grants) da skill "${slug}"...`);
+        const grantsContent = await fs.readFile(grantsPath, 'utf8');
+        const lines = grantsContent.split('\n').filter(l => l.trim());
+        
+        for (const line of lines) {
+          try {
+            const grant = JSON.parse(line);
+            if (grant.agent_key) {
+              const agentId = await resolveAgentId(grant.agent_key, config);
+              if (agentId) {
+                await axios.post(`${config.goclaw.api_url}/v1/skills/${remoteSkill.id}/grants/agent`, 
+                  { agent_id: agentId, version: grant.pinned_version || null },
+                  { headers: { Authorization: `Bearer ${config.goclaw.token}`, "X-GoClaw-User-Id": config.goclaw.username || "system" } }
+                );
+                console.log(`   ➕ Permissão concedida ao agente: ${grant.agent_key}`);
+              }
+            }
+          } catch (e: any) {
+            console.warn(`   ⚠️ Falha ao conceder permissão: ${e.response?.data?.error || e.message}`);
+          }
+        }
+        console.log(`✅ Permissões sincronizadas.`);
+      }
+    }
+
+  } catch (error: any) {
+    console.error(`❌ Erro no deploy da skill "${slug}":`);
+    if (error.response) {
+      console.error(error.response.data);
+    } else {
+      console.error(error.message);
+    }
+  }
+}
+
 deployCmd
   .command("skill <slug>")
-  .description("Faz o build da skill e envia para a API do GoClaw")
+  .description("Faz build e upload automático de uma skill para o GoClaw")
   .action(async (slug: string) => {
     const config = await getConfig();
     if (!config.goclaw || !config.goclaw.token) {
@@ -325,46 +422,7 @@ deployCmd
     }
 
     const basePath = getWorkspaceRoot();
-    const skillPath = path.join(basePath, "skills", slug);
-    const exportsPath = path.join(basePath, "exports");
-    const zipPath = path.join(exportsPath, `${slug}.zip`);
-
-    if (!(await fs.pathExists(skillPath))) {
-      console.error(`❌ A skill "${slug}" não foi encontrada em skills/${slug}.`);
-      process.exit(1);
-    }
-    
-    await fs.ensureDir(exportsPath);
-    const zip = new AdmZip();
-    zip.addLocalFolder(skillPath, "");
-    zip.writeZip(zipPath);
-    
-    console.log(`✅ Build concluído: ${slug}.zip preparado para envio.`);
-
-    console.log(`🚀 Fazendo upload para o GoClaw...`);
-    const form = new FormData();
-    form.append("file", fs.createReadStream(zipPath));
-
-    try {
-      const url = `${config.goclaw.api_url}/v1/skills/upload`;
-      const response = await axios.post(url, form, {
-        headers: {
-          ...form.getHeaders(),
-          Authorization: `Bearer ${config.goclaw.token}`, "X-GoClaw-User-Id": config.goclaw.username || "system"
-        }
-      });
-      const data = response.data;
-      if (data && data.version) {
-        console.log(`📌 Skill atualizada para a versão ${data.version}.`);
-      }
-    } catch (error: any) {
-      console.error("❌ Erro durante o deploy:");
-      if (error.response) {
-        console.error(error.response.data);
-      } else {
-        console.error(error.message);
-      }
-    }
+    await deploySkill(slug, config, basePath);
   });
 
 async function deployContextFiles(slug: string, config: any, resolvedId?: string | null) {
@@ -376,66 +434,121 @@ async function deployContextFiles(slug: string, config: any, resolvedId?: string
   }
 
   const files = await fs.readdir(agentPath);
-  
-  // Identificar ficheiros de contexto e de memória
-  const memoryFileNames = ['MEMORY.md', 'memory.md'];
-  const memoryDirName = 'memory';
-  
-  const contextFiles = files.filter(f => 
-    (f.endsWith('.md') || f.endsWith('.txt') || f.endsWith('.py')) && 
-    f !== 'README.md' && 
-    f !== 'agent.json' && 
-    !memoryFileNames.includes(f)
-  );
-  
-  const hasMemoryDir = await fs.pathExists(path.join(agentPath, memoryDirName));
-  const memoryFilesFound = files.filter(f => memoryFileNames.includes(f));
-  const hasMemory = hasMemoryDir || memoryFilesFound.length > 0;
+  const itemsToSync = files.filter(f => f !== 'agent.json' && f !== 'README.md');
 
-  if (contextFiles.length === 0 && !hasMemory) {
+  if (itemsToSync.length === 0) {
     console.log(`Nenhum ficheiro de contexto ou memória encontrado para "${slug}".`);
     return;
   }
 
   const tempExportDir = path.join(basePath, `temp_export_${slug}`);
-  const tempContextDir = path.join(tempExportDir, "context_files");
-  const tempMemoryDir = path.join(tempExportDir, "memory");
   const tarPath = path.join(basePath, `temp_export_${slug}.tar.gz`);
 
+  // Guardar lista de ficheiros locais para pruning
+  const localFilePaths: string[] = [];
+  async function collectFilesRecursive(dir: string, baseDir: string): Promise<string[]> {
+    const results: string[] = [];
+    if (!(await fs.pathExists(dir))) return results;
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      const relativePath = path.relative(baseDir, fullPath).replace(/\\/g, '/');
+      if (entry.isDirectory()) {
+        const subResults = await collectFilesRecursive(fullPath, baseDir);
+        results.push(...subResults);
+      } else {
+        results.push(relativePath);
+      }
+    }
+    return results;
+  }
+
   try {
-    const sections: string[] = [];
+    const sections = new Set<string>();
     
-    if (contextFiles.length > 0) {
-      sections.push("context_files");
-      await fs.ensureDir(tempContextDir);
-      for (const file of contextFiles) {
-        await fs.copy(path.join(agentPath, file), path.join(tempContextDir, file));
+    // Processar ficheiros/pastas da raiz do agente
+    for (const item of itemsToSync) {
+      const itemPath = path.join(agentPath, item);
+      const isDir = (await fs.stat(itemPath)).isDirectory();
+      
+      const section = "context_files";
+      sections.add(section);
+      
+      const targetDir = path.join(tempExportDir, section);
+      await fs.ensureDir(targetDir);
+      
+      if (isDir) {
+        // Obter todos os ficheiros da pasta (ex: memory, _system)
+        // e achatá-os (flatten) com o nome da pasta como prefixo (ex: memory_arquivo.md)
+        // O GoClaw espera que os ficheiros de contexto não tenham pastas, mas sim prefixos achatados!
+        const subFiles = await fs.readdir(itemPath);
+        for (const sub of subFiles) {
+          const subPath = path.join(itemPath, sub);
+          const isSubDir = (await fs.stat(subPath)).isDirectory();
+          if (!isSubDir) {
+            const flatName = `${item}_${sub}`;
+            await fs.copy(subPath, path.join(targetDir, flatName));
+          }
+        }
+      } else {
+        await fs.copy(itemPath, path.join(targetDir, item));
       }
     }
 
-    if (hasMemory) {
-      sections.push("memory");
-      await fs.ensureDir(tempMemoryDir);
-      // Copiar ficheiros de memória explícitos para a pasta memory no arquivo
-      for (const file of memoryFilesFound) {
-        await fs.copy(path.join(agentPath, file), path.join(tempMemoryDir, file));
+    // Coletar ficheiros para pruning
+    const sectionDir = path.join(tempExportDir, "context_files");
+    const sectionEntries = await collectFilesRecursive(sectionDir, sectionDir);
+    for (const entry of sectionEntries) {
+      // O GoClaw retorna os caminhos das memórias com barras (memory/arquivo.md)
+      // Nós achatamos para o upload (memory_arquivo.md). Para o pruning não apagar ficheiros
+      // válidos acidentalmente, temos que re-mapear o nome achatado para a versão com barra.
+      let finalEntry = entry;
+      if (entry.startsWith("memory_")) {
+        finalEntry = entry.replace("memory_", "memory/");
+      } else if (entry.startsWith("_system_")) {
+        finalEntry = entry.replace("_system_", "_system/");
       }
-      // Copiar conteúdo da pasta memory se existir
-      if (hasMemoryDir) {
-        await fs.copy(path.join(agentPath, memoryDirName), tempMemoryDir);
+      localFilePaths.push(finalEntry);
+    }
+
+    const sectionsArray = Array.from(sections);
+
+    // --- HACK PARA APAGAR FICHEIROS FÍSICOS DO GOCLAW ---
+    // O GoClaw não apaga ficheiros do disco (context_files) quando os apagamos da DB (memory_documents).
+    // Isto faz com que os ficheiros voltem como "fantasmas" durante o pull.
+    // Solução: Injetar ficheiros vazios no tarball para os órfãos, forçando o /import a esmagá-los com 0 bytes!
+    try {
+      const docsUrl = `${config.goclaw.api_url}/v1/agents/${agentId}/memory/documents`;
+      const preDocsRes = await axios.get(docsUrl, {
+        headers: { Authorization: `Bearer ${config.goclaw.token}`, "X-GoClaw-User-Id": config.goclaw.username || "system" }
+      });
+      const preDocs = preDocsRes.data || [];
+      for (const pDoc of preDocs) {
+        if (pDoc.path && !localFilePaths.includes(pDoc.path)) {
+          const flatGhost = pDoc.path.replace(/[\/\\]/g, '_');
+          const ghostPath = path.join(tempExportDir, "context_files", flatGhost);
+          await fs.ensureDir(path.dirname(ghostPath));
+          await fs.writeFile(ghostPath, " "); // 1 byte soft-delete payload
+          if (!sectionsArray.includes("context_files")) {
+            sectionsArray.push("context_files");
+          }
+        }
       }
+    } catch (e: any) {
+      console.warn("Aviso: Falha ao procurar fantasmas para o tarball.", e.message);
     }
 
     await tar.c({
       gzip: true,
       file: tarPath,
       cwd: tempExportDir
-    }, sections);
+    }, sectionsArray);
 
     const form = new FormData();
     form.append("file", fs.createReadStream(tarPath));
 
-    const url = `${config.goclaw.api_url}/v1/agents/${agentId}/import?include=${sections.join(",")}`;
+    // Upload dos ficheiros (aditivo)
+    const url = `${config.goclaw.api_url}/v1/agents/${agentId}/import?include=${sectionsArray.join(",")}`;
     await axios.post(url, form, {
       headers: {
         ...form.getHeaders(),
@@ -444,7 +557,76 @@ async function deployContextFiles(slug: string, config: any, resolvedId?: string
       }
     });
 
-    console.log(`✅ Upload cirúrgico de ${contextFiles.length} ficheiros de contexto e ${hasMemory ? 'dados de memória' : 'sem memória'} concluído com sucesso!`);
+    console.log(`✅ Upload de ficheiros e subpastas de contexto concluído com sucesso!`);
+
+    // Atualização forçada de memórias editadas (bypassa a proteção de overwrite do /import)
+    for (const localPath of localFilePaths) {
+      if (localPath.startsWith('memory/') && localPath.endsWith('.md')) {
+        try {
+          // O ficheiro físico no tempExportDir está achatado (memory_arquivo.md)
+          const flatFileName = localPath.replace("memory/", "memory_");
+          const content = await fs.readFile(path.join(sectionDir, flatFileName), 'utf8');
+          
+          // O endpoint usa {path...} portanto não podemos fazer URL encode das barras
+          const putUrl = `${config.goclaw.api_url}/v1/agents/${agentId}/memory/documents/${localPath}`;
+          await axios.put(putUrl, { content }, {
+            headers: { Authorization: `Bearer ${config.goclaw.token}`, "X-GoClaw-User-Id": config.goclaw.username || "system" }
+          });
+          console.log(`✅ Edição de memória forçada com sucesso: ${localPath}`);
+        } catch (putErr: any) {
+          console.warn(`⚠️ Aviso na edição de ${localPath}: O conteúdo pode não ter sido alterado. (${putErr.message})`);
+        }
+      }
+    }
+
+    // --- Início do Pruning (Remover ficheiros órfãos do servidor) ---
+    try {
+      const documentsUrl = `${config.goclaw.api_url}/v1/agents/${agentId}/memory/documents`;
+      const docsResponse = await axios.get(documentsUrl, {
+        headers: {
+          Authorization: `Bearer ${config.goclaw.token}`,
+          "X-GoClaw-User-Id": config.goclaw.username || "system"
+        }
+      });
+      
+      const remoteDocs = docsResponse.data || [];
+      let deletedCount = 0;
+      
+      for (const doc of remoteDocs) {
+        if (!doc.path) continue;
+        
+        // Verifica se o ficheiro remoto existe na nossa lista de ficheiros locais
+        if (!localFilePaths.includes(doc.path)) {
+          console.log(`🧹 Removendo memória órfã no servidor: ${doc.path}`);
+          
+          try {
+            // O endpoint do GoClaw espera o caminho exato sem URL encode (route genérica {path...})
+            // E é mandatório passar o user_id dono do documento, senão dá erro 500.
+            const deleteUrl = `${config.goclaw.api_url}/v1/agents/${agentId}/memory/documents/${doc.path}`;
+            await axios.delete(deleteUrl, {
+              headers: {
+                Authorization: `Bearer ${config.goclaw.token}`,
+                "X-GoClaw-User-Id": doc.user_id || config.goclaw.username || "system"
+              }
+            });
+            deletedCount++;
+          } catch (delErr: any) {
+            const errorData = delErr.response?.data?.error || "";
+            if (delErr.response?.status === 500 && errorData.includes("not found")) {
+              console.log(`✅ ${doc.path} já estava removido da base de dados.`);
+            } else {
+              console.warn(`⚠️ Não foi possível apagar ${doc.path}: ${delErr.message}`);
+            }
+          }
+        }
+      }
+      if (deletedCount > 0) {
+        console.log(`✅ Pruning concluído: ${deletedCount} ficheiro(s) apagado(s) do GoClaw.`);
+      }
+    } catch (pruneErr: any) {
+      console.warn(`⚠️ Aviso: Falha ao fazer pruning das memórias: ${pruneErr.message}`);
+    }
+
   } finally {
     if (await fs.pathExists(tempExportDir)) await fs.remove(tempExportDir);
     if (await fs.pathExists(tarPath)) await fs.remove(tarPath);
@@ -519,8 +701,45 @@ deployCmd
     await deployAgent(slug, config);
   });
 
+
+async function deployAllAgents(config: any, basePath: string) {
+  const agentsDir = path.join(basePath, "agents");
+  if (await fs.pathExists(agentsDir)) {
+    const agents = await fs.readdir(agentsDir);
+    console.log(`🚀 Iniciando deploy em lote de ${agents.length} agentes...`);
+    for (const slug of agents) {
+      const agentPath = path.join(agentsDir, slug);
+      if ((await fs.stat(agentPath)).isDirectory()) {
+         await deployAgent(slug, config);
+      }
+    }
+  } else {
+    console.log("Nenhum agente encontrado em agents/.");
+  }
+}
+
+async function deployAllSkills(config: any, basePath: string) {
+  const skillsDir = path.join(basePath, "skills");
+  if (await fs.pathExists(skillsDir)) {
+    const skills = await fs.readdir(skillsDir);
+    console.log(`🚀 Iniciando deploy em lote de skills...`);
+    for (const item of skills) {
+      const itemPath = path.join(skillsDir, item);
+      if ((await fs.stat(itemPath)).isDirectory()) {
+        if (item === "system") {
+          console.log("⏩ Ignorando pasta 'system/' (skills nativas do GoClaw são apenas de leitura)");
+          continue;
+        }
+        await deploySkill(item, config, basePath);
+      }
+    }
+  } else {
+    console.log("Nenhuma skill encontrada em skills/.");
+  }
+}
+
 deployCmd
-  .command("all")
+  .command("agents")
   .description("Faz deploy de todos os agentes do workspace")
   .action(async () => {
     const config = await getConfig();
@@ -528,32 +747,137 @@ deployCmd
       console.error("❌ Configure sua chave de API (token) no agentforge.json.");
       process.exit(1);
     }
-
     const basePath = getWorkspaceRoot();
-    const agentsDir = path.join(basePath, "agents");
-    
-    if (!(await fs.pathExists(agentsDir))) {
-      console.log("Nenhum agente encontrado em agents/.");
-      return;
+    await deployAllAgents(config, basePath);
+    console.log("🏁 Deploy de agentes concluído!");
+  });
+
+deployCmd
+  .command("skills")
+  .description("Faz deploy de todas as skills do workspace")
+  .action(async () => {
+    const config = await getConfig();
+    if (!config.goclaw || !config.goclaw.token) {
+      console.error("❌ Configure sua chave de API (token) no agentforge.json.");
+      process.exit(1);
     }
+    const basePath = getWorkspaceRoot();
+    await deployAllSkills(config, basePath);
+    console.log("🏁 Deploy de skills concluído!");
+  });
 
-    const agents = await fs.readdir(agentsDir);
-    console.log(`🚀 Iniciando deploy em lote de ${agents.length} agentes...`);
-    
-    for (const slug of agents) {
-      const agentPath = path.join(agentsDir, slug);
-      if ((await fs.stat(agentPath)).isDirectory()) {
-         await deployAgent(slug, config);
-      }
+deployCmd
+  .command("all")
+  .description("Faz deploy de todos os agentes e skills do workspace")
+  .action(async () => {
+    const config = await getConfig();
+    if (!config.goclaw || !config.goclaw.token) {
+      console.error("❌ Configure sua chave de API (token) no agentforge.json.");
+      process.exit(1);
     }
+
+    const basePath = getWorkspaceRoot();
+    await deployAllAgents(config, basePath);
+    await deployAllSkills(config, basePath);
     
-    console.log("🏁 Deploy em lote concluído!");
+    console.log("🏁 Deploy completo (agentes e skills) concluído!");
   });
 
 const pullCmd = program
   .command("pull")
   .description("Sincroniza entidades do GoClaw para o workspace local");
 
+async function pullAllSkills(config: any) {
+  console.log("🧹 Limpando a pasta local de skills...");
+  await fs.emptyDir(path.join(getWorkspaceRoot(), "skills"));
+
+  console.log("📥 Baixando skills do GoClaw...");
+  const url = `${config.goclaw.api_url}${config.goclaw.skills_export_endpoint || '/v1/skills/export'}`;
+  const response = await axios.get(url, {
+    headers: {
+      Authorization: `Bearer ${config.goclaw.token}`, "X-GoClaw-User-Id": config.goclaw.username || "system"
+    },
+    responseType: "stream"
+  });
+
+  const tempTarPath = path.join(getWorkspaceRoot(), "temp_skills.tar.gz");
+  const writer = fs.createWriteStream(tempTarPath);
+  response.data.pipe(writer);
+
+  await new Promise((resolve, reject) => {
+    writer.on("finish", resolve);
+    writer.on("error", reject);
+  });
+
+  console.log("📦 Extraindo skills para a pasta local...");
+  await tar.x({
+    file: tempTarPath,
+    cwd: getWorkspaceRoot()
+  });
+  await fs.remove(tempTarPath);
+
+  console.log("📥 Baixando ficheiros de código das skills...");
+  const skillsListRes = await axios.get(`${config.goclaw.api_url}/v1/skills`, {
+    headers: { Authorization: `Bearer ${config.goclaw.token}`, "X-GoClaw-User-Id": config.goclaw.username || "system" }
+  });
+  
+  const skills = skillsListRes.data.skills || [];
+  for (const skill of skills) {
+    try {
+      const isSystem = skill.is_system === true;
+      const targetFolder = isSystem ? path.join("system", skill.slug) : skill.slug;
+      
+      if (isSystem) {
+        const originalPath = path.join(getWorkspaceRoot(), "skills", skill.slug);
+        const newPath = path.join(getWorkspaceRoot(), "skills", targetFolder);
+        if (await fs.pathExists(originalPath)) {
+          await fs.ensureDir(path.dirname(newPath));
+          await fs.move(originalPath, newPath, { overwrite: true });
+        }
+      }
+
+      const filesRes = await axios.get(`${config.goclaw.api_url}/v1/skills/${skill.id}/files`, {
+        headers: { Authorization: `Bearer ${config.goclaw.token}`, "X-GoClaw-User-Id": config.goclaw.username || "system" }
+      });
+      
+      const files = filesRes.data.files || [];
+      for (const file of files) {
+        if (file.isDir) continue;
+        const fileContentRes = await axios.get(`${config.goclaw.api_url}/v1/skills/${skill.id}/files/${file.path}`, {
+          headers: { Authorization: `Bearer ${config.goclaw.token}`, "X-GoClaw-User-Id": config.goclaw.username || "system" }
+        });
+        const filePath = path.join(getWorkspaceRoot(), "skills", targetFolder, file.path);
+        await fs.ensureDir(path.dirname(filePath));
+        await fs.writeFile(filePath, fileContentRes.data.content || "");
+      }
+    } catch (fileErr: any) {
+      console.warn(`⚠️ Não foi possível transferir os ficheiros da skill ${skill.slug}: ${fileErr.message}`);
+    }
+  }
+
+  // Remover quaisquer skills fantasmas que o tarball tenha extraído
+  const validSlugs = new Set(skills.map((s: any) => s.is_system === true ? path.join("system", s.slug) : s.slug));
+  const skillsDir = path.join(getWorkspaceRoot(), "skills");
+  if (await fs.pathExists(skillsDir)) {
+    const localItems = await fs.readdir(skillsDir);
+    for (const item of localItems) {
+      if (item === "system") {
+        const systemDir = path.join(skillsDir, "system");
+        if (await fs.pathExists(systemDir)) {
+          const systemItems = await fs.readdir(systemDir);
+          for (const sysItem of systemItems) {
+            if (!validSlugs.has(path.join("system", sysItem))) {
+              await fs.remove(path.join(systemDir, sysItem));
+            }
+          }
+        }
+      } else if (!validSlugs.has(item)) {
+        await fs.remove(path.join(skillsDir, item));
+      }
+    }
+  }
+}
+
 pullCmd
   .command("skills")
   .description("Faz download do arquivo tar.gz de skills do GoClaw e extrai localmente")
@@ -569,106 +893,101 @@ pullCmd
       return;
     }
 
-    console.log("🧹 Limpando a pasta local de skills...");
-    await fs.emptyDir(path.join(getWorkspaceRoot(), "skills"));
-
-    console.log("📥 Baixando skills do GoClaw...");
     try {
-      const url = `${config.goclaw.api_url}${config.goclaw.skills_export_endpoint || '/v1/skills/export'}`;
-      const response = await axios.get(url, {
-        headers: {
-          Authorization: `Bearer ${config.goclaw.token}`, "X-GoClaw-User-Id": config.goclaw.username || "system"
-        },
-        responseType: "stream"
-      });
+      await pullAllSkills(config);
+      console.log("✅ Pull de skills concluído com sucesso! As skills foram atualizadas localmente.");
+    } catch (error: any) {
+      console.error("❌ Erro durante o pull das skills:");
+      if (error.response) {
+        console.error(`Status HTTP ${error.response.status}`);
+      } else {
+        console.error(error.message);
+      }
+    }
+  });
 
-      const tempTarPath = path.join(getWorkspaceRoot(), "temp_skills.tar.gz");
-      const writer = fs.createWriteStream(tempTarPath);
-      response.data.pipe(writer);
+async function pullAgent(slug: string, agentId: string, config: any) {
+  console.log(`📦 Baixando agente: ${slug}...`);
+  
+  const url = `${config.goclaw.api_url}/v1/agents/${agentId}/export`;
+  const response = await axios.get(url, {
+    headers: { Authorization: `Bearer ${config.goclaw.token}`, "X-GoClaw-User-Id": config.goclaw.username || "system" },
+    responseType: "stream"
+  });
 
-      await new Promise((resolve, reject) => {
-        writer.on("finish", resolve);
-        writer.on("error", reject);
-      });
+  const tempTarPath = path.join(getWorkspaceRoot(), `temp_agent_${slug}.tar.gz`);
+  
+  try {
+    const writer = fs.createWriteStream(tempTarPath);
+    response.data.pipe(writer);
 
-      console.log("📦 Extraindo skills para a pasta local...");
-      await tar.x({
-        file: tempTarPath,
-        cwd: getWorkspaceRoot() 
-      });
-      await fs.remove(tempTarPath);
+    await new Promise((resolve, reject) => {
+      writer.on("finish", resolve);
+      writer.on("error", reject);
+    });
 
-      console.log("📥 Baixando ficheiros de código das skills...");
-      const skillsListRes = await axios.get(`${config.goclaw.api_url}/v1/skills`, {
-        headers: { Authorization: `Bearer ${config.goclaw.token}`, "X-GoClaw-User-Id": config.goclaw.username || "system" }
-      });
-      
-      const skills = skillsListRes.data.skills || [];
-      for (const skill of skills) {
-        try {
-          const isSystem = skill.is_system === true;
-          const targetFolder = isSystem ? path.join("system", skill.slug) : skill.slug;
-          
-          if (isSystem) {
-            const originalPath = path.join(getWorkspaceRoot(), "skills", skill.slug);
-            const newPath = path.join(getWorkspaceRoot(), "skills", targetFolder);
-            if (await fs.pathExists(originalPath)) {
-              await fs.ensureDir(path.dirname(newPath));
-              await fs.move(originalPath, newPath, { overwrite: true });
-            }
-          }
+    const agentPath = path.join(getWorkspaceRoot(), "agents", slug);
+    if (await fs.pathExists(agentPath)) {
+      await fs.emptyDir(agentPath);
+    } else {
+      await fs.ensureDir(agentPath);
+    }
 
-          const filesRes = await axios.get(`${config.goclaw.api_url}/v1/skills/${skill.id}/files`, {
-            headers: { Authorization: `Bearer ${config.goclaw.token}`, "X-GoClaw-User-Id": config.goclaw.username || "system" }
-          });
-          
-          const files = filesRes.data.files || [];
-          for (const file of files) {
-            if (file.isDir) continue;
-            const fileContentRes = await axios.get(`${config.goclaw.api_url}/v1/skills/${skill.id}/files/${file.path}`, {
-              headers: { Authorization: `Bearer ${config.goclaw.token}`, "X-GoClaw-User-Id": config.goclaw.username || "system" }
-            });
-            const filePath = path.join(getWorkspaceRoot(), "skills", targetFolder, file.path);
-            await fs.ensureDir(path.dirname(filePath));
-            await fs.writeFile(filePath, fileContentRes.data.content || "");
-          }
-        } catch (fileErr: any) {
-          console.warn(`⚠️ Não foi possível transferir os ficheiros da skill ${skill.slug}: ${fileErr.message}`);
-        }
+    // Obter os caminhos reais (com barras) da API para reverter o flattening do export
+    const docsRes = await axios.get(`${config.goclaw.api_url}/v1/agents/${agentId}/memory/documents`, {
+      headers: { Authorization: `Bearer ${config.goclaw.token}`, "X-GoClaw-User-Id": config.goclaw.username || "system" }
+    });
+    const pathMap: Record<string, string> = {};
+    (docsRes.data || []).forEach((d: any) => {
+      if (d.path) {
+        const flat = d.path.replace(/[\/\\]/g, '_');
+        pathMap[flat] = d.path;
       }
+    });
 
-      // Remover quaisquer skills fantasmas que o tarball tenha extraído (skills apagadas mas ainda no export)
-      const validSlugs = new Set(skills.map((s: any) => s.is_system === true ? path.join("system", s.slug) : s.slug));
-      const skillsDir = path.join(getWorkspaceRoot(), "skills");
-      if (await fs.pathExists(skillsDir)) {
-        const localItems = await fs.readdir(skillsDir);
-        for (const item of localItems) {
-          if (item === "system") {
-            const systemDir = path.join(skillsDir, "system");
-            if (await fs.pathExists(systemDir)) {
-              const systemItems = await fs.readdir(systemDir);
-              for (const sysItem of systemItems) {
-                if (!validSlugs.has(path.join("system", sysItem))) {
-                  await fs.remove(path.join(systemDir, sysItem));
-                }
-              }
-            }
-          } else if (!validSlugs.has(item)) {
-            await fs.remove(path.join(skillsDir, item));
+    await tar.x({
+      file: tempTarPath,
+      cwd: agentPath,
+      strip: 0,
+      filter: (path) => {
+        return path === 'agent.json' || path.startsWith('context_files/');
+      }
+    });
+    
+    const contextDir = path.join(agentPath, "context_files");
+    if (await fs.pathExists(contextDir)) {
+      const contextFiles = await fs.readdir(contextDir);
+      for (const f of contextFiles) {
+        const filePath = path.join(contextDir, f);
+        const stat = await fs.stat(filePath);
+        if (stat.isFile()) {
+          const content = await fs.readFile(filePath, 'utf8');
+          if (content === " " || content === "") {
+            // Fantasma neutralizado pelo nosso script de deploy! Deita fora!
+            await fs.remove(filePath);
+            continue;
           }
         }
-      }
 
-      console.log("✅ Pull concluído com sucesso! As skills foram atualizadas localmente.");
-    } catch (error: any) {
-      console.error("❌ Erro durante o pull das skills:");
-      if (error.response) {
-        console.error(`Status HTTP ${error.response.status}`);
-      } else {
-        console.error(error.message);
+        if (pathMap[f]) {
+          const targetPath = path.join(agentPath, pathMap[f]);
+          await fs.ensureDir(path.dirname(targetPath));
+          await fs.move(filePath, targetPath, { overwrite: true });
+        } else if (f.startsWith('_system_') || f.startsWith('memory_')) {
+          // É um stub de diretório do export do GoClaw (ex: _system_dreaming_) ou um órfão esmagado. Ignoramos.
+          await fs.remove(filePath);
+        } else {
+          await fs.move(filePath, path.join(agentPath, f), { overwrite: true });
+        }
       }
+      await fs.remove(contextDir);
     }
-  });
+  } finally {
+    if (await fs.pathExists(tempTarPath)) {
+      await fs.remove(tempTarPath);
+    }
+  }
+}
 
 pullCmd
   .command("agents")
@@ -699,84 +1018,9 @@ pullCmd
 
       for (const agent of agents) {
         const slug = agent.agent_key;
-        console.log(`📦 Baixando agente: ${slug}...`);
-        
-        const url = `${config.goclaw.api_url}/v1/agents/${agent.id}/export?sections=config,context_files,memory`;
-        const response = await axios.get(url, {
-          headers: { Authorization: `Bearer ${config.goclaw.token}`, "X-GoClaw-User-Id": config.goclaw.username || "system" },
-          responseType: "stream"
-        });
-
-        const tempTarPath = path.join(getWorkspaceRoot(), `temp_agent_${slug}.tar.gz`);
-        
-        try {
-          const writer = fs.createWriteStream(tempTarPath);
-          response.data.pipe(writer);
-
-          await new Promise((resolve, reject) => {
-            writer.on("finish", resolve);
-            writer.on("error", reject);
-          });
-
-          const agentPath = path.join(getWorkspaceRoot(), "agents", slug);
-          await fs.ensureDir(agentPath);
-
-          await tar.x({
-            file: tempTarPath,
-            cwd: agentPath,
-            strip: 0, 
-            filter: (path) => {
-              return path === 'agent.json' || path.startsWith('context_files/') || path.startsWith('memory/') || path === 'MEMORY.md' || path === 'memory.md';
-            }
-          });
-          
-          const contextDir = path.join(agentPath, "context_files");
-          if (await fs.pathExists(contextDir)) {
-            const contextFiles = await fs.readdir(contextDir);
-            for (const f of contextFiles) {
-              await fs.move(path.join(contextDir, f), path.join(agentPath, f), { overwrite: true });
-            }
-            await fs.remove(contextDir);
-          }
-
-          // Reconstruir ficheiros de memória a partir de JSONL
-          const memoryDir = path.join(agentPath, "memory");
-          if (await fs.pathExists(memoryDir)) {
-            const processJsonl = async (filePath: string) => {
-              if (!(await fs.pathExists(filePath))) return;
-              const content = await fs.readFile(filePath, 'utf8');
-              const lines = content.split('\n').filter(l => l.trim());
-              for (const line of lines) {
-                try {
-                  const entry = JSON.parse(line);
-                  if (entry.path && entry.content) {
-                    const targetPath = path.join(agentPath, entry.path);
-                    await fs.ensureDir(path.dirname(targetPath));
-                    await fs.writeFile(targetPath, entry.content);
-                  }
-                } catch (e) {}
-              }
-              await fs.remove(filePath);
-            };
-
-            await processJsonl(path.join(memoryDir, "global.jsonl"));
-            const usersDir = path.join(memoryDir, "users");
-            if (await fs.pathExists(usersDir)) {
-              const userFiles = await fs.readdir(usersDir);
-              for (const uf of userFiles) {
-                if (uf.endsWith(".jsonl")) {
-                  await processJsonl(path.join(usersDir, uf));
-                }
-              }
-              await fs.remove(usersDir);
-            }
-          }
-        } finally {
-          if (await fs.pathExists(tempTarPath)) {
-            await fs.remove(tempTarPath);
-          }
-        }
+        await pullAgent(slug, agent.id, config);
       }
+
       console.log("✅ Pull de agentes concluído com sucesso!");
     } catch (error: any) {
       if (error.response && error.response.status) {
@@ -808,61 +1052,7 @@ pullCmd
     // PULL SKILLS INLINE
     console.log('\n--- [1/2] SKILLS ---');
     try {
-      const url = `${config.goclaw.api_url}${config.goclaw.skills_export_endpoint || '/v1/skills/export'}`;
-      const response = await axios.get(url, {
-        headers: { Authorization: `Bearer ${config.goclaw.token}`, 'X-GoClaw-User-Id': config.goclaw.username || 'system' },
-        responseType: 'stream'
-      });
-
-      const tempTarPath = path.join(getWorkspaceRoot(), 'temp_skills.tar.gz');
-      const writer = fs.createWriteStream(tempTarPath);
-      response.data.pipe(writer);
-
-      await new Promise((resolve, reject) => {
-        writer.on('finish', resolve);
-        writer.on('error', reject);
-      });
-
-      await tar.x({ file: tempTarPath, cwd: getWorkspaceRoot() });
-      await fs.remove(tempTarPath);
-
-      const skillsListRes = await axios.get(`${config.goclaw.api_url}/v1/skills`, {
-        headers: { Authorization: `Bearer ${config.goclaw.token}`, 'X-GoClaw-User-Id': config.goclaw.username || 'system' }
-      });
-      
-      const skills = skillsListRes.data.skills || [];
-      for (const skill of skills) {
-        try {
-          const isSystem = skill.is_system === true;
-          const targetFolder = isSystem ? path.join('system', skill.slug) : skill.slug;
-          
-          if (isSystem) {
-            const originalPath = path.join(getWorkspaceRoot(), 'skills', skill.slug);
-            const newPath = path.join(getWorkspaceRoot(), 'skills', targetFolder);
-            if (await fs.pathExists(originalPath)) {
-              await fs.ensureDir(path.dirname(newPath));
-              await fs.move(originalPath, newPath, { overwrite: true });
-            }
-          }
-
-          const filesRes = await axios.get(`${config.goclaw.api_url}/v1/skills/${skill.id}/files`, {
-            headers: { Authorization: `Bearer ${config.goclaw.token}`, 'X-GoClaw-User-Id': config.goclaw.username || 'system' }
-          });
-          
-          const files = filesRes.data.files || [];
-          for (const file of files) {
-            if (file.isDir) continue;
-            const fileContentRes = await axios.get(`${config.goclaw.api_url}/v1/skills/${skill.id}/files/${file.path}`, {
-              headers: { Authorization: `Bearer ${config.goclaw.token}`, 'X-GoClaw-User-Id': config.goclaw.username || 'system' }
-            });
-            const filePath = path.join(getWorkspaceRoot(), 'skills', targetFolder, file.path);
-            await fs.ensureDir(path.dirname(filePath));
-            await fs.writeFile(filePath, fileContentRes.data.content || '');
-          }
-        } catch (fileErr: any) {
-          console.warn(`⚠️ Não foi possível transferir os ficheiros da skill ${skill.slug}: ${fileErr.message}`);
-        }
-      }
+      await pullAllSkills(config);
       console.log('✅ Pull de skills concluído!');
     } catch (error: any) {
       console.error('❌ Erro durante o pull das skills:', error.message);
@@ -880,50 +1070,7 @@ pullCmd
 
       for (const agent of agents) {
         const slug = agent.agent_key;
-        console.log(`📦 Baixando agente: ${slug}...`);
-        
-        const url = `${config.goclaw.api_url}/v1/agents/${agent.id}/export`;
-        const response = await axios.get(url, {
-          headers: { Authorization: `Bearer ${config.goclaw.token}`, 'X-GoClaw-User-Id': config.goclaw.username || 'system' },
-          responseType: 'stream'
-        });
-
-        const tempTarPath = path.join(getWorkspaceRoot(), `temp_agent_${slug}.tar.gz`);
-        
-        try {
-          const writer = fs.createWriteStream(tempTarPath);
-          response.data.pipe(writer);
-
-          await new Promise((resolve, reject) => {
-            writer.on('finish', resolve);
-            writer.on('error', reject);
-          });
-
-          const agentPath = path.join(getWorkspaceRoot(), 'agents', slug);
-          await fs.ensureDir(agentPath);
-
-          await tar.x({
-            file: tempTarPath,
-            cwd: agentPath,
-            strip: 0, 
-            filter: (path) => {
-              return path === 'agent.json' || path.startsWith('context_files/');
-            }
-          });
-          
-          const contextDir = path.join(agentPath, 'context_files');
-          if (await fs.pathExists(contextDir)) {
-            const contextFiles = await fs.readdir(contextDir);
-            for (const f of contextFiles) {
-              await fs.move(path.join(contextDir, f), path.join(agentPath, f), { overwrite: true });
-            }
-            await fs.remove(contextDir);
-          }
-        } finally {
-          if (await fs.pathExists(tempTarPath)) {
-            await fs.remove(tempTarPath);
-          }
-        }
+        await pullAgent(slug, agent.id, config);
       }
       console.log('✅ Pull de agentes concluído!');
     } catch (error: any) {