Metadata-Version: 2.4
Name: guardiancontext
Version: 0.1.18
Summary: Contexto versionado em Git e coordenação de tarefas para agentes de programação.
Author: IronStack
License: Licença de Uso — GuardianContext
        Copyright (c) 2026 IronStack. Todos os direitos reservados.
        
        1. Concessão. A IronStack concede a você uma licença limitada, não exclusiva,
           intransferível e revogável para instalar e usar este software (CLI `guardian`,
           Desktop Manager e componentes distribuídos com eles) em conjunto com o serviço
           GuardianContext, conforme os Termos de Uso vigentes (docs/termos-de-uso.md ou
           https://api.ironstack.dev.br/termos), que integram esta licença.
        
        2. Restrições. Salvo autorização escrita da IronStack, você não pode: redistribuir,
           sublicenciar, vender ou alugar o software; remover avisos de autoria; usar o
           software para construir serviço concorrente; nem extrair a biblioteca curada de
           padrões para uso fora do serviço. Modificações para uso próprio são permitidas.
        
        3. Arquivos gerados no seu repositório (router.md, quadro.md, wiki/, decisoes/,
           claims/, handoffs/, hook pre-commit e afins) são seus, sem restrição.
        
        4. SEM GARANTIAS. O SOFTWARE É FORNECIDO "NO ESTADO EM QUE SE ENCONTRA", SEM GARANTIA
           DE QUALQUER NATUREZA, EXPRESSA OU IMPLÍCITA, INCLUINDO COMERCIALIZAÇÃO, ADEQUAÇÃO
           A UM FIM ESPECÍFICO E NÃO VIOLAÇÃO.
        
        5. LIMITAÇÃO DE RESPONSABILIDADE. EM NENHUMA HIPÓTESE A IRONSTACK RESPONDERÁ POR
           DANOS INDIRETOS, INCIDENTAIS, ESPECIAIS OU CONSEQUENCIAIS, PERDA DE DADOS, DE
           CÓDIGO OU DE LUCROS, DECORRENTES DO USO DO SOFTWARE OU DE AÇÕES DE AGENTES DE IA
           OPERADOS PELO USUÁRIO, AINDA QUE AVISADA DA POSSIBILIDADE. AGENTES DE IA EXECUTAM
           COMANDOS REAIS; A REVISÃO DO QUE ELES FAZEM É RESPONSABILIDADE DO USUÁRIO.
        
        6. Lei aplicável: República Federativa do Brasil.
        
Project-URL: Homepage, https://ironstack.dev.br/guardiancontext/
Project-URL: Documentation, https://ironstack.dev.br/guardiancontext/manual/
Project-URL: Terms, https://api.ironstack.dev.br/termos
Keywords: agents,coordination,git,multi-agent,control-plane
Requires-Python: >=3.9
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: PyYAML>=6.0
Provides-Extra: update
Requires-Dist: packaging<27,>=24; extra == "update"
Requires-Dist: cryptography<51,>=43; extra == "update"
Provides-Extra: security
Requires-Dist: cryptography<51,>=43; extra == "security"
Provides-Extra: dev
Requires-Dist: pytest>=7.0; extra == "dev"
Provides-Extra: semantic
Requires-Dist: fastembed==0.5.1; extra == "semantic"
Provides-Extra: obsidian
Requires-Dist: watchdog>=3.0.0; extra == "obsidian"
Provides-Extra: desktop
Requires-Dist: PySide6>=6.6; extra == "desktop"
Dynamic: license-file

# GuardianContext

[English](#english) · [Español](#español) · [Português (Brasil)](#português-brasil)

## English

GuardianContext helps you and your AI agents resume work on a project. It organizes rules, decisions, and tasks as Markdown files in your Git repository.

Before starting a task, you can search these files and gather the relevant instructions for your agent. This makes project decisions available across Codex and Claude Code sessions. Since the files live in Git, you can also review changes and consult their history.

GuardianContext includes a CLI and Desktop app for repository context, local search, claims, handoffs, diagnostics, and native hook protection. Run Codex, Claude Code, or another agent with its own client; GuardianContext does not launch agent sessions or provide MCP transport.

[User manual](https://ironstack.dev.br/guardiancontext/manual/) · [Product website](https://ironstack.dev.br/guardiancontext/) · [Support](mailto:suporte@ironstack.dev.br)

### What you can do

- Record rules and decisions that need to remain available in future sessions.
- Search project information and prepare a task brief with document excerpts and source file references.
- Reserve a file scope for a limited time with claims, and record handoffs so work can continue in a later session.
- Check document organization with `guardian doctor` and `guardian audit`.
- Review repository setup and local activity with `guardian doctor` and the Desktop diagnostics.

These features depend on configuration and on the people working on the project. Keep reviewing changes, tests, and commits. GuardianContext does not guarantee that an agent will follow the recorded rules.

### Local code graph and project knowledge

Build and query a local structural graph of the code when you choose. Graphify is an optional executable that you install separately; GuardianContext does not install it, and its absence does not affect the base package. You can also export versioned project documents to a project-specific folder in an Obsidian vault you choose. Preview changes first. The export is one-way, and edited copies are preserved and shown as conflicts.

### Install with the graphical interface

The official installer uses [uv](https://docs.astral.sh/uv/) to set up a Python 3.11 environment. It installs the graphical interface, semantic search, security features, and the required update component.

#### Windows, in PowerShell

```powershell
irm https://api.ironstack.dev.br/install.ps1 | iex
```

#### macOS or Linux

```sh
curl -fsSL https://api.ironstack.dev.br/install.sh | sh
```

These commands download and run the installer. You can open the URL and read the script before running it.

Installation may download Python and other components. Semantic search downloads a model on first use. On Linux, the graphical interface also needs the Qt libraries.

When Desktop Manager opens:

1. Create an account and accept the Terms of Use, or sign in to your existing account.
2. Choose a Git repository folder and your team's working mode.
3. Run setup and check the diagnostics.

If the window does not open, run `guardian-desktop` in a new terminal.

#### Check your agent's configuration

An active license or a high audit score does not confirm that your agent is using GuardianContext.

Run Codex, Claude Code, or another agent with its own client. GuardianContext does not create new Guardian MCP servers or launch agent sessions. Native hooks remain available and may configure the selected client's hook files. After upgrading to 0.1.18, Guardian checks only projects it already knows. On verified Windows configurations, Guardian removes a legacy entry only when ownership and access permissions are verified and the file is not EFS-encrypted. It creates a protected backup outside the repository for 30 days before replacing the configuration. If the file uses EFS, ownership or access permissions cannot be verified, or the platform is Linux or macOS, Guardian leaves the configuration unchanged and reports a pending cleanup; Linux and macOS use `permissions_unavailable`.

Diagnostics report configuration readiness and recorded claims or hook activity separately, with the latest event's source, scope, date, and result. These records do not prove an agent's identity, that it read instructions, or that it followed them. The Internal license also requires project setup.

### Install from the terminal

To try the document structure and text search, install the base package with [uv](https://docs.astral.sh/uv/getting-started/installation/):

```sh
uv tool install --python 3.11 guardiancontext
cd meu-repositorio
guardian init
guardian doctor
```

Replace `meu-repositorio` with your project's folder.

These commands create and check the local structure. Configure native hooks separately if the project needs them. To connect your account to the service, run `guardian signup` or `guardian login` in that folder. The command prompts you for your password.

The base package requires Python 3.9 or later. Python 3.11 is recommended for optional components. The manual explains how to install them, configure hooks, and choose between working in the same folder or in separate worktrees.

### Example: look up a decision before changing the database

After initializing GuardianContext, create `decisoes/0001-migrations.md`:

```markdown
# Database migrations

Every migration must include a rollback plan and be reviewed before deployment.
```

Update the index and find the decision:

```sh
guardian index rebuild --lexical
guardian brief "migrations" --tool agents --max-tokens 1500
```

The first command updates local search. The second prepares a task brief with matching excerpts and their source file paths.

Give the brief to your agent before it starts the change, and review the proposed actions.

This example uses text search from the base package. Results depend on the recorded content and the search terms.

### Where the files live

The default structure includes:

- `router.md`, `wiki/`, and `decisoes/` to organize project information.
- `claims/` and `handoffs/` to record work reservations and pass context to a later session.
- `docs/trabalho/` for supporting plans and references. In this repository, issues track work and claims reserve file scopes.

Local state and the index live in `.guardian/`. Review generated files before adding them to Git.

### What works offline

Local structure and search commands can work without a connection to the service.

Registration, synchronization, and licensed features have their own connection and authorization requirements. The manual included in the package can also be read offline.

### What data is sent to the service

Audit reports send metrics and counts. Pattern synchronization sends metadata and vectors. When calling the service, the client also reports its version, the interface in use, and a random installation profile identifier.

The `guardian contribute` command lets you propose a document for the curated library. Before submission, the text is anonymized and shown for your review and confirmation. Check the content to avoid sharing sensitive information.

The API key is stored in your user profile, outside the repository. GuardianContext may write native hook configuration and clean up proven Guardian entries left by the retired MCP integration; these are separate local operations. It does not create new Guardian MCP servers or start agent sessions. Run external agent clients separately.

### Updates

Official installations use automatic updates with safety checks. Updates are deferred while the runtime is in use. Check the status with `guardian update status`.

Other installation methods may require manual updates.

### Manual and support

The [full manual](https://ironstack.dev.br/guardiancontext/manual/) is available on the website. To read the packaged manual in English, Spanish, or Portuguese:

```sh
guardian manual --lang en
guardian manual --lang es
guardian manual --lang pt
```

To report a problem, email [suporte@ironstack.dev.br](mailto:suporte@ironstack.dev.br). Include your operating system, the output of `guardian --version`, the action you took, and the error message. Remove credentials and private data from logs.

GuardianContext is an IronStack product, distributed under a proprietary use license. The license is in the `LICENSE` file included in the package. Service conditions are in the [Terms of Use](https://api.ironstack.dev.br/termos).

---

## Español

[English](#english) · [Español](#español) · [Português (Brasil)](#português-brasil)

GuardianContext te ayuda a ti y a tus agentes de IA a retomar el trabajo en un proyecto. Organiza las reglas, decisiones y tareas en archivos Markdown dentro del repositorio Git.

Antes de empezar una tarea, puedes buscar en esos archivos y reunir las instrucciones relevantes para el agente. Así puedes usar las decisiones del proyecto en distintas sesiones de Codex y Claude Code. Como los archivos están en Git, también puedes revisar los cambios y consultar su historial.

GuardianContext incluye una CLI y una aplicación Desktop para consultar el contexto del repositorio, la búsqueda local, claims, handoffs, diagnósticos y protección mediante hooks nativos. Ejecute Codex, Claude Code u otro agente con su propio cliente; GuardianContext no inicia sesiones de agentes ni ofrece transporte MCP.

[Manual de uso](https://ironstack.dev.br/guardiancontext/manual/) · [Sitio del producto](https://ironstack.dev.br/guardiancontext/) · [Soporte](mailto:suporte@ironstack.dev.br)

### Para qué sirve

- Registrar las reglas y decisiones que deben seguir disponibles en las próximas sesiones.
- Buscar información del proyecto y preparar un resumen para una tarea, con fragmentos de los documentos y referencias a los archivos de origen.
- Reservar un ámbito de archivos por tiempo limitado con claims y registrar handoffs para continuar el trabajo en otra sesión.
- Comprobar la organización de los documentos con `guardian doctor` y `guardian audit`.
- Revisar la configuración del repositorio y la actividad local con `guardian doctor` y el diagnóstico de Desktop.

Estas funciones dependen de la configuración y de la participación de quienes trabajan en el proyecto. Sigue revisando los cambios, las pruebas y los commits. GuardianContext no garantiza que un agente cumpla las reglas registradas.

### Grafo de código y conocimiento del proyecto

Genera y consulta un grafo estructural local del código cuando lo necesites. Graphify es un ejecutable opcional que se instala por separado; GuardianContext no lo instala y su ausencia no afecta al paquete básico. También puedes exportar documentos versionados del proyecto a una carpeta propia del proyecto en el vault de Obsidian que elijas. Revisa la vista previa antes de exportar. La exportación es unidireccional y conserva las copias editadas, que se muestran como conflictos.

### Instalación con interfaz gráfica

El instalador oficial usa [uv](https://docs.astral.sh/uv/) para preparar un entorno con Python 3.11. Instala la interfaz gráfica, la búsqueda semántica, las funciones de seguridad y el componente obligatorio de actualización.

#### Windows, en PowerShell

```powershell
irm https://api.ironstack.dev.br/install.ps1 | iex
```

#### macOS o Linux

```sh
curl -fsSL https://api.ironstack.dev.br/install.sh | sh
```

Estos comandos descargan y ejecutan el instalador. Puedes abrir la URL y leer el script antes de ejecutarlo.

La instalación puede descargar Python y otros componentes. La búsqueda semántica descarga un modelo en el primer uso. En Linux, la interfaz gráfica también necesita las bibliotecas de Qt.

Cuando se abra Desktop Manager:

1. Crea una cuenta y acepta los Términos de Uso o inicia sesión con tu cuenta existente.
2. Elige la carpeta de un repositorio Git y el modo de trabajo del equipo.
3. Ejecuta la configuración y revisa el diagnóstico.

Si la ventana no se abre, ejecuta `guardian-desktop` en una terminal nueva.

#### Comprueba la configuración del agente

Tener una licencia activa o una buena puntuación en la auditoría no confirma que el agente esté usando GuardianContext.

Ejecute Codex, Claude Code u otro agente con su propio cliente. GuardianContext no crea nuevos servidores MCP de Guardian ni inicia sesiones de agentes. Los hooks nativos siguen disponibles y pueden configurar los archivos de hooks del cliente elegido. Tras actualizar a 0.1.18, Guardian revisa solo los proyectos que ya conoce. En configuraciones verificadas de Windows, Guardian elimina una entrada antigua solo cuando verifica la propiedad y los permisos de acceso, y el archivo no está cifrado con EFS. Antes de sustituir la configuración, crea una copia protegida fuera del repositorio durante 30 días. Si el archivo usa EFS, no se pueden verificar la propiedad o los permisos de acceso, o la plataforma es Linux o macOS, Guardian deja intacta la configuración e indica una limpieza pendiente; en Linux y macOS informa `permissions_unavailable`.

El diagnóstico informa por separado la configuración y la actividad registrada de claims o hooks, con el origen, alcance, fecha y resultado del último evento. Estos registros no demuestran la identidad de un agente, que haya leído las instrucciones ni que las haya seguido. La licencia Internal también requiere la configuración del proyecto.

### Instalación desde la terminal

Para probar la estructura de documentos y la búsqueda textual, instala el paquete básico con [uv](https://docs.astral.sh/uv/getting-started/installation/):

```sh
uv tool install --python 3.11 guardiancontext
cd meu-repositorio
guardian init
guardian doctor
```

Sustituye `meu-repositorio` por la carpeta de tu proyecto.

Estos comandos crean y comprueban la estructura local. Configure los hooks nativos por separado si el proyecto los necesita. Para conectar tu cuenta al servicio, ejecuta `guardian signup` o `guardian login` en esa carpeta. El comando solicita la contraseña durante la ejecución.

El paquete básico requiere Python 3.9 o posterior. Para los componentes opcionales se recomienda Python 3.11. El manual explica cómo instalarlos, configurar los hooks y elegir entre trabajar en la misma carpeta o en worktrees separados.

### Ejemplo: consultar una decisión antes de modificar la base de datos

Después de inicializar GuardianContext, crea el archivo `decisoes/0001-migrations.md`:

```markdown
# Migraciones de la base de datos

Toda migración debe incluir un plan de reversión y revisarse antes del despliegue.
```

Actualiza el índice y busca la decisión:

```sh
guardian index rebuild --lexical
guardian brief "migrations" --tool agents --max-tokens 1500
```

El primer comando actualiza la búsqueda local. El segundo prepara un resumen para la tarea, con los fragmentos encontrados y las rutas de los archivos de origen.

Entrega ese resumen al agente antes de que empiece el cambio y revisa las acciones propuestas.

El ejemplo usa la búsqueda textual del paquete básico. Los resultados dependen del contenido registrado y de los términos de búsqueda.

### Dónde están los archivos

La estructura predeterminada incluye:

- `router.md`, `wiki/` y `decisoes/` para organizar la información del proyecto.
- `claims/` y `handoffs/` para registrar reservas de trabajo y pasar contexto a una sesión posterior.
- `docs/trabalho/` para planes y referencias de apoyo. En este repositorio, las issues registran los trabajos y las claims reservan ámbitos de archivos.

El estado y el índice local están en `.guardian/`. Revisa los archivos generados antes de añadirlos a Git.

### Qué funciona sin conexión

Los comandos locales de estructura y búsqueda pueden funcionar sin conexión con el servicio.

El registro, la sincronización y las funciones sujetas a licencia tienen sus propios requisitos de conexión y autorización. El manual incluido en el paquete también se puede consultar sin conexión.

### Qué datos se envían al servicio

Los informes de auditoría envían métricas y recuentos. La sincronización de patrones envía metadatos y vectores. En las llamadas al servicio, el cliente también informa su versión, la interfaz utilizada y un identificador aleatorio del perfil de instalación.

El comando `guardian contribute` permite proponer un documento para la biblioteca seleccionada. Antes del envío, el texto se anonimiza y se presenta para tu revisión y confirmación. Comprueba el contenido para evitar compartir información sensible.

La clave de API se guarda en el perfil del usuario, fuera del repositorio. GuardianContext puede escribir la configuración de hooks nativos y limpiar entradas de Guardian cuya propiedad se haya demostrado y que dejó la integración MCP retirada; son operaciones locales distintas. No crea nuevos servidores MCP de Guardian ni inicia sesiones de agentes. Ejecute los clientes externos por separado.

### Actualizaciones

Las instalaciones oficiales usan actualizaciones automáticas con comprobaciones de seguridad. La actualización se aplaza mientras el runtime está en uso. Consulta el estado con `guardian update status`.

Otras formas de instalación pueden requerir actualizaciones manuales.

### Manual y soporte

El [manual completo](https://ironstack.dev.br/guardiancontext/manual/) está disponible en el sitio web. Para consultar el manual del paquete en español, inglés o portugués:

```sh
guardian manual --lang es
guardian manual --lang en
guardian manual --lang pt
```

Para informar de un problema, escribe a [suporte@ironstack.dev.br](mailto:suporte@ironstack.dev.br). Incluye el sistema operativo, la salida de `guardian --version`, la acción realizada y el mensaje de error. Elimina las credenciales y los datos privados de los registros.

GuardianContext es un producto de IronStack, distribuido bajo una licencia de uso propietaria. La licencia está en el archivo `LICENSE`, incluido en el paquete. Las condiciones del servicio se encuentran en los [Términos de Uso](https://api.ironstack.dev.br/termos).

---

## Português (Brasil)

[English](#english) · [Español](#español) · [Português (Brasil)](#português-brasil)

O GuardianContext ajuda você e seus agentes de IA a retomar o trabalho em um projeto. Ele organiza as regras, decisões e tarefas em arquivos Markdown dentro do repositório Git.

Antes de começar uma tarefa, você pode buscar nesses arquivos e reunir as instruções relevantes para entregar ao agente. Isso permite usar as decisões do projeto em diferentes sessões de Codex e Claude Code. Como os arquivos estão no Git, você também pode revisar o que mudou e consultar o histórico.

O GuardianContext reúne CLI e Desktop para contexto do repositório, busca local, claims, handoffs, diagnósticos e proteção por hooks nativos. Execute Codex, Claude Code ou outro agente no cliente próprio; o GuardianContext não inicia sessões de agentes nem oferece transporte MCP.

[Manual de uso](https://ironstack.dev.br/guardiancontext/manual/) · [Site do produto](https://ironstack.dev.br/guardiancontext/) · [Suporte](mailto:suporte@ironstack.dev.br)

### Para que serve

- Registrar as regras e decisões que precisam continuar disponíveis nas próximas sessões.
- Buscar informações do projeto e montar um resumo para uma tarefa, com trechos dos documentos e referências aos arquivos.
- Reservar um escopo de arquivos por tempo limitado com claims e registrar handoffs para continuar o trabalho em outra sessão.
- Verificar a organização dos documentos com `guardian doctor` e `guardian audit`.
- Conferir a configuração do repositório e a atividade local com `guardian doctor` e o diagnóstico do Desktop.

Esses recursos dependem da configuração e da participação de quem trabalha no projeto. Continue revisando as alterações, os testes e os commits. O GuardianContext não garante que um agente siga as regras registradas.

### Grafo de código e conhecimento do projeto

Gere e consulte um grafo estrutural local do código quando quiser. Graphify é um executável opcional, instalado separadamente; o GuardianContext não o instala e sua ausência não afeta o pacote básico. Também é possível exportar documentos versionados do projeto para uma pasta exclusiva do projeto no vault escolhido do Obsidian. Confira a prévia antes de exportar. A exportação segue em uma direção e preserva cópias editadas, que aparecem como conflitos.

### Instalação com interface gráfica

O instalador oficial usa o [uv](https://docs.astral.sh/uv/) para preparar o ambiente com Python 3.11. Ele instala a interface gráfica, a busca semântica, os recursos de segurança e o componente obrigatório de atualização.

#### Windows, no PowerShell

```powershell
irm https://api.ironstack.dev.br/install.ps1 | iex
```

#### macOS ou Linux

```sh
curl -fsSL https://api.ironstack.dev.br/install.sh | sh
```

Esses comandos baixam e executam o instalador. Você pode abrir a URL e ler o script antes de executá-lo.

A instalação pode baixar Python e outros componentes. A busca semântica baixa um modelo no primeiro uso. No Linux, a interface gráfica também precisa das bibliotecas do Qt.

Quando o Desktop Manager abrir:

1. Crie uma conta e aceite os Termos de Uso ou entre na sua conta existente.
2. Escolha a pasta de um repositório Git e o modo de trabalho da equipe.
3. Execute a configuração e confira o diagnóstico.

Se a janela não abrir, execute `guardian-desktop` em um terminal novo.

#### Confira a configuração do agente

Ter uma licença ativa ou uma boa nota na auditoria não comprova que o agente está usando o GuardianContext.

Execute Codex, Claude Code ou outro agente no cliente próprio. O GuardianContext não cria novos servidores MCP Guardian nem inicia sessões de agentes. Os hooks nativos continuam disponíveis e podem configurar os arquivos de hooks do cliente escolhido. Após atualizar para 0.1.18, o Guardian verifica somente os projetos que já conhece. Em configurações verificadas do Windows, o Guardian remove uma entrada antiga somente quando comprova a propriedade e verifica as permissões de acesso, e o arquivo não está criptografado com EFS. Antes de substituir a configuração, cria um backup protegido fora do repositório por 30 dias. Se o arquivo usar EFS, se não for possível verificar propriedade ou permissões de acesso, ou se a plataforma for Linux ou macOS, o Guardian mantém a configuração intacta e informa uma pendência; em Linux e macOS, registra `permissions_unavailable`.

O diagnóstico informa separadamente a prontidão da configuração e a atividade registrada de claims ou hooks, com origem, escopo, data e resultado do último evento. Esses registros não comprovam a identidade do agente, a leitura das instruções ou seu cumprimento. A licença Internal também exige a configuração do projeto.

### Instalação pelo terminal

Para experimentar a estrutura de documentos e a busca textual, instale o pacote básico com [uv](https://docs.astral.sh/uv/getting-started/installation/):

```sh
uv tool install --python 3.11 guardiancontext
cd meu-repositorio
guardian init
guardian doctor
```

Substitua `meu-repositorio` pela pasta do seu projeto.

Esses comandos criam e verificam a estrutura local. Configure hooks nativos separadamente se o projeto precisar deles. Para conectar a conta ao serviço, execute `guardian signup` ou `guardian login` nessa pasta. O comando solicita a senha durante a execução.

O pacote básico requer Python 3.9 ou superior. Para os componentes opcionais, o ambiente recomendado é Python 3.11. O manual explica como instalar esses componentes, configurar os hooks e escolher entre trabalhar na mesma pasta ou em worktrees separadas.

### Exemplo: consultar uma decisão antes de alterar o banco

Depois de inicializar o GuardianContext, crie o arquivo `decisoes/0001-migrations.md`:

```markdown
# Migrations de banco

Toda migration deve incluir um plano de rollback e ser revisada antes do deploy.
```

Atualize o índice e busque a decisão:

```sh
guardian index rebuild --lexical
guardian brief "migrations" --tool agents --max-tokens 1500
```

O primeiro comando atualiza a busca local. O segundo prepara um briefing: um resumo para a tarefa, com trechos encontrados e os caminhos dos arquivos de origem.

Entregue esse resumo ao agente antes de ele trabalhar na alteração e revise as ações propostas.

O exemplo usa a busca textual do pacote básico. Os resultados dependem do conteúdo registrado e dos termos usados na busca.

### Onde ficam os arquivos

A estrutura padrão inclui:

- `router.md`, `wiki/` e `decisoes/` para organizar as informações do projeto.
- `claims/` e `handoffs/` para registrar reservas de trabalho e passar contexto a uma sessão futura.
- `docs/trabalho/` para planos e referências de apoio. Neste repositório, issues registram as frentes e claims reservam escopos de arquivos.

O estado e o índice local ficam em `.guardian/`. Revise os arquivos gerados antes de adicioná-los ao Git.

### O que funciona sem conexão

Os comandos locais de estrutura e busca podem funcionar sem conexão com o serviço.

Cadastro, sincronização e recursos sujeitos a licença têm seus próprios requisitos de conexão e autorização. O manual incluído no pacote também pode ser consultado sem conexão.

### Quais dados são enviados ao serviço

O relatório de auditoria envia métricas e contagens. A sincronização de padrões envia metadados e vetores. Nas chamadas ao serviço, o cliente também informa sua versão, a interface usada e um identificador aleatório do perfil de instalação.

O comando `guardian contribute` permite propor um documento à biblioteca curada. Antes do envio, o texto passa por anonimização e é apresentado para sua revisão e confirmação. Confira o conteúdo para evitar o compartilhamento de informações sensíveis.

A chave de API fica no perfil do usuário, fora do repositório. O GuardianContext pode gravar a configuração de hooks nativos e limpar entradas Guardian cuja propriedade comprove, deixadas pela integração MCP aposentada; são operações locais distintas. Ele não cria novos servidores MCP Guardian nem inicia sessões de agentes. Execute os clientes externos separadamente.

### Atualizações

Instalações oficiais usam atualização automática com verificações de segurança. Quando o runtime está em uso, a atualização é adiada. Consulte o estado com `guardian update status`.

Outras formas de instalação podem exigir atualização manual.

### Manual e suporte

O [manual completo](https://ironstack.dev.br/guardiancontext/manual/) está disponível no site. Para consultar o manual do pacote em português, inglês ou espanhol:

```sh
guardian manual --lang pt
guardian manual --lang en
guardian manual --lang es
```

Para reportar um problema, escreva para [suporte@ironstack.dev.br](mailto:suporte@ironstack.dev.br). Informe o sistema operacional, a saída de `guardian --version`, a ação executada e a mensagem de erro. Remova credenciais e dados privados dos logs.

GuardianContext é um produto da IronStack, distribuído sob licença proprietária de uso. A licença está no arquivo `LICENSE`, incluído no pacote. As condições do serviço estão nos [Termos de Uso](https://api.ironstack.dev.br/termos).
