Agentic Task System (ats)

Seu gerenciador de tarefas é a melhor memória de agente que você não está usando.

ats é um servidor MCP e CLI que mantém o contexto de agentes de IA nos sistemas de tarefas que você já mantém — TickTick, Taskmaster, Beads, Obsidian, Notion, GitHub, Airtable, Google, ou vários ao mesmo tempo por meio do adaptador composto. Ele recupera tarefas, notas, decisões e runbooks relevantes com proveniência e pode gravar resultados de volta quando o adaptador ativo suporta gravações. Funciona com Claude Code, Claude Desktop, Cursor e qualquer cliente MCP.

Adaptador, não migração. Seu aplicativo de tarefas, repositório ou vault permanece autoritativo. O ATS mapeia essa fonte para um contrato comum de tarefas; caches opcionais e índices vetoriais melhoram a recuperação, mas nunca se tornam um segundo registro que as pessoas precisam editar. É tarefa-primeiro: a tarefa é a espinha dorsal, enquanto materiais de apoio, como issues do GitHub e especificações do Notion, são recuperados como contexto por trás dela.

Duas camadas, um CLI: tarefas e um grafo de conhecimento. A camada de tarefas é baseada em registros de propósito — cada entrada vive nos projetos e campos de um backend, e esse backend permanece autoritativo. Uma camada baseada em registros estruturalmente não pode conter a outra coisa que agentes acumulam: conhecimento durável escrito de qualquer fonte, sobre assuntos mistos, em um único espaço. A camada de grafo de conhecimento — ats kg (kg = knowledge graph) — é a resposta do ATS exatamente para isso: fatos sujeito–predicado–objeto com proveniência e validade temporal, propostos por agentes de qualquer lugar (uma chamada, uma tarefa, um repositório, um chat), ratificados por um humano e consultados em um único lugar, independentemente de qual backend o trabalho ao redor vive. O armazenamento embutido é integrado e sem dependências. Para um motor de grafo dedicado, a combinação recomendada é Graphiti como servidor de banco de dados de grafo e LadybugDB como banco de dados de grafo embutido: ats kg export --cypher emite um script carregável pelo LadybugDB, e ats kg export (JSON, com proveniência completa) está pronto para um pipeline de ingestão do Graphiti.

npm install -g @reneza/ats-cli @reneza/ats-adapter-ticktick
ats config use ticktick
ats auth login
ats find "deployment runbook"

Um ats find em GitHub + Notion + TickTick. O ATS classifica os ramos de recuperação disponíveis com RRF e retém a proveniência dos resultados.

Arquitetura e limites de confiança

O ATS separa o registro autoritativo da maquinaria de recuperação ao redor dele:

AI client or operator
        |
        | local stdio, or token-gated HTTP when self-hosted
        v
ATS CLI / MCP server
        |
        +-- Core: task contract, links, lifecycle, ledger, events
        +-- Retrieval: keyword + native + optional dense branches -> RRF
        |
        v
Adapter boundary (auth, mapping, reads, patch-style writes)
        |
        +-- TickTick / Notion / GitHub / Airtable / Google
        +-- Obsidian / Taskmaster / Beads / OKF files
        |
        +-- derived retrieval state
            corpus cache + optional Qdrant/Ollama index

• O backend permanece autoritativo. O ATS não pede que usuários editem um banco de memória duplicado. Gravações passam pelo adaptador ativo, que é dono da autenticação específica do backend, do mapeamento de campos e dos deep links.
• O estado de recuperação é derivado, não canônico. O Core mantém um cache de corpus de cinco minutos por padrão. A recuperação densa é opcional: adaptadores podem fornecer embeddings, e o adaptador de referência TickTick pode usar Qdrant mais Ollama. Sem vetores, ramos de palavras-chave e nativos do adaptador ainda rodam.
• Credenciais ficam na fronteira do adaptador. Um adaptador composto delega autenticação a cada filho e não armazena credencial adicional entre fontes. Seus filhos ainda executam dentro de um único processo do ATS; isso é separação de roteamento, não isolamento de processo. O stdio local não expõe uma porta MCP. O blueprint hospedado adiciona um gateway com token bearer, serviços privados Qdrant/Ollama e um backend de demonstração público separado para o painel do operador opcional.
• O Core relata as falhas que consegue ver. Falhas de ramos de recuperação e de corpus composto de nível superior retornam degraded e warnings. Caminhos de omissão conhecidos dentro de fallbacks de adaptadores são destacados em Tradeoffs e limites.
• Mudanças de estado são rastreáveis. Resultados carregam proveniência de fonte; find --explain expõe contribuições de RRF; gravações usam semântica de patch, e gravações suportadas podem reter imagens anteriores para desfazer.

