@agent-native/core 0.76.5 → 0.76.6

package/corpus/core/docs/content/locales/pt-BR/template-content.md

@@ -0,0 +1,402 @@
+---
+title: "Conteúdo"
+description: "Obsidian de código aberto para MDX: edite arquivos Markdown/MDX locais, gere blocos personalizados interativos ricos e escreva com um agente de IA."
+---
+
+# Conteúdo
+
+O conteúdo é Obsidian de código aberto para MDX: um documento amigável para arquivos locais
+espaço de trabalho onde o agente pode ler, escrever, reorganizar e publicar páginas para
+você. Abra um documento, peça "reescreva este parágrafo para ser mais conciso" ou "crie um
+página chamada Planejamento do quarto trimestre com subpáginas para metas, métricas e riscos" - o mesmo
+resultado, quer você mesmo faça isso ou pergunte.
+
+```an-wireframe
+{
+  "surface": "desktop",
+  "html": "<div style='display:grid;grid-template-columns:210px 1fr;gap:14px;padding:16px;min-height:500px;box-sizing:border-box'><aside class='wf-card' style='display:flex;flex-direction:column;gap:10px'><strong>Content</strong><span class='wf-pill accent'>Q3 Roadmap</span><span class='wf-pill'>Goals</span><span class='wf-pill'>Metrics</span><span class='wf-pill'>Risks</span><hr/><span class='wf-pill'>Engineering wiki</span><span class='wf-pill'>Reading list</span><span class='wf-pill'>Weekly sync</span></aside><main style='display:flex;flex-direction:column;gap:12px;min-width:0;padding:8px 20px'><div style='display:flex;align-items:center;gap:10px'><h1 style='margin:0'>Q3 Roadmap</h1><div style='flex:1'></div><button>Share</button><button class='primary'>Publish</button></div><div class='wf-card' style='flex:1;display:flex;flex-direction:column;gap:12px;padding:22px'><h2 style='margin:0'>Launch goals</h2><p style='margin:0'>Ship the onboarding flow, reduce setup time, and document owner handoffs.</p><div class='wf-box'>At a glance · owner, window, status</div><div class='wf-box'>Top objectives</div><div class='wf-box'>Workstreams table</div></div></main></div>"
+}
+```
+
+Ao abrir o aplicativo, você verá uma árvore de páginas ao lado do editor. O agente sempre sabe qual página você está visualizando e qual texto você selecionou, para que as edições do documento possam permanecer baseadas na página atual.
+
+```an-diagram title="One document, many editors" summary="You and the agent both write through the same Yjs pipeline. SQL is the canonical store; local files and Notion are optional sync surfaces."
+{
+  "html": "<div class=\"diagram-flow\"><div class=\"diagram-col\"><div class=\"diagram-node\">You type<br><small class=\"diagram-muted\">slash menu, toolbar</small></div><div class=\"diagram-node\">Agent edits<br><small class=\"diagram-muted\">edit-document find/replace</small></div></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-panel center\"><span class=\"diagram-pill accent\">Yjs CRDT</span><small class=\"diagram-muted\">live, conflict-free merge</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-box\">documents (markdown)<br><small class=\"diagram-muted\">canonical SQL store</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&harr;</div><div class=\"diagram-col\"><div class=\"diagram-box\">Local .md / .mdx<br><small class=\"diagram-muted\">/local-files</small></div><div class=\"diagram-box\">Notion pages<br><small class=\"diagram-muted\">pull · push</small></div></div></div>",
+  "css": ".diagram-flow{display:flex;align-items:center;gap:12px;flex-wrap:wrap}.diagram-flow .diagram-col{display:flex;flex-direction:column;gap:10px}.diagram-flow .diagram-arrow{font-size:22px;line-height:1}.diagram-flow .center{display:flex;flex-direction:column;align-items:center;gap:4px}"
+}
+```
+
+## O que você pode fazer com isso
+
+- **Escreva rich text** com títulos, listas, tabelas, blocos de código, imagens e links. Comandos de barra (`/`) inserem blocos; selecionar o texto abre uma barra de ferramentas de formatação.
+- **Organize as páginas em uma árvore** — aninhe infinitamente, arraste para reordenar, páginas favoritas que você usa com frequência.
+- **Pesquise tudo** com pesquisa de texto completo em títulos e conteúdo.
+- **Edite arquivos Markdown/MDX locais como Obsidian.** Use a visualização `/local-files`
+  para exportar seu espaço de trabalho para arquivos, edite-os em suas próprias ferramentas, visualize
+  alterações e importe-as de volta. No modo de arquivo local, o conteúdo é gravado diretamente em
+  o arquivo `.md` ou `.mdx` selecionado.
+- **Gere blocos personalizados interativos avançados.** Registre componentes React locais,
+  insira-os como MDX e deixe o agente criar ou atualizar arquivos de componentes para
+  seus documentos.
+- **Sincronize com Notion.** Vincule um documento local a uma página Notion e extraia ou envie conteúdo em qualquer direção. Os comentários também são sincronizados nos dois sentidos.
+- **Colabore em tempo real.** Várias pessoas (e o agente) podem editar o mesmo documento ao mesmo tempo.
+- **Compartilhe documentos** com colegas de equipe ou torne-os públicos – privados por padrão, com funções de visualizador/editor/administrador.
+- **Peça qualquer coisa ao agente**: "Reescreva este parágrafo." "Adicione um TL;DR no topo." "Encontre todas as minhas anotações de reuniões da semana passada." "Torne esse tom mais formal."
+
+## Primeiros passos
+
+Demonstração ao vivo: [content.agent-native.com](https://content.agent-native.com).
+
+Ao abrir o aplicativo, clique em **+ Nova página** na barra lateral, dê um título e comece a escrever. Para usar o agente, digite na barra lateral:
+
+- "Crie uma página chamada Onboarding e adicione três subpáginas abaixo dela."
+- "Reescreva este parágrafo para ser mais conciso." (com uma página aberta)
+- "Adicione uma seção sobre preços com três marcadores."
+- "Resuma este documento em um TL;DR na parte superior."
+- "Obtenha as últimas novidades de Notion." (depois de vincular uma página Notion)
+
+Selecione o texto e pressione Cmd+I para focar o agente com essa seleção pré-carregada - "tornar isso mais contundente" e operar exatamente com o que você destacou.
+
+## Arquivos locais Markdown/MDX {#local-files}
+
+O conteúdo pode percorrer documentos de ida e volta por meio de arquivos locais sem clonagem ou execução
+o aplicativo Conteúdo localmente. Parece Obsidian para MDX: os arquivos permanecem inspecionáveis
+e editável, enquanto o aplicativo oferece um editor avançado, agente actions, compartilhamento e
+blocos personalizados. Abra `/local-files`, escolha uma pasta no seu navegador ou agente
+Native Desktop e exporte a árvore de documentos atual como Markdown/MDX em
+`content/`.
+
+Cada arquivo exportado contém frontmatter para metadados de documentos (`id`, `title`,
+`parentId`, `position`, sinalizadores de favoritos/pesquisa/visibilidade e `updatedAt`) plus
+o corpo do documento como Markdown. Você pode editar esses arquivos em seu editor normal,
+depois retorne ao `/local-files` para visualizar e importar as alterações de volta para o Conteúdo.
+
+Este fluxo de trabalho é útil quando você deseja conteúdo no controle de origem ou em lote
+edite documentos com ferramentas locais ou queira um caminho sem clonagem para equipes que preferem arquivos
+como superfície de revisão. O aplicativo hospedado continua sendo a fonte da verdade para compartilhamento,
+comentários, permissões e colaboração ao vivo; a pasta local é explícita
+superfície de sincronização.
+
+O conteúdo também pode ser executado no **Modo de arquivo local**, onde os arquivos são a origem de
+verdade em vez de documentos SQL. Adicione `agent-native.json` a um repositório, defina
+`mode: "local-files"` e configure raízes como `docs/`, `blog/`,
+`content/` e `resources/`. O editor de conteúdo padrão preenche seu
+barra lateral esquerda dos arquivos `.md`/`.mdx` locais e grava as edições de volta no
+arquivo selecionado através do documento normal actions. Use isto para documentos repo-first,
+blogs, bibliotecas de recursos ou conteúdo pessoal no estilo Obsidian com tecnologia MDX
+componentes; volte para o modo de banco de dados quando desejar colaboração hospedada e
+Compartilhamento apoiado por SQL. Consulte [Local File Mode](/docs/local-file-mode) para
+layout de repositório independente, configuração, componentes MDX personalizados, local
+Widgets `extensions/` e guia de segurança de produção.
+
+Para instalar a habilidade Content local-files em um repositório existente:
+
+```bash
+npx @agent-native/core@latest skills add content --mode local-files --scope project
+```
+
+O instalador copia a habilidade `content` para seu agente de codificação e grava ou
+atualiza `agent-native.json` com raízes de conteúdo para `docs/`, `blog/`, `content/`,
+e `resources/`. Quando um aplicativo de conteúdo local, Agent Native Desktop ou confiável
+a ponte local está em execução, os agentes devem usar o Conteúdo actions como
+`list-documents`, `get-document`, `edit-document`, `update-document` e
+`share-local-file-document` em vez de gravações brutas no sistema de arquivos. Sem aquele local
+bridge, a habilidade instalada ainda dá ao agente o contrato de repoediting para
+edições seguras de Markdown/MDX.
+
+## Para desenvolvedores
+
+O restante deste documento é para qualquer pessoa que faça bifurcação do modelo Conteúdo ou estenda-o.
+
+### Início rápido
+
+Estruture um novo espaço de trabalho com o modelo Conteúdo:
+
+```bash
+npx @agent-native/core@latest create my-workspace --standalone --template content
+cd my-workspace
+pnpm install
+pnpm dev
+```
+
+Abra `http://localhost:8083` e crie sua primeira página. Em seguida, peça ao agente para "criar uma página chamada Onboarding e adicionar três subpáginas abaixo dela".
+
+### Principais recursos {#key-features}
+
+**Páginas aninhadas.** Os documentos formam uma árvore arrastável com favoritos, ícones, ordem e compartilhamento no nível da página.
+
+**Rico editor MDX.** Tiptap alimenta títulos, listas, tabelas, blocos de código, imagens, links, comandos de barra, barras de ferramentas de seleção e componentes React locais.
+
+**Colaboração ao vivo.** O Yjs mantém vários editores e edições de agentes sincronizados sem atrapalhar uns aos outros.
+
+**Pesquisa e comentários.** Pesquisa de texto completo, comentários ancorados, histórico de versões e fluxos de restauração são integrados à superfície do documento.
+
+**Sincronização de superfícies.** Os documentos podem ser sincronizados com Notion ou pastas locais Markdown/MDX, com SQL atuando como camada colaborativa de cache/histórico.
+
+### Sincronização de arquivos locais
+
+A rota `/local-files` protegida usa o navegador File System Access API ou um
+ponte de pasta nativa protegida dentro do Agent Native Desktop, para leitura e gravação
+Arquivos Markdown/MDX de uma pasta escolhida pelo usuário. Depois que a pasta estiver vinculada e
+importado, o arquivo selecionado é tratado como autoridade: abrindo a página lê
+o arquivo, e o editor normal salva, escreve o arquivo primeiro. SQL é então atualizado como um
+camada de cache/histórico para o documento existente UI, pesquisa e painel de versão, não
+como fonte da verdade. O menu da página no canto superior direito expõe o caminho de origem local:
+o caminho relativo está sempre disponível, o caminho absoluto está disponível no arquivo local verdadeiro
+modo e Agent Native Desktop, e Reveal no Finder estão disponíveis através do
+ponte de desktop ou modo de arquivo local apoiado por servidor.
+
+As chamadas de rota de sincronização em massa:
+
+- `export-content-source` — lê a árvore de documentos acessíveis e retorna um
+  pacote de arquivos `content/` determinísticos.
+- `import-content-source` — valida arquivos, cria novos documentos privados,
+  atualiza documentos onde o chamador tem acesso de editor, preserva a versão
+  histórico e rejeita ciclos pais inválidos.
+
+O formato de origem reside em `shared/content-source.ts`. Mantenha esse arquivo como
+contrato único para nomes de arquivos, frontmatter, análise e serialização.
+
+Os espaços de trabalho de arquivos locais também podem fornecer componentes React repo-locais por meio do
+pasta `components` configurada. O servidor de desenvolvimento de conteúdo importa PascalCase
+exporta desses arquivos, renderiza tags MDX correspondentes, como `<ImpactCounter />`
+dentro do editor e os expõe no menu de barras em Componentes locais.
+Esta é a camada "Obsidian for MDX": os blocos MDX personalizados permanecem locais para o
+espaço de trabalho, mas o editor pode renderizá-los e o agente pode gerá-los ou atualizá-los
+sua fonte sem clonar o aplicativo Content. Um componente mínimo do espaço de trabalho pode
+ser:
+
+```tsx
+// components/ImpactCounter.tsx
+import { useState } from "react";
+
+export function ImpactCounter({
+  label = "points",
+  start = 3,
+}: {
+  label?: string;
+  start?: number;
+}) {
+  const [count, setCount] = useState(start);
+  return (
+    <button type="button" onClick={() => setCount(count + 1)}>
+      Impact: {count} {label}
+    </button>
+  );
+}
+
+export const ImpactCounterInputs = {
+  label: { type: "string", label: "Label", default: "points" },
+  start: { type: "number", label: "Starting count", default: 3 },
+};
+```
+
+Use-o no MDX local como `<ImpactCounter />` ou insira-o a partir da barra do editor
+menu em Componentes locais. Quando os metadados de entrada são exportados, selecionando o
+o componente no editor mostra um botão de edição de canto que reescreve os adereços MDX
+no arquivo local.
+
+O seletor de **Arquivos locais** do navegador pode ler e gravar arquivos `.md` e `.mdx` em
+próprio, mas as visualizações do componente React executável requerem um compilador local. Corre
+Conteúdo localmente ou use o Agent Native Desktop para que o caminho do espaço de trabalho selecionado possa
+ser registrado no servidor de desenvolvimento de conteúdo local. Vite então importa
+`components/*.tsx`, recarrega a quente, edita em arquivos de componentes existentes e recarrega
+o registro do componente quando arquivos são adicionados ou removidos. Os agentes podem usar
+`list-local-component-files` e `write-local-component-file` para inspecionar ou
+atualizar arquivos de componentes registrados enquanto o editor atualiza da mesma fonte.
+
+### Comentários
+
+Comentários encadeados em documentos com âncoras de texto entre aspas, respostas e estado de resolução. Apoiado pela tabela `document_comments` e `app/components/editor/CommentsSidebar.tsx`. Actions: `list-comments`, `add-comment`. Os comentários Notion podem ser sincronizados nos dois sentidos via `sync-notion-comments`.
+
+### Histórico de versões
+
+Cada atualização significativa captura uma linha na tabela `document_versions`. O UI apresenta isso em `app/components/editor/VersionHistoryPanel.tsx`.
+
+### Compartilhamento e visibilidade
+
+Os documentos são privados por padrão. Você pode alterar a visibilidade para `org` ou `public` ou conceder funções por usuário e por organização (`viewer`, `editor`, `admin`). O compartilhamento montado automaticamente da estrutura actions funciona imediatamente:
+
+- `share-resource --resourceType document --resourceId <id> --principalType user --principalId <email> --role editor`
+- `unshare-resource` / `list-resource-shares` / `set-resource-visibility`
+
+Veja a habilidade `sharing`.
+
+### Equipes
+
+Uma página de equipe dedicada em `/team` (consulte `app/routes/_app.team.tsx`) usa o componente `TeamPage` da estrutura para criar organizações e gerenciar membros.
+
+### Trabalhando com o agente
+
+Como o agente vê sua tela atual, a maioria dos prompts não exige que você faça referência explícita a um documento. Quando você tem uma página aberta, "isto" significa aquela página.
+
+Para pequenas edições, o agente usa `edit-document --find ... --replace ...` para que apenas o texto alterado flua através de Yjs - você verá a diferença aplicada no local, em vez de toda a página ser renderizada novamente. Para reescritas maiores ele usa `update-document --content ...`.
+
+Se você selecionar o texto e pressionar Cmd+I (ou focar o painel do agente), a seleção viajará com sua próxima mensagem como contexto, então "tornar isso mais marcante" opera exatamente no que você destacou.
+
+### Bancos de dados e propriedades
+
+Os documentos podem hospedar bancos de dados in-line — tabelas no estilo Notion onde cada linha é em si um documento. O agente pode criar bancos de dados, adicionar itens, configurar definições de colunas e definir valores de propriedades por meio de actions: `create-content-database`, `add-database-item`, `set-document-property`. As definições de propriedades (tipo, visibilidade, opções, posição) residem em `document_property_definitions`; os valores por linha residem em `document_property_values`.
+
+### actions adicional
+
+Além da superfície CRUD no modelo de dados, o modelo fornece `export-document` para converter uma página em Markdown ou HTML, `transcribe-media` para anexar uma transcrição a uma página e `restore-document-version` para reverter para um instantâneo anterior.
+
+### Modelo de dados
+
+Nove tabelas, todas definidas em `server/db/schema.ts`:
+
+- **`documents`** — a árvore de páginas. Colunas: `id`, `parent_id`, `title`, `content` (redução), `icon`, `position`, `is_favorite`, `visibility`, `owner_email`, `org_id`, `created_at`, `updated_at`.
+- **`document_versions`** — instantâneos completos do título e conteúdo para histórico de versões. Reverter com `restore-document-version`.
+- **`document_comments`** — comentários encadeados com `thread_id`, `parent_id`, `quoted_text`, `resolved` e um `notion_comment_id` opcional para sincronização bidirecional do Notion.
+- **`document_sync_links`** — uma linha por documento vinculado a Notion que rastreia ID de página remota, horários da última sincronização, estado de conflito, hash de conteúdo e erros.
+- **`document_property_definitions`** — definições de colunas para bancos de dados embutidos: nome, tipo, visibilidade, opções e posição.
+- **`content_databases`** — objetos de banco de dados embutidos anexados a um `document_id` com um título e configuração de visualização JSON.
+- **`content_database_items`** — linhas em um banco de dados embutido, cada uma vinculando um `database_id` a um `document_id`.
+- **`document_property_values`** — valores de propriedade por documento (`property_id` → `value_json`).
+- **`document_shares`** — concessões por usuário e por organização criadas por meio de `createSharesTable`.
+
+```an-schema title="Content data model" summary="Nine tables in server/db/schema.ts. documents is the page tree; the rest hang off it for versions, comments, Notion sync, inline databases, and sharing."
+{
+  "entities": [
+    {
+      "id": "documents",
+      "name": "documents",
+      "note": "The page tree (ownable, markdown body)",
+      "fields": [
+        { "name": "id", "type": "id", "pk": true },
+        { "name": "parent_id", "type": "id", "fk": "documents.id", "nullable": true, "note": "infinite nesting" },
+        { "name": "title", "type": "string" },
+        { "name": "content", "type": "markdown" },
+        { "name": "icon", "type": "string", "nullable": true },
+        { "name": "position", "type": "int", "note": "sibling ordering" },
+        { "name": "is_favorite", "type": "bool" },
+        { "name": "visibility", "type": "enum", "note": "private | org | public" },
+        { "name": "owner_email", "type": "string" },
+        { "name": "org_id", "type": "id", "nullable": true }
+      ]
+    },
+    {
+      "id": "document_versions",
+      "name": "document_versions",
+      "note": "Full title/content snapshots for version history",
+      "fields": [
+        { "name": "id", "type": "id", "pk": true },
+        { "name": "document_id", "type": "id", "fk": "documents.id" },
+        { "name": "title", "type": "string" },
+        { "name": "content", "type": "markdown" }
+      ]
+    },
+    {
+      "id": "document_comments",
+      "name": "document_comments",
+      "note": "Threaded comments with quoted-text anchors",
+      "fields": [
+        { "name": "id", "type": "id", "pk": true },
+        { "name": "document_id", "type": "id", "fk": "documents.id" },
+        { "name": "thread_id", "type": "id" },
+        { "name": "parent_id", "type": "id", "fk": "document_comments.id", "nullable": true },
+        { "name": "quoted_text", "type": "string", "nullable": true },
+        { "name": "resolved", "type": "bool" },
+        { "name": "notion_comment_id", "type": "string", "nullable": true, "note": "bidirectional Notion sync" }
+      ]
+    },
+    {
+      "id": "document_sync_links",
+      "name": "document_sync_links",
+      "note": "One row per Notion-linked document",
+      "fields": [
+        { "name": "id", "type": "id", "pk": true },
+        { "name": "document_id", "type": "id", "fk": "documents.id" },
+        { "name": "notion_page_id", "type": "string" },
+        { "name": "conflict", "type": "bool" },
+        { "name": "content_hash", "type": "string" }
+      ]
+    },
+    {
+      "id": "content_databases",
+      "name": "content_databases",
+      "note": "Inline database objects attached to a document",
+      "fields": [
+        { "name": "id", "type": "id", "pk": true },
+        { "name": "document_id", "type": "id", "fk": "documents.id" },
+        { "name": "title", "type": "string" },
+        { "name": "view_config", "type": "json" }
+      ]
+    },
+    {
+      "id": "content_database_items",
+      "name": "content_database_items",
+      "note": "Rows in an inline database (each row is a document)",
+      "fields": [
+        { "name": "id", "type": "id", "pk": true },
+        { "name": "database_id", "type": "id", "fk": "content_databases.id" },
+        { "name": "document_id", "type": "id", "fk": "documents.id" }
+      ]
+    },
+    {
+      "id": "document_property_definitions",
+      "name": "document_property_definitions",
+      "note": "Column definitions for inline databases",
+      "fields": [
+        { "name": "id", "type": "id", "pk": true },
+        { "name": "name", "type": "string" },
+        { "name": "type", "type": "string" },
+        { "name": "options", "type": "json", "nullable": true },
+        { "name": "position", "type": "int" }
+      ]
+    },
+    {
+      "id": "document_property_values",
+      "name": "document_property_values",
+      "note": "Per-document property values",
+      "fields": [
+        { "name": "id", "type": "id", "pk": true },
+        { "name": "document_id", "type": "id", "fk": "documents.id" },
+        { "name": "property_id", "type": "id", "fk": "document_property_definitions.id" },
+        { "name": "value_json", "type": "json" }
+      ]
+    },
+    {
+      "id": "document_shares",
+      "name": "document_shares",
+      "note": "Per-user and per-org grants (createSharesTable)",
+      "fields": [
+        { "name": "id", "type": "id", "pk": true },
+        { "name": "document_id", "type": "id", "fk": "documents.id" },
+        { "name": "principal", "type": "string" },
+        { "name": "role", "type": "enum", "note": "viewer | editor | admin" }
+      ]
+    }
+  ],
+  "relations": [
+    { "from": "documents", "to": "documents", "kind": "1-n", "label": "has children" },
+    { "from": "documents", "to": "document_versions", "kind": "1-n", "label": "has snapshots" },
+    { "from": "documents", "to": "document_comments", "kind": "1-n", "label": "has comments" },
+    { "from": "documents", "to": "document_sync_links", "kind": "1-1", "label": "links to Notion" },
+    { "from": "documents", "to": "content_databases", "kind": "1-n", "label": "hosts databases" },
+    { "from": "content_databases", "to": "content_database_items", "kind": "1-n", "label": "has rows" },
+    { "from": "document_property_definitions", "to": "document_property_values", "kind": "1-n", "label": "has values" },
+    { "from": "documents", "to": "document_shares", "kind": "1-n", "label": "has share grants" }
+  ]
+}
+```
+
+O conteúdo é armazenado como markdown. O editor converte de e para o modelo Tiptap JSON na memória; a linha SQL é sempre remarcada para que actions, pesquisa e sincronização Notion possam operar em um único formato canônico.
+
+Todas as tabelas proprietárias incluem `owner_email` e `org_id` via `ownableColumns()`, portanto, cada linha tem como escopo o usuário conectado (e, opcionalmente, sua organização ativa) a partir do momento em que é criada.
+
+### Personalizando
+
+Os quatro pontos a serem observados ao mudar o comportamento:
+
+- **`actions/`** — todas as operações que o agente ou UI podem realizar. Adicione um novo arquivo como `actions/publish-to-wordpress.ts` usando `defineAction` e ambos os lados o receberão gratuitamente. Chave actions existente: `create-document.ts`, `edit-document.ts`, `update-document.ts`, `delete-document.ts`, `list-documents.ts`, `search-documents.ts`, `get-document.ts`, `pull-notion-page.ts`, `push-notion-page.ts`, `add-comment.ts`, `view-screen.ts`, `navigate.ts`.
+- **`app/routes/`** — a superfície da página. `_app.tsx` é o layout sem caminho que mantém a barra lateral e o painel do agente montados; `_app._index.tsx` é a visualização de pouso; `_app.page.$id.tsx` é a rota do editor; `_app.team.tsx` é a página de configurações da equipe.
+- **`app/components/editor/`** — o editor Tiptap. Adicione um novo tipo de nó em `extensions/` e registre-o em `DocumentEditor.tsx`. A barra de ferramentas de bolha, o menu de barras e as visualizações instantâneas são arquivos componentes que você pode editar.
+- **`.agents/skills/`** — orientação que o agente lê antes de agir. Se você adicionar um novo recurso (por exemplo, um pipeline de publicação CMS), coloque um `SKILL.md` em uma nova pasta de habilidade para que o agente o use corretamente. skills existente: `document-editing`, `notion-integration`, `real-time-sync`, `delegate-to-agent`, `storing-data`, `self-modifying-code`, `security`, `frontend-design`, `create-skill`, `capture-learnings`.
+- **`AGENTS.md`** — o guia de agente de nível superior com a folha de dicas de ação e a tabela de tarefas comuns. Atualize-o sempre que adicionar um recurso importante para que o agente o descubra sem explorá-lo.
+- **`server/db/schema.ts`** — modelo de dados. Adicione uma coluna ou tabela aqui. O modelo Conteúdo não possui script `db:push`; ele depende de migrações estritamente aditivas executadas na inicialização. Edite `server/db/schema.ts`, escreva uma migração aditiva correspondente e a mudança será aplicada na próxima vez que o aplicativo for inicializado. As atualizações de esquema nunca devem descartar, renomear ou alterar destrutivamente tabelas ou colunas existentes (consulte [Database](/docs/database#migrations) para obter diretrizes).
+- **`shared/notion-markdown.ts`** — conversão de redução em blocos Notion. Estenda isso se você adicionar novos tipos de bloco que precisam passar por Notion.
+
+O próprio agente pode fazer todas essas alterações - peça para ele "adicionar uma coluna de tags aos documentos e expô-la na barra lateral" e ele atualizará o esquema, migrará, conectará o UI e escreverá a ação.

package/corpus/core/docs/content/locales/pt-BR/template-design.md

@@ -0,0 +1,173 @@
+---
+title: "Projeto"
+description: "Um estúdio de prototipagem HTML nativo do agente: gere, refine, visualize e exporte designs Alpine/Tailwind interativos com um agente."
+---
+
+# Projeto
+
+Design é um estúdio de prototipagem HTML nativo do agente. Em vez de uma tela de desenho em camadas, o agente gera protótipos Alpine/Tailwind HTML completos e independentes, renderiza-os em um iframe e permite refinar o resultado com prompts e ajustes de controles.
+
+```an-wireframe
+{
+  "surface": "desktop",
+  "html": "<div style='display:flex;flex-direction:column;gap:14px;padding:18px;min-height:520px;box-sizing:border-box'><div style='display:flex;align-items:center;gap:10px'><h1 style='margin:0'>Product launch page</h1><span class='wf-pill accent'>Desktop</span><span class='wf-pill'>Tablet</span><span class='wf-pill'>Mobile</span><div style='flex:1'></div><button>Preview</button><button class='primary'>Export code</button></div><div class='wf-card' style='flex:1;display:grid;grid-template-rows:auto 1fr auto;gap:12px'><div style='display:flex;gap:8px'><span class='wf-pill accent'>Hero</span><span class='wf-pill'>Pricing</span><span class='wf-pill'>FAQ</span></div><div class='wf-box' style='display:flex;align-items:center;justify-content:center;min-height:230px'><strong>Generated HTML prototype</strong></div><div class='wf-card' style='display:flex;align-items:center;gap:10px'><span class='wf-muted'>Make the hero denser and the CTA clearer.</span><div style='flex:1'></div><button class='primary'>Apply revision</button></div></div></div>"
+}
+```
+
+Quando você abre o aplicativo, o protótipo gerado é o centro da área de trabalho, com modos de visualização, revisões imediatas e controles de exportação à mão. Tudo o que o agente produz é HTML real que você pode refinar, exportar ou entregar.
+
+```an-diagram title="One artifact, no translation" summary="The agent generates standalone Alpine/Tailwind HTML; the iframe, the editable source, and every export all read the same files. A linked design system feeds tokens into each pass."
+{
+  "html": "<div class=\"diagram-design\"><div class=\"diagram-col\"><div class=\"diagram-node\">Prompt<br><small class=\"diagram-muted\">describe screen / page</small></div><div class=\"diagram-pill\">Design system</div></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-box\" data-rough><span class=\"diagram-pill accent\">Agent generate</span><small class=\"diagram-muted\">standalone HTML / JSX files</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-box\" data-rough>iframe preview<br><small class=\"diagram-muted\">tweak knobs · Cmd+I refine</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&#8635;</div><div class=\"diagram-panel center\"><span class=\"diagram-pill ok\">Export</span><small class=\"diagram-muted\">HTML · ZIP · PDF · handoff</small></div></div>",
+  "css": ".diagram-design{display:flex;align-items:center;gap:12px;flex-wrap:wrap}.diagram-design .diagram-col{display:flex;flex-direction:column;gap:8px;align-items:flex-start}.diagram-design .diagram-box{display:flex;flex-direction:column;gap:4px}.diagram-design .diagram-arrow{font-size:20px;line-height:1}.diagram-design .center{display:flex;flex-direction:column;align-items:center;gap:4px}"
+}
+```
+
+## Quando escolher
+
+- **Você deseja um conceito refinado de página de destino, direção de produto UI ou exploração de marca** que possa deixar a ferramenta como HTML real, e não uma tela de desenho em camadas.
+- **Você quer um protótipo interativo funcional**, com estilos Alpine interactions e Tailwind, em vez de modelos estáticos.
+- **Você deseja comparar rotas rapidamente**, gerar algumas variantes, escolher a mais forte e continuar refinando.
+- **Você deseja um resultado de design de sua propriedade** — exporte HTML, ZIP ou PDF ou entregue o protótipo para uma ferramenta de codificação.
+
+## O que você pode fazer com isso
+
+- **Gere protótipos completos.** Descreva a tela ou página necessária e o agente criará um documento HTML funcional com estilo Tailwind e interactions Alpine.
+- **Compare variantes.** Comece com várias direções, escolha a mais forte e continue refinando.
+- **Ajuste visual.** Use os controles de ajuste integrados para alterações comuns ou peça ao agente atualizações de cópia, layout, cor, espaçamento e interação.
+- **Aplique sistemas de design.** Salve e reutilize as preferências do sistema de design para que o trabalho gerado fique mais próximo de sua marca.
+- **Importe referências.** Traga HTML existente ou material de referência como contexto para uma nova passagem de design.
+- **Exporte arquivos reais.** Exporte HTML, ZIP ou PDF do protótipo gerado.
+
+## Primeiros passos
+
+Demonstração ao vivo: [design.agent-native.com](https://design.agent-native.com).
+
+1. **Descreva o artefato.** Peça a tela, o fluxo, a página de destino ou o visual
+   direção desejada. Inclua público, tom e quaisquer restrições de produto.
+2. **Compare as direções.** Gere algumas variantes, escolha a mais forte e
+   continue refinando em vez de começar de novo.
+3. **Ajuste os detalhes.** Use controles de ajuste para alterações visuais comuns ou pergunte
+   o agente para alterações de layout, cópia, resposta e interação.
+4. **Exporte quando for útil.** Baixe HTML, ZIP ou PDF assim que o protótipo
+   está pronto para ser entregue a outra ferramenta ou colega de equipe.
+
+### Instruções úteis
+
+- "Crie três direções de página de destino para um produto de análise técnica."
+- "Torne este painel mais denso e fácil de verificar para uma equipe de operações."
+- "Aplique nosso sistema de design salvo e simplifique o layout móvel."
+- "Exporte este protótipo como ZIP assim que a variante final for selecionada."
+- "Transforme este HTML em uma página de preços mais forte sem alterar as cores da marca."
+
+## Para desenvolvedores
+
+O restante deste documento é para qualquer pessoa que faça bifurcação do modelo Design ou estenda-o.
+
+### Início rápido
+
+```bash
+npx @agent-native/core@latest create my-design --standalone --template design
+cd my-design
+pnpm install
+pnpm dev
+```
+
+### Modelo de dados
+
+Todos os dados residem em SQL via Drizzle ORM. Esquema: `templates/design/server/db/schema.ts`. Os designs e sistemas de design carregam o padrão `ownableColumns` e uma tabela de compartilhamentos de estrutura correspondente, para que eles se encaixem no modelo de compartilhamento por usuário/por organização.
+
+| Tabela                                   | O que ele contém                                                                                                                              |
+| ---------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
+| `designs`                                | Um projeto de design — `title`, `description`, `project_type` (`prototype`/`other`), o blob `data` JSON e um link `design_system_id` opcional |
+| `design_files`                           | Arquivos individuais pertencentes a um desenho (`filename`, `content`, `file_type` com padrão `html`)                                         |
+| `design_versions`                        | `snapshot`s pontuais de um design com um `label` opcional, para histórico e reversão                                                          |
+| `design_systems`                         | Tokens de marca reutilizáveis — `data` (cores/tipografia/espaçamento), `assets`, `custom_instructions` e uma sinalização `is_default`         |
+| `design_shares` / `design_system_shares` | O Framework compartilha tabelas mapeando principais (usuários ou organizações) para funções (visualizador, editor, administrador)             |
+
+```an-schema title="Design data model" summary="A design owns its files and versioned snapshots, and optionally links a reusable design system. Both designs and systems are ownable, each with a framework shares table."
+{
+  "entities": [
+    { "id": "designs", "name": "designs", "note": "A design project (ownable)", "fields": [
+      { "name": "id", "type": "id", "pk": true },
+      { "name": "title", "type": "text" },
+      { "name": "description", "type": "text", "nullable": true },
+      { "name": "project_type", "type": "text", "note": "prototype / other" },
+      { "name": "data", "type": "json", "note": "starts as {}" },
+      { "name": "design_system_id", "type": "id", "fk": "design_systems.id", "nullable": true }
+    ] },
+    { "id": "files", "name": "design_files", "note": "Files in a design", "fields": [
+      { "name": "design_id", "type": "id", "fk": "designs.id" },
+      { "name": "filename", "type": "text" },
+      { "name": "content", "type": "text" },
+      { "name": "file_type", "type": "text", "note": "defaults to html" }
+    ] },
+    { "id": "versions", "name": "design_versions", "note": "History / rollback", "fields": [
+      { "name": "design_id", "type": "id", "fk": "designs.id" },
+      { "name": "snapshot", "type": "json" },
+      { "name": "label", "type": "text", "nullable": true }
+    ] },
+    { "id": "systems", "name": "design_systems", "note": "Reusable brand tokens (ownable)", "fields": [
+      { "name": "id", "type": "id", "pk": true },
+      { "name": "data", "type": "json", "note": "colors / typography / spacing" },
+      { "name": "assets", "type": "json", "nullable": true },
+      { "name": "custom_instructions", "type": "text", "nullable": true },
+      { "name": "is_default", "type": "boolean" }
+    ] },
+    { "id": "design_shares", "name": "design_shares", "note": "Framework shares table", "fields": [
+      { "name": "design_id", "type": "id", "fk": "designs.id" },
+      { "name": "role", "type": "text", "note": "viewer / editor / admin" }
+    ] },
+    { "id": "system_shares", "name": "design_system_shares", "note": "Framework shares table", "fields": [
+      { "name": "design_system_id", "type": "id", "fk": "design_systems.id" },
+      { "name": "role", "type": "text", "note": "viewer / editor / admin" }
+    ] }
+  ],
+  "relations": [
+    { "from": "designs", "to": "files", "kind": "1-n" },
+    { "from": "designs", "to": "versions", "kind": "1-n" },
+    { "from": "systems", "to": "designs", "kind": "1-n", "label": "applied to" },
+    { "from": "designs", "to": "design_shares", "kind": "1-n" },
+    { "from": "systems", "to": "system_shares", "kind": "1-n" }
+  ]
+}
+```
+
+Um projeto de design é um shell até ter conteúdo: `create-design` cria uma linha vazia (`data: "{}"`) e, em seguida, `generate-design` grava os arquivos HTML/JSX independentes reais. O artefato gerado, a fonte editável e todas as exportações vêm do mesmo HTML, portanto, não há um formato de "maquete de IA" separado para traduzir. Um sistema de design vinculado fornece tokens e `custom_instructions` que o agente honra em cada passagem de geração.
+
+As rotas no UI estão sob `templates/design/app/routes/`: `_index.tsx` (lista), `design.$id.tsx` (editor), `present.$id.tsx` (apresentação), `design-systems.tsx` e `design-systems_.setup.tsx`, `templates.tsx`, `examples.tsx`, mais `settings.tsx` e `team.tsx`.
+
+### Chave actions
+
+Cada operação que pode ser chamada pelo agente é um arquivo TypeScript em `templates/design/actions/`, montado automaticamente em `POST /_agent-native/actions/:name` e executável a partir de CLI como `pnpm action <name>`. Os agrupamentos:
+
+- **Designs** — `create-design` (shell vazio), `generate-design` (gravação de conteúdo HTML/JSX gerado), `update-design`, `get-design`, `list-designs`, `duplicate-design`, `delete-design` e `apply-tweaks` para valores de botão de ajuste ao vivo persistentes (cor de destaque, densidade, etc.).
+- **Arquivos** — `create-file`, `update-file`, `list-files`, `delete-file` para os arquivos dentro de um projeto de design.
+- **Sistemas de design** — `create-design-system`, `update-design-system`, `get-design-system`, `list-design-systems`, `delete-design-system`, `set-default-design-system` e `analyze-brand-assets` para coletar dados da marca antes da análise.
+- **Importar** — `import-code`, `import-figma`, `import-github`, `import-from-url`, `import-document` (DOCX/PPTX/PDF/XLSX) e `import-design-project` para extrair um sistema de design de um projeto existente.
+- **Exportação e transferência** — `export-html`, `export-pdf`, `export-svg`, `export-zip` e `export-coding-handoff` para transformar um design em uma transferência de ferramenta de codificação.
+- **Contexto e navegação** — `view-screen` (design atual, arquivo aberto, visualização, pergunta pendente ou grade de variantes), `get-design-snapshot` (estado atual para um agente externo continuar) e `navigate`.
+
+### Trabalhando com o agente
+
+O agente sempre sabe o que você tem em aberto. O design atual, o arquivo aberto, a visualização ativa e qualquer questão pendente ou grade de variantes são retornados por `view-screen` e injetados em cada mensagem, para que você possa dizer "tornar isso mais denso" ou "exportar esta variante" sem nomear o design.
+
+Como um design consiste apenas em arquivos HTML/JSX independentes, o agente edita a mesma fonte que o iframe renderiza e de onde vem cada exportação — não há um formato de "maquete de IA" separado para traduzir. Um sistema de design vinculado fornece tokens e `custom_instructions` que o agente homenageia em cada passagem de geração. Selecione o texto ou uma região na visualização e pressione Cmd+I para focar o agente exatamente nessa parte.
+
+### Personalizando
+
+Design é um modelo completo e clonável. Algumas ideias práticas de extensão:
+
+- "Adicione um sistema de design de comércio eletrônico reutilizável com nossos tokens e componentes de amostra."
+- "Adicione uma etapa de exportação que carregue o ZIP para nosso sistema de revisão interno."
+- "Deixe-me colar a página de destino HTML existente e pedir ao agente três versões mais fortes."
+- "Adicione uma biblioteca de prompts salva para a página do produto, painel e resumos da tela de integração."
+- "Adicionar uma predefinição de exportação PDF personalizada para análise das partes interessadas."
+
+O agente edita rotas, componentes, actions e modelos apoiados por SQL conforme necessário. Consulte [Templates](/docs/cloneable-saas) para clonagem completa, personalização, fluxo de implantação e [Getting Started](/docs/getting-started) se este for seu primeiro modelo nativo de agente.
+
+## O que vem a seguir
+
+- [**Templates**](/docs/cloneable-saas) — o modelo clone e próprio
+- [**Context Awareness**](/docs/context-awareness) — como o agente sabe o que o usuário está visualizando
+- [**Creating Templates**](/docs/creating-templates) — padrões de construção atuais para modelos nativos de agente