@danhachuel/thunderbolt 0.2.50 → 0.2.52

package/MANUAL-INSTALACAO.md

@@ -2,7 +2,7 @@
 
 Este manual descreve a instalação local da UI Thunderbolt, baseada no MoneyPrinterTurbo, utilizando o pacote npm `@danhachuel/thunderbolt`. O fluxo recomendado instala automaticamente o ambiente Python, as dependências da aplicação, as dependências do MoneyPrinterTurbo, o Streamlit e o suporte FFmpeg através de `imageio-ffmpeg`.
 
-> **Versão deste manual:** 0.2.50
+> **Versão deste manual:** 0.2.52
 > **Pacote npm:** `@danhachuel/thunderbolt`
 > **Porta padrão da UI:** `localhost:3030`  
 > **Repositório:** [github.com/DanHachuel/thunderbolt](https://github.com/DanHachuel/thunderbolt)
@@ -100,13 +100,13 @@ Execute:
 Windows PowerShell ou MobaXterm:
 
 ```powershell
-npx.cmd --yes @danhachuel/thunderbolt@0.2.50 install
+npx.cmd --yes @danhachuel/thunderbolt@0.2.52 install
 ```
 
 Linux/macOS:
 
 ```bash
-npx --yes @danhachuel/thunderbolt@0.2.50 install
+npx --yes @danhachuel/thunderbolt@0.2.52 install
 ```
 
 A instalação normal é **segura para actualizações**: preserva `storage`, Blueprints, Brandings, configurações e artefactos do utilizador. Remove apenas `.venv`, o clone técnico do MoneyPrinterTurbo e dependências que serão recriadas. Uma pasta antiga sem dados do utilizador, como `C:\Users\<utilizador>\AppData\Local\hermes` da tentativa incompleta, pode ser removida; uma pasta antiga que contenha Blueprints, Brandings ou storage é preservada e apenas avisada no terminal. Feche processos Python, Node, Streamlit e MobaXterm que estejam a usar as pastas antes de executar.
@@ -396,12 +396,21 @@ Após iniciar a aplicação, valide o seguinte percurso:
 11. **Configurações > Configurações Técnicas:** confirme que os caminhos e credenciais estão locais e não aparecem no Git. Na secção **Contas Google/YouTube — canais em lote**, adicione cada conta com o seu e-mail/Gmail, OAuth Client ID, OAuth Client Secret e `sessionInfo` próprios; use **Repetir campos para nova conta** para preparar contas adicionais e o ícone **Apagar conta** para eliminar individualmente a conta, tokens, documento JSON e associações de canais.
 12. **OpenAI/ NVIDIA NIM:** em **LLM — providers e modelos**, seleccione `openai`, confirme a Base URL, introduza a API key e clique em **Consultar/actualizar modelos NIM**. Escolha um modelo da lista ou utilize o fallback manual e guarde as configurações. Confirme que a consulta só ocorre após o clique e que um erro de endpoint não interrompe a UI.
 13. **Criação de Vídeos:** confirme que `Pexels/Pixabay` substitui o label antigo, que `Estilo IA` aparece apenas em `full_ia` e que `Apenas Música` exige áudio e guarda `background_mode=none`.
-14. **Automação:** no cartão de cada canal, escolha o **Blueprint padrão** e a **Voz padrão**, clique em `Guardar` e confirme que o resumo do cartão se actualiza. Configure também **Automação ON** e um horário `HH:MM`; confirme a lista de vídeos cadastrados. Os mesmos defaults aparecem em **Canais** e são usados em novas tarefas. Inicie o Thunderbolt pelo launcher, confirme o aviso verde **Worker activo** e verifique que o relógio apresentado corresponde ao computador. O worker cria no máximo um lote por canal por dia quando o horário local coincide.
-15. **Configurações > Configurações Técnicas > Teste de vozes:** teste Edge/Azure ou provider configurado e confirme reprodução/download sem criação de tarefa.
-16. **Upload directo:** em **Configurações > Configurações Técnicas > Contas Google/YouTube — canais em lote**, cada cartão Gmail apresenta o uploader **Documento de credenciais desta conta Google** e o campo **sessionInfo token desta conta Google**. O sessionInfo é guardado por conta e sincronizado no documento JSON, que reúne `SID`, `SSID`, `HSID`, `APISID`, `INNERTUBE_API_KEY`, `chunk_size` e `delegated_session_ids` por canal. Use **Repetir campos para nova conta** para preencher o formulário seguinte e o ícone **Apagar conta** para remover a conta e os dados privados associados. Em **Canais > Canais cadastrados**, associe cada canal à conta Google do documento; a UI não mostra nem edita o `DELEGATED_SESSION_ID`. O documento é guardado em `storage/youtube_direct_accounts/<id-da-conta>/credentials.json`, e o uploader lê os valores directos exclusivamente desse documento. Não existem campos técnicos de cookies, INNERTUBE_API_KEY, chunk_size ou DELEGATED_SESSION_ID na parte inferior da UI e o método não extrai cookies automaticamente do navegador.
-17. **Configurações > MCP > Client MCP:** confirme que Short Video Maker, AutoVio, OpenMontage e OpenCut aparecem com as portas padrão editáveis. O estado **Activo** é uma preferência local; a detecção deve indicar **Não detectado** quando os serviços externos não estiverem instalados ou iniciados.
-18. **Configurações > MCP > Servidor MCP:** abra a subaba, mantenha o host `127.0.0.1`, active **Servidor MCP ON** e clique em **Guardar e iniciar Servidor MCP**. Confirme o endpoint `/mcp` e o health endpoint `/health`. Mantenha **Permitir ferramentas de escrita** desactivado até precisar que um agente crie lotes.
-19. **Configurações > MCP > Skill:** clique em **Guardar skill localmente** e confirme o ficheiro em `storage/skills/moneyprinterturbo-video.md`; opcionalmente use **Descarregar skill .md** para obter a cópia através do navegador.
+14. **Canais:** abra **Configurações > Canais**, clique em **Editar** num cartão, altere o nicho, Blueprint/Prompts do Canal, Narrador/Voz padrão e horário, guarde e confirme que o cartão é actualizado sem duplicar o canal. Clique em **Actualizar últimos 10 vídeos**, valide a vista Lista, mude para Kanban e abra **Editar vídeo** para testar título, estado, data, URL e notas.
+15. **Automação:** no cartão de cada canal, escolha o **Blueprint padrão** e a **Voz padrão**, clique em `Guardar` e confirme que o resumo do cartão se actualiza. Configure também **Automação ON** e um horário `HH:MM`; confirme a lista de vídeos cadastrados. Os mesmos defaults aparecem em **Canais** e são usados em novas tarefas. Inicie o Thunderbolt pelo launcher, confirme o aviso verde **Worker activo** e verifique que o relógio apresentado corresponde ao computador. O worker cria no máximo um lote por canal por dia quando o horário local coincide.
+16. **Configurações > Configurações Técnicas > Teste de vozes:** teste Edge/Azure ou provider configurado e confirme reprodução/download sem criação de tarefa.
+17. **Upload directo:** em **Configurações > Configurações Técnicas > Contas Google/YouTube — canais em lote**, cada cartão Gmail apresenta o uploader **Documento de credenciais desta conta Google** e o campo **sessionInfo token desta conta Google**. O sessionInfo é guardado por conta e sincronizado no documento JSON, que reúne `SID`, `SSID`, `HSID`, `APISID`, `INNERTUBE_API_KEY`, `chunk_size` e `delegated_session_ids` por canal. Use **Repetir campos para nova conta** para preencher o formulário seguinte e o ícone **Apagar conta** para remover a conta e os dados privados associados. Em **Canais > Canais cadastrados**, associe cada canal à conta Google do documento; a UI não mostra nem edita o `DELEGATED_SESSION_ID`. O documento é guardado em `storage/youtube_direct_accounts/<id-da-conta>/credentials.json`, e o uploader lê os valores directos exclusivamente desse documento. Não existem campos técnicos de cookies, INNERTUBE_API_KEY, chunk_size ou DELEGATED_SESSION_ID na parte inferior da UI e o método não extrai cookies automaticamente do navegador.
+18. **Configurações > MCP > Client MCP:** confirme que Short Video Maker, AutoVio, OpenMontage e OpenCut aparecem com as portas padrão editáveis. O estado **Activo** é uma preferência local; a detecção deve indicar **Não detectado** quando os serviços externos não estiverem instalados ou iniciados.
+19. **Configurações > MCP > Servidor MCP:** abra a subaba, mantenha o host `127.0.0.1`, active **Servidor MCP ON** e clique em **Guardar e iniciar Servidor MCP**. Confirme o endpoint `/mcp` e o health endpoint `/health`. Mantenha **Permitir ferramentas de escrita** desactivado até precisar que um agente crie lotes.
+20. **Configurações > MCP > Skill:** clique em **Guardar skill localmente** e confirme o ficheiro em `storage/skills/moneyprinterturbo-video.md`; opcionalmente use **Descarregar skill .md** para obter a cópia através do navegador.
+
+## Gestão de Canais, edição e vídeos recentes
+
+Na página **Configurações > Canais**, cada canal cadastrado aparece num cartão com o botão **Editar**. O editor permite alterar o nome, URL, handle, idioma, estilo wide, **Canais de Referência / Nicho**, **Prompts do Canal** (Blueprint padrão), **Narrador** (Voz padrão), conta Google do Upload directo, descrição e Automação ON/horário. Guardar alterações actualiza o mesmo registo local; não é necessário apagar e criar o canal novamente.
+
+O cartão mostra o nicho ou Canais de Referência imediatamente abaixo do nome. Os três blocos de gestão usam os rótulos **Prompts do Canal**, **Canais de Referência** e **Narrador**, com botões que abrem o editor do próprio canal.
+
+A secção **Últimos 10 vídeos publicados** fica abaixo das configurações do canal e não dentro de Criação de Vídeos. Clique em **Actualizar últimos 10 vídeos** para consultar o feed RSS público do YouTube sem Data API Key. Os resultados são guardados em `storage/state/channel_videos.json`. A vista **Lista** apresenta título, data, URL, estado e botão **Editar vídeo**; a vista **Kanban** separa Planejamento, Produção, Finalizado e Agendado/Publicado. A edição local permite alterar título, estado, data, URL e notas. Essas alterações são overrides de gestão local e não publicam automaticamente no YouTube.
 
 ## Canais em lote por conta Google/YouTube
 
@@ -419,7 +428,7 @@ Ao abrir a página, o Thunderbolt não prepara dados públicos, não descarrega
 
 Os parâmetros da UI são número de clusters entre 2 e 10, suporte mínimo entre 0,01 e 0,50, país, engagement, intervalo de datas e tags, todos dentro da área principal da aba. O núcleo normaliza os dados, calcula engagement, aplica filtros, faz transformação logarítmica e standardização, executa K-Means e calcula itemsets/regras com FP-Growth. Não são apresentados resultados até ao primeiro clique em **Analisar Nichos**; o mesmo botão aplica alterações posteriores aos filtros. Os resultados são DataFrames de clusters, itemsets frequentes, regras de associação e dados analisados; o gráfico de dispersão é criado nativamente com Plotly.
 
-As dependências adicionais — `scikit-learn`, `mlxtend`, `plotly`, `seaborn`, `matplotlib` e `kagglehub` — são instaladas pelo procedimento normal de `npx`. Em instalações existentes, execute novamente `npx.cmd --yes @danhachuel/thunderbolt@0.2.50 install`; o instalador detecta e reutiliza o que já estiver válido.
+As dependências adicionais — `scikit-learn`, `mlxtend`, `plotly`, `seaborn`, `matplotlib` e `kagglehub` — são instaladas pelo procedimento normal de `npx`. Em instalações existentes, execute novamente `npx.cmd --yes @danhachuel/thunderbolt@0.2.52 install`; o instalador detecta e reutiliza o que já estiver válido.
 
 ### Niche Finder Apify
 
@@ -457,13 +466,13 @@ A área **Teste de vozes**, dentro de **Configurações > Configurações Técni
 
 ## Upload directo
 
-Em **Configurações > Configurações Técnicas > Contas Google/YouTube — canais em lote**, cada cartão Gmail mostra o uploader **Documento de credenciais desta conta Google** e o input **sessionInfo token desta conta Google**. O documento JSON único contém cookies, INNERTUBE_API_KEY, chunk_size e o mapa de IDs delegados por canal; o sessionInfo preenchido na conta é sincronizado no mesmo ficheiro, guardado em `storage/youtube_direct_accounts/<id-da-conta>/credentials.json`.
+Em **Configurações > Configurações Técnicas > Contas Google/YouTube — canais em lote**, cada conta aparece como um expander identificado por nome e e-mail. Dentro dele existe o uploader **Subir documento de cookies/credenciais** e o input **sessionInfo token desta conta Google**. O documento JSON único contém cookies, INNERTUBE_API_KEY, chunk_size e o mapa de IDs delegados por canal; o sessionInfo preenchido na conta é sincronizado no mesmo ficheiro, guardado em `storage/youtube_direct_accounts/<id-da-conta>/credentials.json`.
 
 Em **Canais > Canais cadastrados**, a secção **Upload directo — documento da conta deste canal** mostra apenas a conta Google associada e confirma se o documento contém o ID delegado desse canal. O `DELEGATED_SESSION_ID` permanece exclusivamente no mapa do documento; o upload bloqueia a operação se faltar qualquer elemento técnico.
 
-A subaba **Upload directo** adapta o [YouTube-Video-Upload-Frontend-Api](https://github.com/Nojus10/YouTube-Video-Upload-Frontend-Api). Cada conta Google tem um único `credentials.json`, com cookies, sessionInfo, INNERTUBE_API_KEY, chunk_size e `delegated_session_ids` por canal. O parser aceita o documento JSON completo, valida os cinco cookies obrigatórios e grava-o fora de `storage/state/`, com permissões locais restritas.
+A subaba **Upload directo** adapta o [YouTube-Video-Upload-Frontend-Api](https://github.com/Nojus10/YouTube-Video-Upload-Frontend-Api). Cada conta Google tem um único `credentials.json`, criado automaticamente ao adicionar a conta, com cookies, sessionInfo, INNERTUBE_API_KEY, chunk_size e `delegated_session_ids` por canal. O uploader aceita um documento JSON completo ou parcial; o merge actualiza somente os valores presentes e preserva os restantes. O documento é guardado fora de `storage/state/`, com permissões locais restritas.
 
-Associe cada canal à conta Google correcta em **Canais**; não introduza o ID delegado na UI. No momento do upload, o Thunderbolt lê o documento da conta, encontra o `DELEGATED_SESSION_ID` pela chave do canal e bloqueia a operação se faltar conta, documento válido, cookies, sessionInfo, INNERTUBE_API_KEY, ID delegado ou vídeo elegível. O tamanho de chunk é normalizado para múltiplos de 262144 bytes. O método é uma integração não oficial de sessão do YouTube; não extraia cookies automaticamente, não os coloque no repositório e não os partilhe.
+Associe cada canal à conta Google correcta em **Canais**; não introduza o ID delegado na UI. A associação do canal é permitida mesmo que o documento esteja incompleto. No momento do upload, o Thunderbolt lê o documento da conta, encontra o `DELEGATED_SESSION_ID` pela chave do canal e bloqueia apenas a operação se faltar conta, documento válido, cookies, sessionInfo, INNERTUBE_API_KEY, ID delegado ou vídeo elegível. O tamanho de chunk é normalizado para múltiplos de 262144 bytes. O método é uma integração não oficial de sessão do YouTube; não extraia cookies automaticamente, não os coloque no repositório e não os partilhe.
 
 ## MCP e integrações externas
 

package/README.md

@@ -14,7 +14,7 @@ A primeira versão implementa a camada UI independente com:
 | Pipeline | Menu expansível com Criação de Vídeos, Criação de Músicas e Upload |
 | Blueprints | Leitura da pasta `storage/blueprints/`, upload/validação de JSON e criação a partir de link YouTube |
 | Brandings | Subaba própria dentro de Blueprints, upload/listagem de Brandings e criação conjunta com Blueprint |
-| Canais | Subabas de importação pública sem API Key, Canais em lote gmail por conta Google/YouTube via OAuth e cadastro manual independente |
+| Canais | Subabas de importação pública sem API Key, Canais em lote gmail por conta Google/YouTube via OAuth e cadastro manual independente; cartões com botão Editar, nicho/referências visível, Prompts do Canal/Blueprint, Narrador/voz e gestão dos últimos 10 vídeos |
 | Criação de Vídeos / Criação de Músicas | Subabas Criar vídeo e Vídeos; lotes; 51 rótulos de idioma; Pexels/Pixabay, full IA com Estilo IA e Apenas Música com agente musical; a segunda página reutiliza o mesmo fluxo com título próprio |
 | Automação | Lista de vídeos e canais, selectores editáveis de Blueprint/voz padrão, Automação ON, horário diário HH:MM e worker local baseado no relógio do computador |
 | Models AI | Menu expansível com Personagens e Redes Sociais reservados para desenvolvimento futuro |
@@ -22,25 +22,35 @@ A primeira versão implementa a camada UI independente com:
 | Edição | Menu expansível abaixo de Automação com Limpador de Metadados funcional, Cortes reservado e Editor Python inspirado no PYEdit para vídeos e scripts locais |
 | Upload | YouTube via `youtube-automation-agent` adaptado internamente, OAuth directo de redundância, Upload directo via sessão Frontend API com cookies/sessionInfo por conta e DELEGATED_SESSION_ID por canal, TikTok, Instagram e Facebook Pages no front end |
 | MCP | Catálogo local opcional de Short Video Maker, AutoVio, OpenMontage e OpenCut, com portas editáveis e activação |
-| Configurações Técnicas | Provedores LLM, OpenAI/NVIDIA NIM com API key, Base URL e selector de modelos, TTS/voz, preview de vozes, Suno, materiais, Whisper, FFmpeg, OAuth YouTube, contas Google/YouTube para canais em lote com e-mail, Client ID, Client Secret e sessionInfo por conta, repetição dos campos para novas contas, eliminação individual e diagnóstico da URI OAuth, cookies SID/SSID/HSID/APISID/SAPISID no documento JSON, Data API Key opcional, Kaggle Username/API Key, Apify API Token/Actor ID/limites, Upload directo, TikTok Client ID/Secret e Upload-Post |
+| Configurações Técnicas | Provedores LLM, OpenAI/NVIDIA NIM com API key, Base URL e selector de modelos, TTS/voz, preview de vozes, Suno, materiais, Whisper, FFmpeg, OAuth YouTube, contas Google/YouTube para canais em lote com e-mail, Client ID, Client Secret e sessionInfo por conta, cartões expansíveis por nome/e-mail, documento credentials.json criado automaticamente e eliminação individual, cookies SID/SSID/HSID/APISID/SAPISID no documento JSON, Data API Key opcional, Kaggle Username/API Key, Apify API Token/Actor ID/limites, Upload directo, TikTok Client ID/Secret e Upload-Post |
 | Launcher | Execução via `npx`, instalação assistida, diagnóstico e preparação para distribuição |
 
 ## Upload directo — credenciais por conta e por canal
 
-O Upload directo baseado no [YouTube-Video-Upload-Frontend-Api](https://github.com/Nojus10/YouTube-Video-Upload-Frontend-Api) usa um único documento JSON por conta Google. Em **Configurações Técnicas > Contas Google/YouTube — canais em lote**, cada cartão Gmail possui o uploader **Documento de credenciais desta conta Google** e o campo específico **sessionInfo token desta conta Google**. O token é guardado por conta e sincronizado no `credentials.json`; o documento continua a reunir `SID`, `SSID`, `HSID`, `APISID`, `INNERTUBE_API_KEY`, `chunk_size` e o mapa `delegated_session_ids` por canal. A UI não contém inputs separados para cookies, INNERTUBE_API_KEY, chunk_size ou DELEGATED_SESSION_ID. O botão **Repetir campos para nova conta** preenche o formulário seguinte com os valores da conta actual, e **Apagar conta** remove a conta, o token OAuth, o documento de credenciais e as associações de canais.
+O Upload directo baseado no [YouTube-Video-Upload-Frontend-Api](https://github.com/Nojus10/YouTube-Video-Upload-Frontend-Api) usa um único documento JSON por conta Google. Em **Configurações Técnicas > Contas Google/YouTube — canais em lote**, cada conta aparece como um cartão expansível identificado por **nome — e-mail**. Dentro do cartão existe o uploader **Subir documento de cookies/credenciais** e o único campo técnico permitido na UI, **sessionInfo token desta conta Google**. Cookies, `INNERTUBE_API_KEY`, `chunk_size` e `delegated_session_ids` continuam exclusivamente no documento.
 
-O documento é validado e guardado por Gmail em `storage/youtube_direct_accounts/<id-da-conta>/credentials.json`, com permissões locais restritas. Em **Canais > Canais cadastrados**, a UI apenas associa o canal à conta Google do documento; não mostra nem edita o `DELEGATED_SESSION_ID`. O uploader procura o ID do canal dentro do mapa `delegated_session_ids` do documento e usa-o como `pageId`/`onBehalfOfUser`. O Upload directo fica bloqueado quando faltar qualquer elemento no documento. Não existem campos técnicos do Upload directo na parte inferior de Configurações Técnicas.
+O botão **Adicionar outra conta Gmail** fica abaixo de uma divisória, fora dos cartões existentes. Ao criar uma conta, o Thunderbolt cria imediatamente `credentials.json` com placeholders vazios. Um upload completo ou parcial é incorporado por merge: os cookies enviados actualizam apenas os cookies fornecidos e valores como `sessionInfo`, `INNERTUBE_API_KEY`, `chunk_size` e `delegated_session_ids` existentes não são apagados. O alerta **Documento incompleto: SID, SSID, HSID, APISID, SAPISID, sessionInfo, INNERTUBE_API_KEY** permanece visível por conta quando necessário.
+
+O documento é guardado por Gmail em `storage/youtube_direct_accounts/<id-da-conta>/credentials.json`, com permissões locais restritas. Em **Canais > Canais cadastrados**, a UI apenas associa o canal à conta Google; essa associação continua permitida mesmo quando o documento está incompleto. O uploader procura o ID do canal dentro do mapa `delegated_session_ids` do documento e usa-o como `pageId`/`onBehalfOfUser`; só a operação de Upload directo é bloqueada quando faltarem os dados técnicos. Não existem campos separados de cookies, INNERTUBE_API_KEY, chunk_size ou DELEGATED_SESSION_ID na UI.
 
 Os dados são segredos de sessão. Os valores não aparecem em tabelas ou logs, o ficheiro é escrito com permissões locais restritas e não é incluído no Git. O Thunderbolt não extrai cookies automaticamente do browser e não envia as credenciais para o GitHub. O método é não oficial e pode deixar de funcionar se o YouTube alterar os endpoints internos.
 
 
 Os adaptadores do MoneyPrinterTurbo e de publicação nas plataformas são ligados pelas configurações locais e pelos pontos de integração em `integrations/`. A UI não inventa dados quando um serviço externo ou credencial não está disponível.
 
-## Navegação da UI 0.2.50
+## Navegação da UI 0.2.52
 
 A barra lateral mantém os níveis principais, nesta ordem: **Início**, **Niche Finder**, **Pipeline**, **Automação**, **Edição**, **Models AI** e **Configurações**. **Pipeline** é expansível e contém **Criação de Vídeos**, **Criação de Músicas** e **Upload**. **Edição** é expansível e contém **Limpador de Metadados**, **Cortes** e **Editor Python**, nessa ordem. **Models AI** é expansível e contém **Personagens** e **Redes Sociais**, nessa ordem. **Niche Finder** é expansível e contém **Niche Finder Kaggle** e **Niche Finder Apify**. **Configurações** é expansível e contém **Canais**, **Blueprints**, **MCP** e **Configurações Técnicas**. O Início reúne o dashboard e as filas do Pipeline, sem botões de acções rápidas.
 
-Dentro de **Configurações Técnicas**, a UI está organizada em três subabas, sem numeração visível: **Contas Google/YouTube — canais em lote**, **API Keys** e **Teste de vozes**. A primeira contém contas Google, sessionInfo e documentos de Upload directo; **API Keys** reúne execução local, OAuth, LLM, TTS, materiais e restantes credenciais; **Teste de vozes** contém exclusivamente o preview de áudio.
+Dentro de **Configurações Técnicas**, a UI está organizada em três subabas, sem numeração visível: **Contas Google/YouTube — canais em lote**, **API Keys** e **Teste de vozes**. A primeira contém cartões expansíveis de contas Google, sessionInfo e documentos de Upload directo; o formulário **Adicionar outra conta Gmail** fica fora dos cartões. **API Keys** reúne execução local, OAuth, LLM, TTS, materiais e restantes credenciais; **Teste de vozes** contém exclusivamente o preview de áudio.
+
+## Canais — edição por cartão e vídeos recentes
+
+A página **Canais** mantém o cadastro e a importação existentes, mas cada cartão agora tem o botão **Editar**. O editor permite alterar nome, URL, handle, idioma, estilo wide, **Canais de Referência / Nicho**, **Prompts do Canal** (Blueprint padrão), **Narrador** (voz padrão), conta Google do Upload directo, descrição e Automação ON/horário. O nicho aparece imediatamente abaixo do nome do canal no cartão; quando não existe, a UI mostra **SEM NICHO CONFIGURADO**.
+
+Os blocos do cartão usam a nomenclatura solicitada: **Prompts do Canal**, **Canais de Referência** e **Narrador**. Os botões de acção abrem o mesmo editor persistente, sem criar um segundo canal nem perder as associações existentes.
+
+Abaixo do cartão, a secção **Últimos 10 vídeos publicados** usa o feed público RSS do YouTube, sem Data API Key. O carregamento ocorre quando se clica em **Actualizar últimos 10 vídeos**, evitando chamadas automáticas ao abrir a página. Os vídeos ficam guardados em `storage/state/channel_videos.json` e podem ser apresentados em **Lista** ou **Kanban**, nos grupos Planejamento, Produção, Finalizado e Agendado/Publicado. Cada vídeo tem **Editar vídeo** para alterar localmente o título, estado, data, URL e notas. A fonte pública não substitui o vídeo nem publica alterações no YouTube; os campos editáveis são overrides locais de gestão.
 
 ## Criação de Vídeos — geração editorial por canal
 
@@ -64,7 +74,7 @@ A consulta só é executada quando o utilizador carrega no botão; a aplicação
 
 Para autorizar uma conta, use no Google Cloud um cliente OAuth do tipo **Desktop app**. O Thunderbolt usa o loopback local determinístico `http://127.0.0.1:8765/`, abre o browser e guarda o token por conta. Se estiver a usar um cliente do tipo Web application, adicione exactamente essa URI em **Google Cloud > APIs e serviços > Credenciais > URIs de redireccionamento autorizados**; a URI deve incluir a porta e a barra final. O erro `400: redirect_uri_mismatch` significa que a URI registada no cliente Google não coincide exactamente com a enviada pela aplicação.
 
-A área **Contas Google/YouTube — canais em lote** permite manter várias contas. Cada cartão tem e-mail, OAuth Client ID, OAuth Client Secret, sessionInfo e documento de Upload directo. Use **Repetir campos para nova conta** para preparar rapidamente outra conta, ou **Apagar conta** para remover a conta, os tokens e os dados directos associados. O sessionInfo é sincronizado com o documento JSON da própria conta; cookies e os restantes parâmetros de Upload directo permanecem apenas nesse documento.
+A área **Contas Google/YouTube — canais em lote** permite manter várias contas em cartões expansíveis com nome e e-mail. Cada cartão tem OAuth Client ID, OAuth Client Secret, sessionInfo e documento de Upload directo; o formulário separado **Adicionar outra conta Gmail** cria o documento padrão automaticamente. Use **Apagar conta** para remover a conta, os tokens e os dados directos associados. O sessionInfo é sincronizado com o documento JSON da própria conta; cookies e os restantes parâmetros de Upload directo permanecem apenas nesse documento.
 
 ## Instalação
 

package/app/main.py

@@ -20,7 +20,7 @@ try:
 except (OSError, json.JSONDecodeError):
     APP_VERSION = ""
 
-from hermes_ui.domain import STAGES, create_batch, create_channel, create_tasks_for_batch, delete_channel, pipeline_summary, set_channel_defaults, transition_task, update_channel
+from hermes_ui.domain import STAGES, create_batch, create_channel, create_tasks_for_batch, delete_channel, pipeline_summary, set_channel_defaults, transition_task, update_channel, update_channel_video
 from hermes_ui.automation_worker import load_worker_status
 from hermes_ui.storage import BLUEPRINTS, STORAGE, ensure_storage, list_blueprint_files, load_blueprint_file, now, read_json, write_json
 from app.modules.niche_finder.apify import ApifyError, DEFAULT_ACTOR_ID, abort_actor_run, build_actor_input, get_dataset_items, normalize_video_items, start_actor_run, wait_for_actor_run
@@ -35,9 +35,9 @@ from hermes_ui.mcp_server import server_status, start_server, stop_server
 from hermes_ui.music import list_music_files, materialize_suno_audio, request_suno_generation, store_music_file
 from hermes_ui.voice_preview import DEFAULT_SAMPLE, load_preview_file, synthesize_preview
 from hermes_ui.creative_generation import CreativeGenerationError, generate_creative_package, generate_topic_for_channel
-from integrations.platforms import IntegrationResult, TikTokAdapter, YouTubeAdapter
+from integrations.platforms import IntegrationResult, TikTokAdapter, YouTubeAdapter, fetch_channel_videos_public
 from integrations.youtube_direct_upload import YouTubeDirectUploader
-from integrations.youtube_direct_credentials import delete_credentials_document, direct_account_status, document_status, parse_credentials_document, save_credentials_document, update_credentials_document_session_info
+from integrations.youtube_direct_credentials import delete_credentials_document, direct_account_status, document_status, ensure_credentials_document, merge_credentials_document, parse_credentials_document, save_credentials_document, update_credentials_document_session_info
 from integrations.youtube_batch import account_key as youtube_batch_account_key, account_status as youtube_batch_account_status, authorize_account as authorize_youtube_batch_account, delete_account_token as delete_youtube_batch_token, list_my_channels as list_youtube_batch_channels, loopback_redirect_uri
 from integrations.local_runtime import MoneyPrinterRuntime
 from integrations.moneyprinter_config import sync_moneyprinter_config
@@ -300,6 +300,172 @@ def channel_default_options(channel: dict) -> tuple[list[str], dict[str, str], s
     return blueprint_ids, blueprint_labels, current_blueprint, voice_options, current_voice
 
 
+def channel_niche_label(channel: dict) -> str:
+    """Return the channel niche/reference label shown under the channel name."""
+    niche = str(channel.get("niche") or "").strip()
+    if niche:
+        return niche
+    references = channel.get("reference_channels")
+    if isinstance(references, list):
+        values = [str(item).strip() for item in references if str(item).strip()]
+        if values:
+            return ", ".join(values)
+    blueprint = blueprint_for_channel(channel)
+    metadata = blueprint.get("metadata") if isinstance(blueprint.get("metadata"), dict) else {}
+    return str(blueprint.get("target_niche") or blueprint.get("niche") or metadata.get("target_niche") or metadata.get("niche") or "SEM NICHO CONFIGURADO").strip()
+
+
+def _merge_channel_videos(channel_id: str, videos: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    existing = read_json("channel_videos.json", [])
+    if not isinstance(existing, list):
+        existing = []
+    other_channels = [item for item in existing if isinstance(item, dict) and str(item.get("channel_id")) != str(channel_id)]
+    current_by_id = {str(item.get("id")): item for item in existing if isinstance(item, dict) and str(item.get("channel_id")) == str(channel_id)}
+    merged: list[dict[str, Any]] = []
+    for video in videos:
+        item = dict(current_by_id.get(str(video.get("id")), {}))
+        item.update(video)
+        item["channel_id"] = str(channel_id)
+        item.setdefault("status", "publicado")
+        merged.append(item)
+    write_json("channel_videos.json", other_channels + merged)
+    return merged
+
+
+def channel_videos_for(channel: dict, limit: int = 10) -> list[dict[str, Any]]:
+    channel_id = str(channel.get("id") or "")
+    stored = read_json("channel_videos.json", [])
+    videos = [item for item in stored if isinstance(item, dict) and str(item.get("channel_id")) == channel_id]
+    videos.sort(key=lambda item: str(item.get("published_at") or item.get("created_at") or ""), reverse=True)
+    return videos[:limit]
+
+
+def render_channel_video_editor(video: dict, channel_id: str) -> None:
+    video_id = str(video.get("id") or "")
+    edit_key = f"channel_video_edit_{video_id}"
+    if st.button("Editar vídeo", key=f"edit_channel_video_{video_id}", use_container_width=True):
+        st.session_state[edit_key] = True
+        st.rerun()
+    if st.session_state.get(edit_key):
+        with st.form(f"channel_video_form_{video_id}"):
+            edited_title = st.text_input("Título", value=str(video.get("title") or ""))
+            edited_status = st.selectbox("Estado", ["planejamento", "produção", "finalizado", "agendado", "publicado"], index=["planejamento", "produção", "finalizado", "agendado", "publicado"].index(str(video.get("status") or "publicado")) if str(video.get("status") or "publicado") in {"planejamento", "produção", "finalizado", "agendado", "publicado"} else 4)
+            edited_date = st.text_input("Data de publicação", value=str(video.get("published_at") or ""))
+            edited_url = st.text_input("URL", value=str(video.get("url") or ""))
+            edited_notes = st.text_area("Notas", value=str(video.get("notes") or ""), height=80)
+            save_video = st.form_submit_button("Guardar alteração", type="primary")
+        if save_video:
+            update_channel_video(video_id, {"title": edited_title.strip(), "status": edited_status, "published_at": edited_date.strip(), "url": edited_url.strip(), "notes": edited_notes.strip()})
+            st.session_state.pop(edit_key, None)
+            st.success("Vídeo actualizado.")
+            st.rerun()
+
+
+def render_channel_videos(channel: dict) -> None:
+    channel_id = str(channel.get("id") or "")
+    st.markdown("### Últimos 10 vídeos publicados")
+    st.caption("A lista usa o feed público do YouTube, sem Data API Key. Pode actualizar manualmente e editar os metadados locais apresentados.")
+    refresh_col, view_col = st.columns([1.4, 1])
+    with refresh_col:
+        if st.button("Actualizar últimos 10 vídeos", key=f"refresh_channel_videos_{channel_id}", use_container_width=True):
+            result = fetch_channel_videos_public(channel, limit=10)
+            if result.ok:
+                videos = _merge_channel_videos(channel_id, result.data.get("videos", []))
+                st.session_state[f"channel_videos_{channel_id}"] = videos
+                st.success(result.message)
+                st.rerun()
+            else:
+                st.warning(result.message)
+    with view_col:
+        view_mode = st.radio("Vista", ["Lista", "Kanban"], horizontal=True, key=f"channel_videos_view_{channel_id}", label_visibility="collapsed")
+    videos = st.session_state.get(f"channel_videos_{channel_id}") or channel_videos_for(channel, limit=10)
+    if not videos:
+        st.info("Ainda não existem vídeos sincronizados. Clique em **Actualizar últimos 10 vídeos**.")
+        return
+    if view_mode == "Lista":
+        for video in videos[:10]:
+            with st.container(border=True):
+                cols = st.columns([0.7, 3.4, 1.4, 1.1])
+                with cols[0]:
+                    if video.get("thumbnail_url"):
+                        st.image(video["thumbnail_url"], width=64)
+                    else:
+                        st.markdown("### YT")
+                with cols[1]:
+                    st.write(f"**{video.get('title', 'Vídeo sem título')}**")
+                    st.caption(f"{video.get('published_at') or 'Sem data'} · {video.get('url') or 'Sem URL'}")
+                with cols[2]:
+                    st.caption(str(video.get("status") or "publicado").title())
+                with cols[3]:
+                    render_channel_video_editor(video, channel_id)
+    else:
+        columns = st.columns(4)
+        groups = [("planejamento", "Planejamento"), ("produção", "Produção"), ("finalizado", "Finalizado"), ("publicado", "Agendado/Publicado")]
+        for column, (status_key, label) in zip(columns, groups):
+            with column:
+                st.markdown(f"**{label}**")
+                group = [video for video in videos[:10] if str(video.get("status") or "publicado").lower() in ({status_key} if status_key != "publicado" else {"publicado", "agendado"})]
+                if not group:
+                    st.caption("Sem vídeos")
+                for video in group:
+                    with st.container(border=True):
+                        st.write(f"**{video.get('title', 'Vídeo sem título')}**")
+                        st.caption(video.get("published_at") or "Sem data")
+                        render_channel_video_editor(video, channel_id)
+
+
+def render_channel_edit_form(channel: dict, youtube_account_ids: list[str], youtube_account_labels: dict[str, str], youtube_accounts_by_id: dict[str, dict[str, Any]]) -> None:
+    channel_id = str(channel["id"])
+    blueprint_ids, blueprint_labels, current_blueprint, voice_options, current_voice = channel_default_options(channel)
+    account_ids = list(youtube_account_ids)
+    current_account = str(channel.get("google_account_id") or "")
+    if current_account and current_account not in account_ids:
+        account_ids.append(current_account)
+        youtube_account_labels[current_account] = "Conta Google não configurada"
+    with st.form(f"channel_edit_form_{channel_id}"):
+        st.subheader("Editar canal")
+        edit_cols = st.columns(2)
+        with edit_cols[0]:
+            edited_name = st.text_input("Nome do canal", value=str(channel.get("name") or ""))
+            edited_url = st.text_input("URL", value=str(channel.get("url") or ""))
+            edited_handle = st.text_input("Handle", value=str(channel.get("handle") or ""))
+            edited_language = st.selectbox("Idioma", ["Português", "English", "Español", "Français", "Deutsch"], index=["Português", "English", "Español", "Français", "Deutsch"].index(channel.get("language")) if channel.get("language") in {"Português", "English", "Español", "Français", "Deutsch"} else 0)
+            style_options = ["Pexels/Pixabay", "full_ia", "Apenas Música"]
+            style_value = {"pexels": "Pexels/Pixabay", "music": "Apenas Música"}.get(str(channel.get("style_wide") or "pexels"), str(channel.get("style_wide") or "Pexels/Pixabay"))
+            edited_style = st.selectbox("Estilo wide", style_options, index=style_options.index(style_value) if style_value in style_options else 0)
+            edited_niche = st.text_input("Canais de Referência / Nicho", value=str(channel.get("niche") or channel_niche_label(channel) if channel_niche_label(channel) != "SEM NICHO CONFIGURADO" else "") )
+        with edit_cols[1]:
+            edited_blueprint = st.selectbox("Prompts do Canal", blueprint_ids, index=blueprint_ids.index(current_blueprint) if current_blueprint in blueprint_ids else 0, format_func=lambda item: blueprint_labels.get(item, item or "Sem Blueprint padrão"))
+            edited_voice = st.selectbox("Narrador", voice_options, index=voice_options.index(current_voice) if current_voice in voice_options else 0, format_func=lambda item: item or "Sem voz padrão")
+            edited_account = st.selectbox("Conta Google para Upload directo", account_ids, index=account_ids.index(current_account) if current_account in account_ids else 0, format_func=lambda item: youtube_account_labels.get(item, item or "Sem conta Google associada"))
+            edited_description = st.text_area("Descrição", value=str(channel.get("description") or ""), height=100)
+            edited_automation = st.toggle("Automação ON", value=bool(channel.get("automation_on", False)), key=f"edit_automation_{channel_id}")
+            edited_time = st.text_input("Horário diário (HH:MM)", value=str(channel.get("automation_time") or "00:00"))
+        save_channel = st.form_submit_button("Guardar alterações", type="primary", use_container_width=True)
+        cancel_edit = st.form_submit_button("Cancelar edição")
+    if cancel_edit:
+        st.session_state.pop(f"edit_channel_{channel_id}", None)
+        st.rerun()
+    if save_channel:
+        if not edited_name.strip():
+            st.error("Informe o nome do canal.")
+        elif not valid_hhmm(edited_time):
+            st.error("O horário diário deve estar no formato HH:MM.")
+        else:
+            update_channel(channel_id, {
+                "name": edited_name.strip(), "url": edited_url.strip(), "handle": edited_handle.strip(), "language": edited_language,
+                "style_wide": {"Pexels/Pixabay": "pexels", "Apenas Música": "music"}.get(edited_style, edited_style),
+                "niche": edited_niche.strip(), "reference_channels": [item.strip() for item in re.split(r"[,|]", edited_niche) if item.strip()],
+                "default_blueprint_id": edited_blueprint.strip(), "blueprint_id": edited_blueprint.strip(),
+                "default_voice": edited_voice.strip(), "voice": edited_voice.strip(),
+                "google_account_id": edited_account.strip(), "google_account_email": str(youtube_accounts_by_id.get(edited_account, {}).get("email", "")),
+                "description": edited_description.strip(), "automation_on": bool(edited_automation), "automation_time": edited_time.strip(),
+            })
+            st.session_state.pop(f"edit_channel_{channel_id}", None)
+            st.success("Canal actualizado.")
+            st.rerun()
+
+
 def render_dashboard():
     st.title("Thunderbolt")
     st.caption("Interface local para operação e automação de conteúdo faceless")
@@ -482,6 +648,7 @@ def render_channels():
                 automation_on = st.toggle("Automação ON", value=bool(imported.get("automation_on", False)), key="yt_import_automation_on")
                 automation_time = st.text_input("Horário diário (HH:MM)", value=imported.get("automation_time", "00:00"), key="yt_import_automation_time")
                 description = st.text_area("Descrição", value=imported.get("description", ""), key="yt_import_description")
+                niche = st.text_input("Canais de Referência / Nicho", value=imported.get("niche", ""), key="yt_import_niche")
                 metrics = st.columns(3)
                 with metrics[0]: subscriber_count = st.number_input("Inscritos", min_value=0, value=int(imported.get("subscriber_count") or 0), key="yt_import_subscribers")
                 with metrics[1]: video_count = st.number_input("Vídeos", min_value=0, value=int(imported.get("video_count") or 0), key="yt_import_videos")
@@ -497,6 +664,8 @@ def render_channels():
                             **imported,
                             "handle": handle.strip(),
                             "description": description.strip(),
+                            "niche": niche.strip(),
+                            "reference_channels": [item.strip() for item in re.split(r"[,|]", niche) if item.strip()],
                             "language": language,
                             "style_wide": {"Pexels/Pixabay": "pexels", "full_ia": "full_ia", "Apenas Música": "music"}.get(style, style),
                             "blueprint_id": blueprint.strip(),
@@ -615,6 +784,7 @@ def render_channels():
             url = st.text_input("URL do canal", placeholder="https://youtube.com/@seucanal", key="manual_channel_url")
             handle = st.text_input("Handle", placeholder="@seucanal", key="manual_channel_handle")
             description = st.text_area("Descrição", key="manual_channel_description")
+            niche = st.text_input("Canais de Referência / Nicho", placeholder="Ex.: História militar, mistérios, ciência", key="manual_channel_niche")
             language = st.selectbox("Idioma", ["Português", "English", "Español", "Français", "Deutsch"], index=0, key="manual_channel_language")
             style = st.selectbox("Estilo wide", ["Pexels/Pixabay", "full_ia", "Apenas Música"], index=0, key="manual_channel_style")
             manual_blueprint_items = blueprint_catalog()
@@ -642,6 +812,8 @@ def render_channels():
                     channel = create_channel(name, url, {
                         "handle": handle.strip(),
                         "description": description.strip(),
+                        "niche": niche.strip(),
+                        "reference_channels": [item.strip() for item in re.split(r"[,|]", niche) if item.strip()],
                         "language": language,
                         "style_wide": {"Pexels/Pixabay": "pexels", "full_ia": "full_ia", "Apenas Música": "music"}.get(style, style),
                         "blueprint_id": blueprint.strip(),
@@ -667,99 +839,94 @@ def render_channels():
         st.info("Nenhum canal cadastrado.")
         return
     for channel in channels:
+        channel_id = str(channel["id"])
+        edit_key = f"edit_channel_{channel_id}"
         with st.container(border=True):
-            channel_account_ids = list(youtube_account_ids)
-            current_channel_account_id = str(channel.get("google_account_id", ""))
-            if current_channel_account_id and current_channel_account_id not in channel_account_ids:
-                channel_account_ids.append(current_channel_account_id)
-                youtube_account_labels[current_channel_account_id] = "Conta Google não configurada"
-            st.markdown("**Upload directo — documento da conta deste canal**")
-            st.caption("O DELEGATED_SESSION_ID deste canal é individual, mas fica apenas no documento JSON da conta Google. A UI não mostra nem edita esse valor; associe apenas o canal à conta que contém o documento.")
-            with st.form(f"channel_direct_credentials_{channel['id']}"):
-                channel_account_id = st.selectbox("Conta Google do documento deste canal", channel_account_ids, index=channel_account_ids.index(current_channel_account_id) if current_channel_account_id in channel_account_ids else 0, format_func=lambda item: youtube_account_labels.get(item, item or "Sem conta Google associada"), key=f"channel_account_{channel['id']}")
-                save_channel_direct_credentials = st.form_submit_button("Associar conta Google ao canal", type="primary", use_container_width=True)
-            selected_channel_account = youtube_accounts_by_id.get(channel_account_id)
-            if selected_channel_account:
-                selected_account_status = document_status(STORAGE, selected_channel_account, channel, settings, channels)
-                if selected_account_status["ready"]:
-                    st.success("Documento da conta completo e DELEGATED_SESSION_ID deste canal encontrado no documento.")
-                elif not selected_account_status["document_exists"]:
-                    st.warning("A conta seleccionada ainda não tem documento JSON de credenciais.")
-                else:
-                    missing_channel_parts = list(selected_account_status["missing_cookies"])
-                    if not selected_account_status["has_session_info"]:
-                        missing_channel_parts.append("sessionInfo")
-                    if not selected_account_status["has_innertube_api_key"]:
-                        missing_channel_parts.append("INNERTUBE_API_KEY")
-                    if not selected_account_status["has_delegated_session_id"]:
-                        missing_channel_parts.append("DELEGATED_SESSION_ID deste canal")
-                    st.warning(f"Documento incompleto: {', '.join(missing_channel_parts)}")
-            else:
-                st.info("Associe este canal a uma conta Google para validar o documento de credenciais.")
-            if save_channel_direct_credentials:
-                update_channel(channel["id"], {"google_account_id": channel_account_id.strip(), "google_account_email": str(youtube_accounts_by_id.get(channel_account_id, {}).get("email", ""))})
-                st.success("Conta Google associada ao canal. O DELEGATED_SESSION_ID continua exclusivamente no documento da conta.")
-                st.rerun()
-            cols = st.columns([0.6, 2.2, 1.2, 1.2, 1.2, 1])
-            with cols[0]:
+            header_cols = st.columns([0.7, 3.5, 1.3, 1.3, 1.5])
+            with header_cols[0]:
                 if channel.get("thumbnail_url"):
-                    st.image(channel["thumbnail_url"], width=54)
+                    st.image(channel["thumbnail_url"], width=64)
                 else:
                     st.markdown("### YT")
-            with cols[1]:
+            with header_cols[1]:
                 st.write(f"**{channel.get('name', 'Sem nome')}**")
+                st.caption(channel_niche_label(channel))
                 st.caption(f"{channel.get('handle') or channel.get('url') or 'sem URL'} · {channel.get('metrics_source', 'manual')}")
-            with cols[2]: st.metric("Inscritos", channel.get("subscriber_count") if channel.get("subscriber_count") is not None else "—")
-            with cols[3]: st.metric("Vídeos", channel.get("video_count") if channel.get("video_count") is not None else "—")
-            with cols[4]: st.metric("Backlog", channel.get("backlog_total", 0))
-            with cols[5]:
-                active = st.toggle("Activo", value=channel.get("active", True), key=f"active_{channel['id']}")
+            with header_cols[2]:
+                st.metric("Inscritos", channel.get("subscriber_count") if channel.get("subscriber_count") is not None else "—")
+            with header_cols[3]:
+                st.metric("Vídeos", channel.get("video_count") if channel.get("video_count") is not None else "—")
+            with header_cols[4]:
+                active = st.toggle("Activo", value=channel.get("active", True), key=f"active_{channel_id}")
                 if active != channel.get("active"):
-                    update_channel(channel["id"], {"active": active})
+                    update_channel(channel_id, {"active": active})
                     st.rerun()
-                delete_key = f"delete_pending_{channel['id']}"
-                if not st.session_state.get(delete_key, False):
-                    if st.button("Apagar canal", key=f"delete_{channel['id']}", use_container_width=True):
+                action_cols = st.columns(2)
+                with action_cols[0]:
+                    if st.button("Editar", key=f"edit_channel_button_{channel_id}", use_container_width=True):
+                        st.session_state[edit_key] = True
+                        st.rerun()
+                with action_cols[1]:
+                    delete_key = f"delete_pending_{channel_id}"
+                    if st.button("Apagar", key=f"delete_{channel_id}", use_container_width=True):
                         st.session_state[delete_key] = True
                         st.rerun()
+            if st.session_state.get(edit_key):
+                render_channel_edit_form(channel, youtube_account_ids, youtube_account_labels, youtube_accounts_by_id)
+            else:
+                summary = channel_blueprint_summary(channel)
+                block_cols = st.columns(3)
+                with block_cols[0]:
+                    st.markdown(f"**Prompts do Canal**\n\n{summary['name']}")
+                    if st.button("Editar Prompts", key=f"edit_prompts_{channel_id}", use_container_width=True):
+                        st.session_state[edit_key] = True
+                        st.rerun()
+                with block_cols[1]:
+                    st.markdown(f"**Canais de Referência**\n\n{channel_niche_label(channel)}")
+                    if st.button("Editar Nicho", key=f"edit_niche_{channel_id}", use_container_width=True):
+                        st.session_state[edit_key] = True
+                        st.rerun()
+                with block_cols[2]:
+                    st.markdown(f"**Narrador**\n\n{summary['voice'] or 'Sem voz padrão'}")
+                    if st.button("Configurar Narrador", key=f"edit_voice_{channel_id}", use_container_width=True):
+                        st.session_state[edit_key] = True
+                        st.rerun()
+
+            channel_account_ids = list(youtube_account_ids)
+            current_channel_account_id = str(channel.get("google_account_id", ""))
+            if current_channel_account_id and current_channel_account_id not in channel_account_ids:
+                channel_account_ids.append(current_channel_account_id)
+                youtube_account_labels[current_channel_account_id] = "Conta Google não configurada"
+            with st.expander("Upload directo — documento da conta deste canal", expanded=False):
+                st.caption("O DELEGATED_SESSION_ID deste canal é individual, mas fica apenas no documento JSON da conta Google. A UI não mostra nem edita esse valor; associe apenas o canal à conta que contém o documento.")
+                with st.form(f"channel_direct_credentials_{channel_id}"):
+                    channel_account_id = st.selectbox("Conta Google do documento deste canal", channel_account_ids, index=channel_account_ids.index(current_channel_account_id) if current_channel_account_id in channel_account_ids else 0, format_func=lambda item: youtube_account_labels.get(item, item or "Sem conta Google associada"), key=f"channel_account_{channel_id}")
+                    save_channel_direct_credentials = st.form_submit_button("Associar conta Google ao canal", type="primary", use_container_width=True)
+                selected_channel_account = youtube_accounts_by_id.get(channel_account_id)
+                if selected_channel_account:
+                    selected_account_status = document_status(STORAGE, selected_channel_account, channel, settings, channels)
+                    if selected_account_status["ready"]:
+                        st.success("Documento da conta completo e DELEGATED_SESSION_ID deste canal encontrado no documento.")
+                    elif not selected_account_status["document_exists"]:
+                        st.warning("A conta seleccionada ainda não tem documento JSON de credenciais.")
+                    else:
+                        missing_channel_parts = list(selected_account_status["missing_cookies"])
+                        if not selected_account_status["has_session_info"]:
+                            missing_channel_parts.append("sessionInfo")
+                        if not selected_account_status["has_innertube_api_key"]:
+                            missing_channel_parts.append("INNERTUBE_API_KEY")
+                        if not selected_account_status["has_delegated_session_id"]:
+                            missing_channel_parts.append("DELEGATED_SESSION_ID deste canal")
+                        st.warning(f"Documento incompleto: {', '.join(missing_channel_parts)}")
                 else:
-                    st.warning("As tarefas, vídeos e artefactos relacionados serão preservados.")
-                    confirm_col, cancel_col = st.columns(2)
-                    with confirm_col:
-                        if st.button("Confirmar apagar", key=f"confirm_delete_{channel['id']}", type="primary", use_container_width=True):
-                            removed = delete_channel(channel["id"])
-                            st.session_state.pop(delete_key, None)
-                            if removed:
-                                st.success(f"Canal {removed.get('name', 'seleccionado')} apagado.")
-                            st.rerun()
-                    with cancel_col:
-                        if st.button("Cancelar", key=f"cancel_delete_{channel['id']}", use_container_width=True):
-                            st.session_state.pop(delete_key, None)
-                            st.rerun()
-            blueprint_ids, blueprint_labels, current_blueprint, voice_options, current_voice = channel_default_options(channel)
-            with st.expander("Definir Blueprint e voz padrão", expanded=False):
-                editor_cols = st.columns(2)
-                with editor_cols[0]:
-                    channel_blueprint = st.selectbox(
-                        "Blueprint padrão",
-                        blueprint_ids,
-                        index=blueprint_ids.index(current_blueprint) if current_blueprint in blueprint_ids else 0,
-                        format_func=lambda item: blueprint_labels.get(item, item or "Sem Blueprint padrão"),
-                        key=f"channel_default_blueprint_{channel['id']}",
-                    )
-                with editor_cols[1]:
-                    channel_voice = st.selectbox(
-                        "Voz padrão",
-                        voice_options,
-                        index=voice_options.index(current_voice) if current_voice in voice_options else 0,
-                        format_func=lambda item: item or "Sem voz padrão",
-                        key=f"channel_default_voice_{channel['id']}",
-                    )
-                if st.button("Guardar Blueprint e voz", key=f"save_channel_defaults_{channel['id']}", type="primary"):
-                    set_channel_defaults(channel["id"], channel_blueprint, channel_voice)
-                    st.success("Blueprint padrão e voz padrão guardados para este canal.")
+                    st.info("Associe este canal a uma conta Google para validar o documento de credenciais.")
+                if save_channel_direct_credentials:
+                    update_channel(channel_id, {"google_account_id": channel_account_id.strip(), "google_account_email": str(youtube_accounts_by_id.get(channel_account_id, {}).get("email", ""))})
+                    st.success("Conta Google associada ao canal. O DELEGATED_SESSION_ID continua exclusivamente no documento da conta.")
                     st.rerun()
 
+            render_channel_videos(channel)
+
 
 def render_new_video(page_title: str = "Criação de Vídeos"):
     st.title(page_title)
@@ -1747,53 +1914,60 @@ def render_settings():
 
     with google_accounts_tab:
         st.subheader("Contas Google/YouTube — canais em lote")
-        st.caption("Cada registo representa uma conta Google que pode gerir vários canais do YouTube. O e-mail identifica a conta; esta área não lê a caixa Gmail. Cada conta tem Client ID, Client Secret e token OAuth próprios.")
+        st.caption("Abra uma conta para ver e editar os detalhes. O e-mail identifica a conta Google; esta área não lê a caixa Gmail.")
         batch_accounts = [account for account in settings.get("youtube_batch_accounts", []) if isinstance(account, dict) and account.get("id")]
-        direct_document_uploads: dict[str, Any] = {}
-        direct_account_save_buttons: dict[str, bool] = {}
+        channel_state = read_json("channels.json", [])
+        youtube_accounts_missing_document: list[str] = []
+
         for batch_account in batch_accounts:
             account_id = str(batch_account["id"])
-            with st.container(border=True):
+            account_email_snapshot = str(batch_account.get("email") or "sem e-mail")
+            account_label_snapshot = str(batch_account.get("label") or "Canais YouTube")
+            ensure_credentials_document(STORAGE, batch_account, settings, channel_state)
+            direct_status = direct_account_status(STORAGE, batch_account)
+            missing_document_parts = list(direct_status.get("missing_cookies", []))
+            if not direct_status.get("has_session_info"):
+                missing_document_parts.append("sessionInfo")
+            if not direct_status.get("has_innertube_api_key"):
+                missing_document_parts.append("INNERTUBE_API_KEY")
+            if missing_document_parts:
+                youtube_accounts_missing_document.append(account_email_snapshot)
+
+            with st.expander(f"{account_label_snapshot} — {account_email_snapshot}", expanded=False):
                 with st.form(f"batch_account_form_{account_id}"):
-                    account_cols = st.columns(4)
+                    account_cols = st.columns(2)
                     with account_cols[0]:
-                        account_label = st.text_input("Nome da conta", value=str(batch_account.get("label", "Canais YouTube")), key=f"batch_label_{account_id}")
-                    with account_cols[1]:
-                        account_email = st.text_input("E-mail/Gmail da conta", value=str(batch_account.get("email", "")), key=f"batch_email_{account_id}")
-                    with account_cols[2]:
+                        account_label = st.text_input("Nome da conta", value=account_label_snapshot, key=f"batch_label_{account_id}")
+                        account_email = st.text_input("E-mail/Gmail da conta", value=account_email_snapshot if account_email_snapshot != "sem e-mail" else "", key=f"batch_email_{account_id}")
                         account_client_id = st.text_input("OAuth Client ID", value=str(batch_account.get("client_id", "")), key=f"batch_client_id_{account_id}")
-                    with account_cols[3]:
+                    with account_cols[1]:
                         account_client_secret = st.text_input("OAuth Client Secret", value=str(batch_account.get("client_secret", "")), type="password", key=f"batch_client_secret_{account_id}")
-                    account_session_info = st.text_input(
-                        "sessionInfo token desta conta Google",
-                        value=str(batch_account.get("sessionInfo") or batch_account.get("session_info") or batch_account.get("direct_session_info", "")),
-                        type="password",
-                        key=f"batch_session_info_{account_id}",
-                        help="Token sessionInfo usado pelo Upload directo. É guardado por conta e sincronizado no credentials.json; os cookies e restantes valores continuam exclusivamente no documento.",
-                    )
+                        account_session_info = st.text_input(
+                            "sessionInfo token desta conta Google",
+                            value=str(batch_account.get("sessionInfo") or batch_account.get("session_info") or batch_account.get("direct_session_info", "")),
+                            type="password",
+                            key=f"batch_session_info_{account_id}",
+                            help="Token sessionInfo usado pelo Upload directo. É guardado por conta e sincronizado no credentials.json; os cookies e restantes valores continuam exclusivamente no documento.",
+                        )
                     save_account = st.form_submit_button("Guardar dados da conta Google", type="primary", use_container_width=True)
-                direct_status = direct_account_status(STORAGE, batch_account)
-                st.markdown("**Credenciais do Upload directo desta conta Google**")
-                st.caption("Estas credenciais pertencem apenas a este Gmail. O ficheiro contém SID, SSID, HSID, APISID e SAPISID e é guardado por ID da conta.")
-                direct_account_cols = st.columns([2.4, 1])
-                with direct_account_cols[0]:
-                    direct_document_uploads[account_id] = st.file_uploader("Documento de credenciais desta conta Google", type=["json"], key=f"direct_credentials_document_{account_id}", help="Documento JSON com cookies SID/SSID/HSID/APISID/SAPISID, sessionInfo token, INNERTUBE_API_KEY, chunk_size e mapa delegated_session_ids.")
-                with direct_account_cols[1]:
-                    if direct_status["document_exists"] and direct_status["ready"]:
-                        st.success("Documento completo")
-                    elif direct_status["document_exists"]:
-                        missing_document_parts = list(direct_status["missing_cookies"])
-                        if not direct_status["has_session_info"]:
-                            missing_document_parts.append("sessionInfo")
-                        if not direct_status["has_innertube_api_key"]:
-                            missing_document_parts.append("INNERTUBE_API_KEY")
-                        st.warning(f"Documento incompleto: {', '.join(missing_document_parts)}")
-                    else:
-                        st.warning("Sem documento de credenciais")
-                st.caption("Documento guardado em: storage/youtube_direct_accounts/<id-da-conta>/credentials.json")
-                direct_account_save_buttons[account_id] = st.button("Guardar documento de Upload directo desta conta", type="secondary", use_container_width=True, key=f"save_direct_account_{account_id}")
+
+                st.markdown("**Documento de cookies/credenciais desta conta Google**")
+                st.caption("O documento padrão é criado automaticamente. Suba um JSON completo ou apenas o documento de cookies; os valores preenchidos são incorporados e mantidos em credentials.json.")
+                document_upload = st.file_uploader(
+                    "Subir documento de cookies/credenciais",
+                    type=["json"],
+                    key=f"direct_credentials_document_{account_id}",
+                    help="Aceita o JSON do YouTube-Video-Upload-Frontend-Api. Um documento parcial de cookies também é incorporado sem apagar os restantes campos.",
+                )
+                if missing_document_parts:
+                    st.warning(f"Documento incompleto: {', '.join(missing_document_parts)}")
+                else:
+                    st.success("Documento completo para a conta Google")
+                st.caption(f"Documento guardado em: {direct_status['document_file']}")
+                document_save = st.button("Guardar documento nesta conta", key=f"save_direct_account_{account_id}", use_container_width=True)
+
                 account_status = youtube_batch_account_status(batch_account, STORAGE)
-                status_cols = st.columns([2, 1, 1])
+                status_cols = st.columns(3)
                 with status_cols[0]:
                     (st.success if account_status.ok else st.warning)(account_status.message)
                 with status_cols[1]:
@@ -1810,23 +1984,13 @@ def render_settings():
                         settings["youtube_batch_accounts"] = remaining_accounts
                         if settings.get("youtube_batch_selected_account_id") == account_id:
                             settings["youtube_batch_selected_account_id"] = str(remaining_accounts[0].get("id")) if remaining_accounts else ""
-                        channels = read_json("channels.json", [])
-                        channels_changed = False
-                        for channel in channels:
+                        for channel in channel_state:
                             if str(channel.get("google_account_id") or "") == account_id:
                                 channel.update({"google_account_id": "", "google_account_email": ""})
-                                channels_changed = True
-                        if channels_changed:
-                            write_json("channels.json", channels)
+                        write_json("channels.json", channel_state)
                         write_json("settings.json", settings)
                         st.rerun()
-                if st.button("Repetir campos para nova conta", icon=":material/content_copy:", key=f"batch_repeat_settings_{account_id}", use_container_width=True):
-                    st.session_state["new_batch_account_label"] = account_label
-                    st.session_state["new_batch_account_email"] = account_email
-                    st.session_state["new_batch_account_client_id"] = account_client_id
-                    st.session_state["new_batch_account_client_secret"] = account_client_secret
-                    st.session_state["new_batch_account_session_info"] = account_session_info
-                    st.rerun()
+
                 if save_account:
                     if "@" not in account_email.strip():
                         st.error("Informe um e-mail Google válido.")
@@ -1840,40 +2004,47 @@ def render_settings():
                                     delete_youtube_batch_token(existing, STORAGE)
                                 existing.update({"label": account_label.strip() or "Canais YouTube", "email": account_email.strip(), "client_id": account_client_id.strip(), "client_secret": account_client_secret.strip(), "sessionInfo": account_session_info.strip()})
                                 update_credentials_document_session_info(STORAGE, existing, account_session_info.strip())
+                                ensure_credentials_document(STORAGE, existing, settings, channel_state)
                         settings["youtube_batch_accounts"] = batch_accounts
                         write_json("settings.json", settings)
                         st.success("Conta Google/YouTube guardada.")
                         st.rerun()
-                if direct_account_save_buttons.get(account_id):
-                    uploaded_document = direct_document_uploads.get(account_id)
-                    if uploaded_document is None:
-                        st.error("Seleccione o documento JSON completo desta conta Google antes de guardar.")
+
+                if document_save:
+                    if document_upload is None:
+                        st.error("Seleccione um documento JSON de cookies/credenciais antes de guardar.")
                     else:
                         try:
-                            document = parse_credentials_document(uploaded_document.getvalue(), uploaded_document.name, session_info_override=account_session_info.strip())
-                            document["account_id"] = account_id
-                            document["email"] = str(batch_account.get("email", ""))
-                            save_credentials_document(STORAGE, batch_account, document)
-                            st.success("Documento de Upload directo guardado exclusivamente para esta conta Google.")
+                            merge_credentials_document(
+                                STORAGE,
+                                batch_account,
+                                document_upload.getvalue(),
+                                document_upload.name,
+                                session_info_override=str(batch_account.get("sessionInfo") or ""),
+                                channels=channel_state,
+                            )
+                            st.success("Documento incorporado e guardado nesta conta Google.")
                             st.rerun()
                         except ValueError as exc:
                             st.error(str(exc))
+
+        if youtube_accounts_missing_document:
+            st.info("Contas que ainda precisam de dados no documento: " + ", ".join(youtube_accounts_missing_document))
+
+        st.divider()
+        st.markdown("### Adicionar outra conta Gmail")
+        st.caption("Este formulário fica fora dos cartões das contas existentes. A associação de canais não depende da completude deste documento; ela apenas ficará pendente para Upload directo até os campos serem preenchidos.")
         with st.form("add_batch_account_form"):
-            st.markdown("**Credenciais do Upload directo desta conta Google**")
-            st.caption("Estes campos pertencem a este Gmail. O ficheiro será guardado numa pasta exclusiva da conta e nunca será uma configuração global.")
-            add_cols = st.columns(4)
+            add_cols = st.columns(2)
             with add_cols[0]:
                 new_account_label = st.text_input("Nome da nova conta", value="Canais YouTube", key="new_batch_account_label")
-            with add_cols[1]:
                 new_account_email = st.text_input("E-mail/Gmail", key="new_batch_account_email")
-            with add_cols[2]:
                 new_account_client_id = st.text_input("OAuth Client ID", key="new_batch_account_client_id")
-            with add_cols[3]:
+            with add_cols[1]:
                 new_account_client_secret = st.text_input("OAuth Client Secret", type="password", key="new_batch_account_client_secret")
-            new_account_session_info = st.text_input("sessionInfo token desta conta Google", type="password", key="new_batch_account_session_info", help="Token sessionInfo desta conta. Os cookies, INNERTUBE_API_KEY, chunk_size e delegated_session_ids continuam apenas no documento JSON.")
-            new_account_document = st.file_uploader("Documento de credenciais desta conta Google", type=["json"], key="new_batch_account_credentials_document", help="Documento JSON único com cookies SID/SSID/HSID/APISID/SAPISID, INNERTUBE_API_KEY, chunk_size e delegated_session_ids. O sessionInfo pode ser preenchido no campo acima ou no documento.")
-            st.caption("O documento é guardado em storage/youtube_direct_accounts/<id-da-conta>/credentials.json. O campo sessionInfo é específico desta conta; os cookies e restantes credenciais continuam apenas no documento.")
-            add_account = st.form_submit_button("Adicionar conta Google/YouTube com documento de Upload directo", use_container_width=True)
+                new_account_session_info = st.text_input("sessionInfo token desta conta Google", type="password", key="new_batch_account_session_info", help="Token sessionInfo desta conta. Os cookies, INNERTUBE_API_KEY, chunk_size e delegated_session_ids continuam apenas no documento.")
+                new_account_document = st.file_uploader("Documento de cookies/credenciais opcional", type=["json"], key="new_batch_account_credentials_document", help="Pode subir agora um JSON completo ou apenas o documento de cookies. Se não subir, será criado um credentials.json padrão vazio.")
+            add_account = st.form_submit_button("Adicionar conta Google/YouTube", type="primary", use_container_width=True)
         if add_account:
             document_error = ""
             if "@" not in new_account_email.strip():
@@ -1882,25 +2053,27 @@ def render_settings():
                 st.error("Informe o Client ID e o Client Secret da nova conta.")
             elif new_account_document is not None:
                 try:
-                    parse_credentials_document(new_account_document.getvalue(), new_account_document.name, session_info_override=new_account_session_info.strip())
-                except ValueError as exc:
-                    document_error = str(exc)
+                    raw_document = new_account_document.getvalue()
+                    json.loads(raw_document.decode("utf-8-sig", errors="replace"))
+                except (UnicodeDecodeError, json.JSONDecodeError, AttributeError) as exc:
+                    document_error = f"O documento {new_account_document.name} deve ser JSON válido."
                     st.error(document_error)
             if "@" in new_account_email.strip() and new_account_client_id.strip() and new_account_client_secret.strip() and not document_error:
                 new_account = {"id": f"google_batch_{uuid.uuid4().hex[:12]}", "label": new_account_label.strip() or "Canais YouTube", "email": new_account_email.strip(), "client_id": new_account_client_id.strip(), "client_secret": new_account_client_secret.strip(), "sessionInfo": new_account_session_info.strip()}
-                if new_account_document is not None:
-                    document = parse_credentials_document(new_account_document.getvalue(), new_account_document.name, session_info_override=new_account_session_info.strip())
-                    document["account_id"] = new_account["id"]
-                    document["email"] = new_account["email"]
-                    save_credentials_document(STORAGE, new_account, document)
                 batch_accounts.append(new_account)
                 settings["youtube_batch_accounts"] = batch_accounts
                 settings["youtube_batch_selected_account_id"] = new_account["id"]
                 write_json("settings.json", settings)
+                ensure_credentials_document(STORAGE, new_account, settings, channel_state)
                 if new_account_document is not None:
-                    st.success(f"Conta {new_account['email']} adicionada com documento de Upload directo por Gmail.")
+                    try:
+                        merge_credentials_document(STORAGE, new_account, new_account_document.getvalue(), new_account_document.name, session_info_override=new_account_session_info.strip(), channels=channel_state)
+                    except ValueError as exc:
+                        st.error(str(exc))
+                        st.stop()
+                    st.success(f"Conta {new_account['email']} adicionada e documento incorporado.")
                 else:
-                    st.warning(f"Conta {new_account['email']} adicionada. Carregue o documento completo no cartão desta conta antes do Upload directo.")
+                    st.warning(f"Conta {new_account['email']} adicionada. Foi criado um credentials.json padrão; suba o documento de cookies nesta conta quando estiver pronto.")
                 st.rerun()
 
     with api_keys_tab:

package/hermes_ui/domain.py

@@ -29,6 +29,8 @@ def create_channel(name: str, url: str = "", metadata: dict[str, Any] | None = N
         "url": url.strip(),
         "handle": "",
         "description": "",
+        "niche": "",
+        "reference_channels": [],
         "thumbnail_url": "",
         "subscriber_count": None,
         "video_count": None,
@@ -184,6 +186,18 @@ def create_tasks_for_batch(batch: dict[str, Any]) -> list[dict[str, Any]]:
     return created
 
 
+def update_channel_video(video_id: str, updates: dict[str, Any]) -> dict[str, Any] | None:
+    """Actualizar um vídeo remoto sincronizado ou um override local de vídeo do canal."""
+    videos = read_json("channel_videos.json", [])
+    for video in videos:
+        if video.get("id") == video_id:
+            video.update(updates)
+            video["updated_at"] = now()
+            write_json("channel_videos.json", videos)
+            return video
+    return None
+
+
 def update_task(task_id: str, updates: dict[str, Any]) -> dict[str, Any] | None:
     tasks = read_json("tasks.json", [])
     for task in tasks:

package/hermes_ui/storage.py

@@ -16,8 +16,9 @@ NICHES_DATA = STORAGE / "data" / "niches"
 SEED_BLUEPRINTS = ROOT / "seed" / "blueprints"
 
 DEFAULTS: dict[str, Any] = {
-    "channels.json": [],
-    "tasks.json": [],
+        "channels.json": [],
+        "channel_videos.json": [],
+        "tasks.json": [],
     "queues.json": {"niche": [], "blueprint": [], "brand": [], "script": [], "title": [], "thumbnail": [], "video": [], "edit": [], "upload": []},
     "batches.json": [],
     "uploads.json": [],

package/integrations/platforms.py

@@ -238,6 +238,80 @@ def _public_feed_data(channel_id: str, headers: dict[str, str]) -> dict[str, Any
         return {}
 
 
+def fetch_channel_videos_public(channel_ref: str | dict[str, Any], limit: int = 10) -> "IntegrationResult":
+    """Fetch the latest public channel videos from YouTube's Atom feed without an API key."""
+    if isinstance(channel_ref, dict):
+        source = str(channel_ref.get("youtube_channel_id") or channel_ref.get("url") or "").strip()
+    else:
+        source = str(channel_ref or "").strip()
+    if not source:
+        return IntegrationResult(False, "Este canal ainda não tem ID ou URL pública do YouTube.", {"videos": []})
+    headers = {
+        "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 Chrome/124 Safari/537.36",
+        "Accept-Language": "pt-BR,pt;q=0.9,en;q=0.8",
+        "Accept": "application/atom+xml,application/xml,text/xml;q=0.9,*/*;q=0.8",
+    }
+    channel_id = _channel_id_from_source(source)
+    if not channel_id and source.startswith(("http://", "https://")):
+        for page_url in _public_page_candidates(source):
+            try:
+                response = requests.get(page_url, headers=headers, timeout=12, allow_redirects=True)
+                response.raise_for_status()
+            except requests.RequestException:
+                continue
+            document = response.text or ""
+            channel_id = _channel_id_from_document(document, str(getattr(response, "url", "") or page_url))
+            if channel_id:
+                break
+    if not channel_id:
+        return IntegrationResult(False, "Não foi possível resolver o ID público do canal para carregar os vídeos.", {"videos": []})
+    feed_url = f"https://www.youtube.com/feeds/videos.xml?channel_id={channel_id}"
+    try:
+        response = requests.get(feed_url, headers=headers, timeout=12)
+        response.raise_for_status()
+        root = ET.fromstring(response.text)
+    except (requests.RequestException, ET.ParseError, ValueError) as exc:
+        return IntegrationResult(False, f"Não foi possível carregar os vídeos públicos do canal: {exc}", {"channel_id": channel_id, "videos": []})
+    namespace = {
+        "yt": "http://www.youtube.com/xml/schemas/2015",
+        "atom": "http://www.w3.org/2005/Atom",
+        "media": "http://search.yahoo.com/mrss/",
+    }
+    videos: list[dict[str, Any]] = []
+    max_items = max(1, min(10, int(limit or 10)))
+    for entry in root.findall("atom:entry", namespace)[:max_items]:
+        video_id = entry.findtext("yt:videoId", default="", namespaces=namespace).strip()
+        title = entry.findtext("atom:title", default="", namespaces=namespace).strip()
+        published_at = entry.findtext("atom:published", default="", namespaces=namespace).strip()
+        updated_at = entry.findtext("atom:updated", default="", namespaces=namespace).strip()
+        link = ""
+        for candidate in entry.findall("atom:link", namespace):
+            if candidate.attrib.get("rel", "alternate") == "alternate":
+                link = candidate.attrib.get("href", "")
+                break
+        if not link and video_id:
+            link = f"https://www.youtube.com/watch?v={video_id}"
+        thumbnail = ""
+        media_group = entry.find("media:group", namespace)
+        if media_group is not None:
+            media_thumbnail = media_group.find("media:thumbnail", namespace)
+            if media_thumbnail is not None:
+                thumbnail = str(media_thumbnail.attrib.get("url", ""))
+        videos.append({
+            "id": f"youtube_{video_id}" if video_id else f"youtube_{len(videos)}",
+            "youtube_video_id": video_id,
+            "channel_id": channel_id,
+            "title": title or "Vídeo sem título",
+            "published_at": published_at,
+            "updated_at": updated_at,
+            "url": link,
+            "thumbnail_url": thumbnail,
+            "source": "youtube_public_rss",
+            "status": "publicado",
+        })
+    return IntegrationResult(True, f"{len(videos)} vídeo(s) público(s) carregado(s) sem API Key.", {"channel_id": channel_id, "videos": videos})
+
+
 @dataclass
 class IntegrationResult:
     ok: bool
@@ -385,6 +459,9 @@ class YouTubeAdapter:
             data["youtube_id"] = direct_id
         return IntegrationResult(False, f"Não foi possível obter dados públicos do YouTube sem API Key. {last_error or 'Confirme o URL/handle ou use Cadastro manual.'}".strip(), data)
 
+    def fetch_channel_videos_public(self, channel_ref: str | dict[str, Any], limit: int = 10) -> IntegrationResult:
+        return fetch_channel_videos_public(channel_ref, limit=limit)
+
     def fetch_channel(self, value: str) -> IntegrationResult:
         ref = self.extract_channel_ref(value)
         if not self.api_key:

package/integrations/youtube_direct_credentials.py

@@ -32,6 +32,13 @@ def cookie_file_path(storage_root: Path, account: dict[str, Any]) -> Path:
     return account_directory(storage_root, account) / "cookies.json"
 
 
+def _placeholder_to_empty(value: Any) -> str:
+    text = str(value or "").strip()
+    if text in {"...", "…", "<preencher>", "<valor>"}:
+        return ""
+    return text
+
+
 def _normalise_pairs(value: Any) -> dict[str, str]:
     pairs: dict[str, str] = {}
     if isinstance(value, dict):
@@ -40,13 +47,13 @@ def _normalise_pairs(value: Any) -> dict[str, str]:
         for key, item in value.items():
             key_text = str(key).strip()
             if key_text in COOKIE_KEYS:
-                pairs[key_text] = str(item or "").strip()
+                pairs[key_text] = _placeholder_to_empty(item)
         return pairs
     if isinstance(value, list):
         for item in value:
             if isinstance(item, dict):
                 name = str(item.get("name") or item.get("key") or "").strip()
-                content = str(item.get("value") or "").strip()
+                content = _placeholder_to_empty(item.get("value"))
                 if name in COOKIE_KEYS:
                     pairs[name] = content
         return pairs
@@ -130,15 +137,15 @@ def _normalise_document(raw: Any, account: dict[str, Any]) -> dict[str, Any]:
         for key, value in delegated_raw.items():
             if isinstance(value, dict):
                 value = value.get("DELEGATED_SESSION_ID") or value.get("delegated_session_id") or ""
-            value = str(value or "").strip()
+            value = _placeholder_to_empty(value)
             if value:
                 delegated[str(key)] = value
     return {
         "account_id": str(raw.get("account_id") or account.get("id") or "").strip(),
         "email": str(raw.get("email") or account.get("email") or "").strip(),
-        "sessionInfo": str(raw.get("sessionInfo") or raw.get("session_info") or raw.get("direct_session_info") or _account_session_info(account)).strip(),
+        "sessionInfo": _placeholder_to_empty(raw.get("sessionInfo") or raw.get("session_info") or raw.get("direct_session_info") or _account_session_info(account)),
         "cookies": {key: cookies.get(key, "") for key in COOKIE_KEYS},
-        "INNERTUBE_API_KEY": str(raw.get("INNERTUBE_API_KEY") or raw.get("innertube_api_key") or raw.get("direct_innertube_api_key") or "").strip(),
+        "INNERTUBE_API_KEY": _placeholder_to_empty(raw.get("INNERTUBE_API_KEY") or raw.get("innertube_api_key") or raw.get("direct_innertube_api_key") or ""),
         "chunk_size": _safe_chunk_size(raw.get("chunk_size", raw.get("direct_chunk_size", DEFAULT_CHUNK_SIZE))),
         "delegated_session_ids": delegated,
     }
@@ -257,6 +264,49 @@ def ensure_credentials_document(storage_root: Path, account: dict[str, Any], set
     return credentials_document_path(storage_root, account)
 
 
+def merge_credentials_document(
+    storage_root: Path,
+    account: dict[str, Any],
+    content: bytes,
+    filename: str = DIRECT_DOCUMENT_NAME,
+    *,
+    session_info_override: str = "",
+    channels: list[dict[str, Any]] | None = None,
+) -> Path:
+    """Merge a complete or partial credentials JSON into the account document.
+
+    The upload may contain only cookies or the full Frontend API document. Existing
+    non-empty values are preserved, so uploading cookies never discards sessionInfo,
+    INNERTUBE_API_KEY, chunk_size or delegated channel IDs.
+    """
+    try:
+        raw = json.loads(content.decode("utf-8-sig", errors="replace"))
+    except (UnicodeDecodeError, json.JSONDecodeError) as exc:
+        raise ValueError(f"O documento de credenciais {filename} deve ser JSON válido.") from exc
+    if not isinstance(raw, dict):
+        raise ValueError(f"O documento de credenciais {filename} deve conter um objecto JSON.")
+
+    current = load_credentials_document(storage_root, account, channels=channels, create=True)
+    incoming = _normalise_document(raw, {**account, "sessionInfo": session_info_override})
+    merged = _normalise_document(current, account)
+    for key in COOKIE_KEYS:
+        if incoming["cookies"].get(key):
+            merged["cookies"][key] = incoming["cookies"][key]
+    incoming_session = _placeholder_to_empty(session_info_override) or incoming.get("sessionInfo", "")
+    if incoming_session:
+        merged["sessionInfo"] = incoming_session
+    if incoming.get("INNERTUBE_API_KEY"):
+        merged["INNERTUBE_API_KEY"] = incoming["INNERTUBE_API_KEY"]
+    if "chunk_size" in raw:
+        merged["chunk_size"] = incoming["chunk_size"]
+    for key, value in incoming.get("delegated_session_ids", {}).items():
+        if value:
+            merged["delegated_session_ids"][str(key)] = value
+    merged["account_id"] = str(account.get("id") or merged.get("account_id") or "")
+    merged["email"] = str(account.get("email") or merged.get("email") or "")
+    return save_credentials_document(storage_root, account, merged)
+
+
 def delegated_session_id(document: dict[str, Any], channel: dict[str, Any]) -> str:
     mapping = document.get("delegated_session_ids", {}) if isinstance(document, dict) else {}
     if not isinstance(mapping, dict):

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danhachuel/thunderbolt",
-  "version": "0.2.50",
+  "version": "0.2.52",
   "description": "Thunderbolt — interface local para operação de canais faceless e motor MoneyPrinterTurbo",
   "main": "scripts/cli.mjs",
   "type": "module",