O cache de corpus pode conter registros completos de tarefas; o log de consultas contém texto de busca; o livro-razão de ações pode conter imagens anteriores de gravações; e payloads do Qdrant podem conter texto e metadados de tarefas além de embeddings. O ATS não aplica criptografia em nível de aplicação ou redação em tempo de execução a essas cópias. Escopar acesso ao host, backups, retenção e implantação à sensibilidade dos sistemas de tarefas subjacentes. Veja recuperação, integridade de estado e o guia de implantação para o comportamento exato.

Opções de implantação

Modo	Recuperação	Limite de confiança e operações
Stdio local	Recuperação por palavras-chave/nativa por padrão; recuperação densa apenas quando o adaptador a fornece	O endpoint MCP não é exposto à rede. Chamadas de adaptador ainda podem alcançar seus sistemas de origem; credenciais e arquivos de cache ficam na máquina que executa o ATS.
Adaptador composto	Um corpus filho combinado; o Core classifica ramos de palavras-chave e busca nativa unificada, com RRF entre os ramos disponíveis. O composto atualmente não expõe busca vetorial de filhos.	Cada filho é dono de sua autenticação e mapeamento, mas roda no mesmo processo do ATS. Uma falha de corpus filho de nível superior é relatada como degradada; veja as lacunas de fallback conhecidas abaixo.
Blueprint hospedado	Recuperação por palavras-chave/nativa mais serviços privados Qdrant/Ollama	Um gateway MCP com token bearer e um backend separado opcional para o painel do operador são públicos; Qdrant e Ollama ficam na rede de serviços privados. Qdrant/Ollama têm discos, enquanto arquivos de runtime do ats-mcp são efêmeros por padrão. Você opera rotação de tokens, persistência, backups, disponibilidade e custo de hospedagem.

“Sem migração” significa sem segunda fonte de verdade. Não significa zero armazenamento derivado.

Como se compara

Abordagem	Registro autoritativo	Estado adicional	Recuperação
CLAUDE.md / arquivos de memória	Markdown mantido para o agente	Os próprios arquivos	Busca de arquivo inteiro ou específica do harness
Serviço de memória separado	Banco de dados específico do agente	Um corpus e um caminho de ingestão para manter	Específico do produto
Conector de backend simples	Aplicativo de tarefas, repositório ou vault de origem	Geralmente nada além do estado do conector	Busca direta ou busca nativa do backend
ATS	Aplicativo de tarefas, repositório ou vault de origem	Cache, estado de consulta/ação/evento; índice vetorial derivado opcional	Palavras-chave + nativa + recuperação densa opcional, RRF, proveniência, contexto tipado

O ATS é uma boa escolha quando o contexto operacional já vive em sistemas de tarefas ou ferramentas de trabalho conectadas e agentes precisam de recuperação classificada e rastreável entre eles. Se Markdown limpo já é a fonte completa de verdade e o carregamento de arquivos inteiros permanece pequeno, um fluxo de trabalho nativo de arquivos pode ser mais simples.

O que você obtém

• Um barramento bidirecional. O agente lê os campos de tarefa que um adaptador fornece; onde o adaptador suporta gravações, ele grava resultados de volta onde você os verá.
• Relevância na primeira busca. Ramos orientados por capacidade — palavras-chave e busca nativa do adaptador, mais recuperação densa quando disponível — são fundidos com RRF e proveniência para reduzir loops repetidos de busca e refinamento.
• Links tipados duráveis. Um agente anexa um link decision / depends-on / output / supersedes; um agente posterior em um contexto novo o recebe via ats context. A transferência vive no aplicativo de tarefas, não em um log de chat.
• Contexto de execução. ats intent captura resultado/porquê/quando-concluído; ats lifecycle impede que contexto obsoleto direcione o trabalho atual; ats security registra decisões de permitir/negar com escopo para clientes cooperantes; ats ledger registra o que um agente fez e se a tarefa avançou; ats promote transforma exploração em uma meta comprometida; ats hierarchy evaluate verifica se o trabalho local ainda suporta seu pai.
• Eventos limitados. ats events watch --json emite NDJSON determinístico task.created/updated/completed/..., com spool 0600 e recuperação de pendências/acks e IDs de deduplicação estáveis. O ATS apenas emite observações — um consumidor ainda avalia intenção, validade e segurança antes de agir.
• Grafo de tarefas para agentes. Tarefas se tornam nós estruturados com prova, gravação de volta, revisão, ciclo de vida e arestas de link em vez de texto de memória livre; veja docs/task-graph-for-agents.md.
• Uma camada de fatos. ats kg mantém conhecimento durável sujeito–predicado–objeto ao lado das tarefas: agentes propõem, um humano ratifica (o único caminho de gravação), e ats kg ask responde com pontuação lexical determinística mais proveniência completa — sem LLM, sem servidor de grafo, um arquivo somente anexação que viaja com ats state export. Retração fecha o intervalo de validade de um fato em vez de excluí-lo, e ats kg export --cypher carrega o grafo em motores embutidos (LadybugDB/Kùzu).
• Transferência de índice de sessão. Navegadores de sessão de agentes de codificação podem manter análises brutas de transcrições enquanto o ATS armazena o resumo durável vinculado à tarefa; veja docs/agent-session-index.md.

Metadados de execução gerenciados pelo ATS podem ser codificados no corpo da tarefa, com links tipados sob ## Related e fontes consultadas sob ## References. Helpers gerenciados são projetados para preservar linhas e links criados por humanos, mas uma atualização direta de conteúdo pode substituir o corpo completo; chamadores devem ler primeiro, gravar a menor mudança pretendida e verificar o resultado. npm run prove:intent executa uma prova sintética determinística do caminho de contexto de execução.

Fluxo de trabalho mínimo neutro de adaptador

1. Selecione e verifique um adaptador: ats config use <adapter>, autentique conforme descrito no README dele, então execute ats doctor.
2. Recupere o conjunto de trabalho: ats find "deployment runbook" --json classifica os ramos disponíveis desse adaptador e retém proveniência.
3. Inspecione o item autoritativo e seu contexto: ats context <project> <task> usa o contrato comum de adaptador e não requer uma camada de notas específica do adaptador.
4. Anexe contexto de execução durável: ats intent set <project> <task> --outcome "..." --done-when "a,b" e ats link add <src-project> <src-task> <dst-project> <dst-task> --type depends-on.
5. Verifique a transferência montada: execute novamente ats context <project> <task> para ler de volta decisões vinculadas, dependências, prova, estado de ciclo de vida e resultados de recuperação relevantes.
6. Grave pelo adaptador ou aplicativo de origem e leia de volta. Mantenha o backend autoritativo atualizado para que o próximo agente receba estado durável em vez de uma transferência apenas por chat.

Implante você mesmo

O painel do operador opcional é um aplicativo web estático voltado para celular, implantável em Cloudflare Pages. O blueprint fornecido do Render constrói o gateway/servidor MCP mais serviços privados Qdrant e Ollama.

Após a implantação, copie o ATS_MCP_TOKEN gerado automaticamente da aba Environment do serviço ats-mcp, aponte seu cliente MCP para https://<your-mcp-url>/mcp com o cabeçalho Authorization: Bearer <ATS_MCP_TOKEN> e defina TICKTICK_ACCESS_TOKEN para ler suas tarefas reais. Prefere sua própria máquina ou um VPS? Mesmas peças como contêineres Docker simples — veja o guia de implantação.

Adaptadores disponíveis

Conectores de backend permitem que um agente alcance Notion, GitHub e sistemas de tarefas, mas acesso sozinho não fornece uma resposta classificada para uma pergunta como "o que eu sei sobre a migração de autenticação?" O ATS adiciona uma camada comum de recuperação: o adaptador composto combina corpora filhos instalados, define namespaces para seus IDs de projeto, une resultados de busca nativa suportados e permite que o Core classifique os ramos disponíveis com proveniência. Cada filho lê suas próprias credenciais, mas todos os filhos configurados executam no mesmo processo do ATS.

Adapter	Fonte autoritativa	Notas de recuperação ou gravação
ticktick	TickTick OpenAPI v1	Recuperação por palavra-chave/nativa funciona sem vetores; Qdrant + Ollama opcionais adicionam recuperação densa.
obsidian	Cofre Markdown local	Nativo de arquivos, gravações em estilo patch preservam frontmatter desconhecido.
okf	Pacote Markdown do Open Knowledge Format	Pacote local.
taskmaster	.taskmaster/tasks/tasks.json local	Estado de tarefas local ao repositório.
beads	Beads local ao repositório via bd --json	Estado de tarefas local com consciência de dependências.
airtable	API REST do Airtable (tabela = projeto)	Acesso à API com escopo do adapter.
google	Google Sheets / Docs / Slides	Somente leitura.
notion	Bancos de dados e páginas do Notion	Acesso com escopo de integração.
github	Issues e discussões do GitHub	Acesso com escopo de repositório.
composite	Backends filhos instalados	Combina corpora filhos, namespaces de IDs de projeto, une resultados de busca nativa e roteia gravações; não é um armazenamento de registros independente e atualmente não expõe embeddings filhos.
things / apple-notes / google-tasks	—	Lista de desejos, não implementado.

Autenticação e mapeamento por adapter vivem no README de cada pacote. PRs são bem-vindos — faça scaffold e verifique contra o contrato:

ats adapter new linear              # writes a contract-complete skeleton
ats adapter test ./ats-adapter-linear   # pass/fail/skip per contract check

Tradeoffs e limites

• A atualização depende do adapter. O cache de corpus do Core tem um TTL padrão de cinco minutos. O comportamento de sincronização do backend, a paginação e a inclusão de trabalho concluído variam por adapter; a ATS não promete leituras em tempo real universais. ats cache sync atualiza o cache sob demanda (compatível com cron) — incrementalmente quando o adapter implementa bulkFetchDelta(), como uma nova busca completa caso contrário.
• A recuperação densa adiciona infraestrutura. Qdrant e Ollama podem melhorar a recuperação semântica, mas adicionam trabalho de indexação, persistência, recursos e backup. A find de linha de base ainda retorna resultados por palavra-chave/nativos quando vetores não estão disponíveis, embora uma tentativa de ramo vetorial possa degradar a resposta; operações hybrid e similar somente com vetores ainda exigem essa infraestrutura.
• O contrato comum é intencionalmente pequeno. A interface do adapter define seis métodos de armazenamento mais ganchos de ciclo de vida de autenticação, enquanto a cobertura prática de gravação, campos mais ricos e busca nativa variam. Verifique o README do adapter antes de assumir paridade entre backends.
• Resultados degradados ainda são resultados parciais. A ATS relata ramos do Core com falha ou timeout, fontes de corpus descartadas — incluindo falhas por projeto dentro de uma busca composta de fallback e buscas de projetos do TickTick — e fontes de busca nativa que um backend não conseguiu ler. O chamador ainda deve decidir se contexto parcial é aceitável; warnings diz o que está faltando, não se isso importava.
• A busca composta não é deduplicação semântica. ats dedup é um comando de análise separado. A identidade de fusão tem namespace por backend (<backend>:<taskId>), então IDs brutos idênticos de backends diferentes permanecem resultados distintos; tarefas semanticamente duplicadas ainda aparecem separadamente até você vinculá-las.
• O blueprint hospedado é uma implantação de referência, não um serviço gerenciado. Um token de portador concede toda a superfície de ferramentas MCP; o blueprint não fornece escopos por usuário ou por ferramenta, RBAC multi-tenant, alta disponibilidade ou SLA.
• O estado do runtime da ATS hospedada é efêmero por padrão. O blueprint persiste Qdrant e Ollama, mas não monta um disco para ats-mcp; seu cache, log de consultas, ledger de ações e imagens anteriores de desfazer, spool de eventos e metadados de sincronização de vetores desaparecem em um reinício ou reimplantação.
• Eventos são observações, não autorização. ats events watch pode relatar mudanças de tarefas, mas um consumidor ainda deve avaliar intenção, validade e segurança antes de tomar uma ação externa.
• A camada de fatos é lexical e controlada por humanos. ats kg ask é pontuação determinística por palavra-chave com proveniência, não busca semântica, e nada chega ao armazenamento de fatos sem ratificação humana — uma rajada de propostas de agentes espera revisão por design.
• A política da ATS não é uma sandbox. A CLI aplica os metadados de aprovação declarados — uma gravação cujo alvo define intent.approvalRequired ou lista a ação em security.approvalRequiredFor entra em ats review em vez de alcançar o backend (ATS_REVIEW_ALL=1 controla cada gravação) — mas isso protege apenas o caminho de gravação da própria ATS. ats security check permanece um ponto de decisão em nível de aplicação para clientes cooperativos, e nada aqui intercepta acesso a shell, sistema de arquivos, rede, modelo ou segredos fora da ATS. Um cliente chamando um adapter diretamente contorna o controle da CLI.

Verificação e evidência operacional

• CI executa o gate completo do repositório no Node 20 e 22: lint, verificações de alegações públicas, verificações de PII, testes unitários, provas de adapter e intenção, e o benchmark de progresso.
• O gate de segurança de publicação verifica tanto a superfície do repositório quanto os tarballs de pacotes npm em busca de segredos, caminhos pessoais, padrões de dados pessoais configurados e termos de denylist configurados localmente. Ele protege superfícies de publicação. Em runtime, o adapter composto pode adicionalmente aplicar níveis de confiança por backend com padrões de redação configurados — uma gravação roteada para um filho "trust": "public" que corresponde a um padrão é bloqueada, não silenciosamente removida (veja o README do composto). Essa tela protege o caminho de gravação composto da própria ATS; não é prevenção geral de perda de dados.
• Testes de integridade de estado e convenções cobrem gravações em estilo patch, preservação de campos desconhecidos, mapeamento explícito de armazenamento para Task, proveniência de resultados e contribuições RRF explicáveis.
• Comportamento de recuperação documenta os ramos do Core, o cache de corpus, orçamentos de tempo, falha graciosa de ramos, registro de uso e o que afeta a latência.

Esses gates verificam o comportamento do repositório; não são uma certificação de disponibilidade ou segurança de produção.

Superfície CLI

# Lifecycle
ats init [adapter]                  # select an adapter and run a health check
ats config use <adapter>            # switch the active adapter
ats auth login                      # delegate login to the active adapter
ats doctor                          # inspect adapter and service health

# Retrieval  (any read command takes --json for piping to jq / agents)
ats find <query> [--explain]       # parallel + RRF + provenance — DEFAULT
ats open <project> <task>          # open any adapter item by explicit ids
ats context <project> <task>       # task + valid linked/retrieved context
ats link list <project> <task>     # list portable typed links
ats hybrid <query>                 # dense+sparse retrieval when embeddings exist
ats similar <id>                   # related items when embeddings exist

# Notes-layer shortcuts (currently TickTick and Obsidian)
ats get <id-or-title> [--extract raw|json|yaml]
ats url <id-or-title>              # paste-ready note cross-reference
ats links <project> <task>         # resolve deep-links in a note body

# Authoring
ats create "<title>" [--content ..][--project <id>]
ats update <project> <task> [--content ..][--title ..]

# Agent execution context (portable across adapters)
ats intent set <project> <task> --outcome ".." --done-when "a,b"
ats promote <src-proj> <src-task> <target-proj> --outcome ".." --done-when "a,b"
ats hierarchy set <project> <task> --kind task
ats hierarchy evaluate <project> <task>
ats lifecycle set <project> <task> --status active --valid-until 2026-12-31
ats link add <src-proj> <src-task> <dst-proj> <dst-task> --type decision
ats graph <project> <task>
ats context <project> <task>

# Facts layer (proposed by agents, ratified by you)
ats kg propose "Acme GmbH" "prefers" "invoices as PDF" --domain sales --source "call 2026-08-01"
ats review approve <id> && ats kg ratify --all
ats kg ask "what does Acme prefer" --domain sales --json
ats kg export --cypher > facts.cypher      # load into LadybugDB / Kùzu
ats ledger record <project> <task> --action release.verified --advanced true
ats security set <project> <task> --trust trusted --allow-actions read --allow-resources task:self
ats security check <project> <task> --action read --resource task:self --reason "load context"
ats events watch --json            # NDJSON observations; never launches agents

# Ops
ats review list                 # writes staged by approvalRequired targets
ats review approve ID && ats review apply --all
ats cache sync                  # refresh the corpus cache (cron-friendly)
ats bench run
ats bench score
ats bench progress --json
ats bench analyze-usage --days 7
npm run prove:intent
npm run prove:taskmaster
npm run prove:beads
npm run prove:progress

Use de qualquer cliente MCP (Claude Code, Claude Desktop, Cursor, Windsurf, OpenCode)

@reneza/ats-mcp expõe o adapter ativo como um conjunto de ferramentas abrangendo recuperação, CRUD e contexto de execução (find, get_task, create_task, set_task_intent, add_task_link, resolve_task_links, context_for_task, record_action, undo_write, poll_task_events e mais). Para Claude Code, isso fornece contexto persistente entre sessões sem substituir o sistema de tarefas como fonte de verdade; caches opcionais e índices vetoriais permanecem estado de recuperação derivado.

A ATS fala MCP sobre stdio, então qualquer cliente que possa iniciar um servidor MCP stdio funciona. Apenas o arquivo de configuração e a chave de wrapper diferem; o binário (ats-mcp) e seu env ATS_ADAPTER são os mesmos em todos os lugares.

Cliente	Onde a configuração vive	Chave de wrapper
Claude Code	claude mcp add (abaixo)	n/a
Claude Desktop	claude_desktop_config.json	mcpServers
Cursor	~/.cursor/mcp.json	mcpServers
Windsurf	~/.codeium/windsurf/mcp_config.json	mcpServers
OpenCode	opencode.json	mcp (formato difere, abaixo)

# Claude Code
claude mcp add ats -e ATS_ADAPTER=@reneza/ats-adapter-ticktick -- ats-mcp

// Claude Desktop / Cursor / Windsurf — identical `mcpServers` shape
{
  "mcpServers": {
    "ats": { "command": "ats-mcp", "env": { "ATS_ADAPTER": "@reneza/ats-adapter-ticktick" } }
  }
}

// OpenCode (opencode.json) — local stdio server, note `command` is an array
{
  "mcp": {
    "ats": {
      "type": "local",
      "command": ["ats-mcp"],
      "environment": { "ATS_ADAPTER": "@reneza/ats-adapter-ticktick" },
      "enabled": true
    }
  }
}

Instale o binário no PATH primeiro (npm i -g @reneza/ats-cli), ou use um caminho absoluto para ats-mcp se seu cliente não herdar seu PATH do shell.

Convenções

• Projeto wiki. Um projeto designado (padrão Permanent Notes) mantém conhecimento durável; outros mantêm tarefas efêmeras.
• Notas de dados de agente = uma nota cujo corpo tem um bloco cercado json / yaml block, extracted via ats get <title> --extract json.
• Referências cruzadas = deep links nativos do adapter — gere com ats url <title>, não escreva manualmente.
• Padrão completo: docs/wiki-conventions.md.

Integridade de estado

A ATS testa reescritas de metadados gerenciados para preservação de campos escritos por humanos, exige mapeamento explícito de armazenamento para Task e carrega proveniência de resultados (sources, find --explain). Cobertura e comportamento de atualização bruta permanecem específicos do adapter. Um gate de segurança de publicação (check-no-pii.mjs) falha o build quando padrões de dados pessoais cobertos aparecem em superfícies de repositório ou pacote. Nota completa: docs/state-integrity.md.

Para o modelo operacional do lado do agente, veja docs/task-graph-for-agents.md: o texto da tarefa é a projeção humana, mas a camada de execução precisa de links estruturados, comandos de prova, requisitos de revisão e alvos de writeback.

Trabalhando na ATS

Contribuições são bem-vindas — correções de bugs e especialmente novos adapters sob packages/adapter-*. Veja CONTRIBUTING.md para a configuração de desenvolvimento e o padrão de adapter, e AGENTS.md se você dirige um agente de codificação sobre o repositório. Trabalhando no código-fonte, pi-codegraph dá ao seu agente um grafo de chamadas do monorepo — o padrão de adapter e o raio de impacto de uma mudança no core — para que ele pare de reler a árvore inteira a cada sessão.

Lançamentos e licença

v0.10.0 adicionou relatórios de recuperação parcial, reranking opcional, observabilidade de uso, detecção de duplicatas/contradições e atualização reativa de OAuth. v0.9.0 adicionou gravações reversíveis, links diretos/pendentes, endurecimento de caminhos do Obsidian e configuração stdio verificada para mais clientes. Histórico completo: CHANGELOG.md.

MIT. Veja LICENSE.

Se a ATS é útil, considere um ⭐ — ajuda outros a encontrá-la.