agentleFS
gabrielh-silvestregabrielh-silvestre/hexlog/scripts/AGENTS.md

hexlog / scripts

AGENTS.md4 starsChanged 19 days agoMITView on GitHub

Parent context: ../AGENTS.md Generated: 2026-09-17 · Updated: 2026-10-07

The file

Files
AGENTS.md

scripts

Parent context: ../AGENTS.md Generated: 2026-09-17 · Updated: 2026-10-07

Purpose

Entrypoints reais de build, instalação e relatório do hexlog. build.ts e install.ts ligam as funções de src/guard.ts e src/installation.ts, que recebem a execução externa por parâmetro, à I/O de verdade: esbuild, fs, child_process e o cliente MCP. insights.ts lê os logs já gravados e imprime um relatório, sem escrever nada; export.ts despeja o log de um processo em JSONL, também sem escrever; timeline.ts cruza os processos de um projeto por prefixo de target e imprime a linha do tempo (com anexos e estado de integridade), também sem escrever; seat-report.ts lê os registros dos tipos da cadeira do dono (lacuna, resposta e aval) e separa as respostas pelo que já foi auditado, sem escrever. Esses relatórios leem por src/compose.ts#composeReader (só o lado de leitura, sem serviço de escrita) e recusam dado 0.x com exit 2. release-notes.ts e release-notes-cli.ts são de outro tipo: o release.yml os roda sem npm ci, então só usam builtins do Node e leem apenas o CHANGELOG.md, sem src/ e sem dado.

Key Files

FileDescription
build.tsBuilda com esbuild os dois entrypoints (server: src/server.ts, bash-guard: hook/bash-guard.ts) para ESM node24, bundled, extensão .mjs. Sempre resolve a partir da raiz do repo (import.meta.dirname), nunca do cwd, pra garantir os mesmos bytes independente de quem chama. Exporta build() (usado por install.ts com write: false para pegar os bytes em memória) e repoRoot
install.tsInstalador/verificador versionado. node scripts/install.ts builda os bundles, verifica o artefato preparado antes de trocar qualquer coisa (hook nega D/permite o resto; servidor sobe e anuncia as 12 tools), copia para ~/.local/lib/hexlog/<versão>/ com troca atômica, grava manifest.json (sha256, commit, dirty), copia as skills de skills/ para ~/.claude/skills/<nome>/ (writeSkillFolder, antes de tocar o settings.json, para uma falha da troca não deixar o guard novo com skills antigas), registra as 4 regras de deny + o hook PreToolUse em ~/.claude/settings.json (backup em settings.json.bak-hexlog) e registra o servidor MCP via claude mcp add/remove, levando o env de mcpServers.hexlog para a entrada refeita (-e K=V) e imprimindo só os nomes (mcp env preserved: A, B), nunca os valores. A saída é só o resumo `hexlog <versão>: installedreinstalledrepaired(oualready installed and intact; nothing to do), os dois sha256, settings.json: updatedalready correcte as linhaswarning: .... node scripts/install.ts --checksó verifica, sem tocar em nada: ignora--archive-0xe nem chamadetectLegacy, então um <D> ilegível (EACCES, ENOTDIR) não o derruba. Regra de permissions.denyde um<D> antigo que o guard tira é impressa (removed deny rule: <regra>), nunca em silêncio. Com dado 0.x em <D> (adapters/fs/data-format.ts#detectLegacy), sem flag lista o que src/archive.ts#inspectLegacyarquivaria e sai 2 sem alterar<D>nem a instalação;--archive-0xrodaarchiveLegacye segue para a instalação (imprime arquivos e caminho do.tar, ou removed N empty 0.x directoriesquando só havia diretórios vazios;ArchiveError: stderr, exit 1, sem instalar). A listagem cita <D>/archive/porque o nome do.tarsó existe depois dearchiveLegacy. Argumento desconhecido é recusado com exit 1 antes de qualquer escrita (coberta em test/install.spec.ts, describe scripts/install.ts`)
cli-error.tsformatCliError(prefix, error): a linha <prefix> failed: CODE: message (detalhes) e o exit code (2 para LEGACY_DATA e PROCESS_CORRUPTED, 1 para o resto) dos scripts de leitura; a recusa de dado 0.x vem de src/errors.ts#legacyDataError, a mesma do kernel MCP. Omite o detalhe que só repete a mensagem (project not found (project not found)) e mantém o processo: do PROCESS_CORRUPTED. reportCliError(prefix, error) imprime essa linha no stderr e devolve o exit code: é o catch de main do export, insights, timeline, seat-report, flow gate e flow reanchor. openReadOnly() abre o composeReader sobre o <D> de XDG_DATA_HOME e lança LEGACY_DATA com dado 0.x (o preâmbulo único de quem lê o log). parseCliArgs(argv, options) é o node:util#parseArgs estrito: opção desconhecida ou sem valor devolve undefined, e o script imprime o uso com exit 1
escape-controls.tsescapeControls(text): troca C0 (menos LF e TAB), DEL, C1, os controles bidi, U+2028/U+2029, os tag characters (U+E0000 a U+E007F) e os seletores de variação U+E0100 a U+E01EF por \uXXXX visível (minúsculo, como o JSON.stringify); o caractere fora do plano básico sai como um escape por unidade UTF-16. Mora em módulo próprio porque importar timeline.ts executaria o main; o timeline.ts e o flow/critic-run.ts o usam
release-notes.tsreleaseNotes(changelog, version, pr?): monta o corpo do GitHub Release a partir da seção ## [version] do CHANGELOG.md (parágrafo de abertura, linha "PR da release" se houver PR, subseções com ### virando ## fora de cerca de código e bloco de instalação literal); as três buscas (fim da seção por ## , 1º ### e rebaixe) seguem a cerca do CommonMark (crases ou til, fecho do mesmo caractere e tamanho igual ou maior, até 3 espaços de recuo) por outsideFences; seção ausente ou vazia lança. Só builtins e nenhum import de src/, porque o release.yml roda sem npm ci
release-notes-cli.tsCLI fino do release.yml: lê o CHANGELOG.md da raiz e imprime releaseNotes. Uso: node scripts/release-notes-cli.ts <version> [--pr <number> --repo <owner/repo>] (--pr vazio equivale a sem PR; --repo exige --pr, mesmo vazio, e o formato dono/nome); uso incorreto ou versão sem seção sai com release-notes failed: ... e exit 1
insights.tsRelatório markdown read-only (integridade da cadeia, linha do tempo e sinais da key: possível duplicata sem chave, chave em excesso (lote de 1 registro com key cuja impressão nenhum outro lote repete) e percentual de lotes com chave por tipo) sobre os registros do hexlog, lidos por composeReader (loadProcess para os elos crus; list e listProjects do ProcessReader para enumerar sem ler o manifesto, então um process.json ilegível vira só a linha do processo e o relatório dos demais sai inteiro). Cadeia quebrada imprime N valid records e, sem nenhum elo válido, timeline: unavailable (chain broken). A chave em excesso é um proxy: o reenvio com a mesma key devolve replayed sem gravar, então o log não registra "nunca teve reenvio"; as seções de gates e forks do 0.x saíram porque evaluate_gate não grava mais. Uso: node scripts/insights.ts [projeto[/processo]]; lê o diretório de dados via dataDir/XDG_DATA_HOME. Exit pela regra única dos scripts de leitura (tabela abaixo); main devolve o maior código dos processos. Argumento desconhecido ou a mais sai com o uso e exit 1. Sem script npm dedicado; nunca escreve no diretório de dados
export.tsExportação read-only dos registros de um processo em JSONL, uma linha por registro (inclui os não vigentes), lidos por composeReader em uma única consulta sem laço de cursor (o teto de 64 MiB por processo limita a memória). Uso: node scripts/export.ts <project>/<process> [--fields a,b,c]; --fields projeta só as chaves pedidas e recusa nome fora das chaves de QueryRecord (que incluem inheritedIn e inheritedOut); --fields sem valor, flag desconhecida e argumento a mais saem com o uso e exit 1. Cadeia adulterada ou dado 0.x saem com 2; demais erros saem com export failed: ... e exit 1. Sem script npm dedicado; nunca escreve no diretório de dados.
timeline.tsLinha do tempo read-only de targets por consulta de alcance projeto com registros não vigentes, lida por composeReader, sem teto de página nem de texto por entrada, numa consulta só sem laço de cursor (o teto de 64 MiB vale por processo e o alcance projeto soma todos eles, limite aceito, pendência aberta sem ADR): o caminho para ler anexo grande. Uso: node scripts/timeline.ts <project> <target-prefix>... [--full] [--json] [--raw]. Texto legível por padrão (uma seção por target, marca [superseded by <id>]/[revoked by <id>], relações de entrada e saída, e as herdadas como inherited in:/inherited out: com a origin); --full imprime cada anexo entre ----- attachment <hash> (<n> bytes) ----- e ----- end -----; --json é JSONL (kind: "record"). A saída (texto e --json) passa uma vez por escapeControls na string final antes do process.stdout.write: ESC, CSI, OSC, U+009B, U+009D e os controles bidi saem como \uXXXX visível, e o --json volta ao original no JSON.parse. --raw imprime o byte exato (o --full --raw entre os delimitadores é idêntico ao anexo) e fica por conta de quem lê. Um anexo com a linha ----- end ----- ainda forja o delimitador no modo texto. Exit 0 íntegro, 2 cadeia, process.json ou anexo quebrado e dado 0.x, 1 uso incorreto ou erro (timeline failed: CODE: msg). Sem script npm dedicado; nunca escreve no diretório de dados
seat-report.tsRelatório read-only da auditoria da cadeira do dono, lido por composeReader (openReadOnly) em uma consulta por papel, sem laço de cursor (o teto de 64 MiB por processo limita a memória). Lê os registros vigentes dos três papéis do pacote de skills/hexlog-setup/references/owner-seat/ (gap, premise, audit) e identifica as arestas pela espécie (answers, supports) e por current, então sobrevive ao mapeamento de nomes de --types. Aval é a aresta supports vigente que chega de um registro do tipo audit; o audit de retirada (o carregador de um revokes, sem essa aresta) é ignorado. Seções exclusivas, por precedência: respostas simuladas sem critério (basis: judgment, basis ausente ou basis: rule sem rule ou sem criteria), lacunas abertas, simuladas não auditadas, auditadas, humanas, sem answeredBy, com answeredBy não reconhecido (ex.: simulated-approved, nunca contado como humano) e respostas a lacuna não vigente (oito seções). Cada linha traz id, target, author.agent, author.model, author.client, rule, hash curto do criteria, actionUsed e, nas respostas, answeredBy="…"; todo valor controlado pelo agente sai entre aspas por JSON.stringify, e a linha marca a resposta humana cujo agent é de ocupante e o aval do mesmo autor da resposta (a conferência segue manual). Não lê anexo: a regra citada não é conferida contra o texto do criteria. Uso: node scripts/seat-report.ts <project> [--process <name>] [--types gap=<t>,premise=<t>,audit=<t>]; sem --process lê o alcance projeto. A saída passa por escapeControls; uso incorreto sai com seat-report failed: usage: ... e exit 1, e papel sem registro cujo tipo não existe no projeto sai com INVALID_INPUT (/types, unknown-type) e exit 1, para que pacote ausente ou --types errado não passe por "nada a auditar". Sem script npm dedicado; nunca escreve no diretório de dados

Fluxo autônomo (flow/)

CLIs do fluxo guiado por diretrizes deste repositório, chamados pelas skills flow-run, flow-gaps e flow-audit e por .claude/hooks/flow-hooks.ts (só o marker.ts), menos o reanchor.ts, que nenhuma skill chama (o dono o roda quando as diretrizes viram directives-N), e o gate.ts, que só é chamado por mark.ts e à mão. Não entram nos bundles do produto. gate.ts, mark.ts e report.ts leem o log por composeReader (cli-error.ts#openReadOnly) e precisam de node_modules; reanchor.ts e sync-cli.ts leem igual e gravam por writer.ts, e eles, o reanchor-plan.ts e o writer.ts também precisam de node_modules; marker.ts, sync.ts, flow.ts e o trio do critic (critic-tools.ts, critic-run.ts, critic.ts, chamado pelo flow-run) usam só builtins e rodam em worktree sem npm ci.

FileDescription
flow/marker.tsSó builtins: slugOf (slug da branch, que recusa main, develop, directives*, audits* e os RESERVED_PROCESS_NAMES do domínio), markerPath (<git-common-dir>/hexlog-flow/<slug>.ok) e os helpers de git de que eles precisam
flow/sync.tsNúcleo puro do sync das diretrizes, sem I/O: planSync, parsePremises, scanPremises, isCurrent (o predicado de vigência de uma linha lida, que reanchor-plan.ts, report.ts e reanchor.ts importam), validateExtracted (os tetos de slug, rule e section, iguais ao maxLength dos tipos de .hexlog/) e verifySync (confere o log relido contra o plano)
flow/flow.tsCLI sem dependência com o modo slug <branch>; o sync das diretrizes é o sync-cli.ts
flow/sync-cli.tscheck e plan [--apply] sobre --process directives-<N>: lista o estado de cada documento de docs/directives/ e, com --apply, grava o sync de diretrizes por writer.ts#openWriter e confere o log relido; sai 0 concluído, 1 recusa, lote recusado ou conferência divergente, 2 com dado 0.x ou log quebrado
flow/gate.tsgateFailures e CLI pre-pr <slug>: avalia os gates pre-pr e gaps fixados no processo (o argumento pre-pr, o único aceito, roda os dois); sai 0 com os dois verdes, 1 listando gate, pergunta e ids, 2 com dado 0.x ou log quebrado. Nenhuma skill chama o CLI: é a conferência manual antes do mark.ts, que importa gateFailures (uso manual documentado em docs/feedback-loops.md, seção Rodar na mão); a regra allow de .claude/settings.json e a entrada do knip.json existem por ele
flow/mark.tsmark <slug>: confere o slug da branch e os gates por gateFailures e só então grava o .ok (branch e sha da ponta); a árvore suja não importa; recusa sem gravar nada, com exit 1 (2 com dado 0.x ou log quebrado, pelo formatCliError); só age como CLI (guard import.meta.main, como o gate.ts)
flow/report.tsreport <slug> [<base>]: lista as decisões vigentes cuja base merece revisão (o rests-on e o anchored-in herdados pela linhagem, inheritedOut, contam como os gravados); só imprime e sai sempre 0
flow/reanchor-plan.tsNúcleo puro da reancoragem: planReanchor (classifica as âncoras anchored-in e rests-on em same, changed, gone, ambiguous e stale; regrava só as de âncoras same e manda o resto ao dono), toBatches (lotes de até 50 com key pelo conteúdo), verifyReanchor (conferência relativa do log relido), summarizeApply (o resumo do --apply: as linhas de stdout e de stderr e o exit code), formatPlan, isLatestGeneration, generationOf e COPIED_NAMES (as relações que a regravação copia, conferidas por spec contra a lista de docs/directives/fluxo-hexlog.md)
flow/writer.tsGravador do log pelo register do compose(): openWriter (recusa antes de abrir se checkInstalled acusa código instalado diferente ou dado 0.x; devolve write e attach, que anexa um .md/.txt do cwd e devolve o hash), checkInstalled (versão e manifest.json instalados e src/ do HEAD contra o commit do build), readInstalled (as entradas reais dessa conferência) e gitDiffQuiet (o git diff --quiet real, preso à raiz do checkout)
flow/reanchor.tsreanchor --to directives-<N> [--apply]: sem --apply imprime o plano e avisa se o código instalado difere; com --apply regrava, por processo, as decisões de âncoras idênticas e confere o log relido; sai 0 concluído, 1 recusa, lote recusado ou conferência divergente, 2 com dado 0.x ou log quebrado
flow/critic-tools.tsParte pura do runner do critic da cadeira do dono: TOOLS (claude, agy), resolveTool (a flag vence HEXLOG_CRITIC_CLI; sem nenhuma, claude), buildRules, buildCommand, buildPrompt, foldTurn/parseTurn (stream da ferramenta), truncateText (corta em bytes, na fronteira de caractere) e classifyFailure (credential, mcp, timeout, transient); sem I/O
flow/critic-catalog.tsParte pura do catálogo de ações do critic: parseCatalog lê a seção "Catálogo de ações" de docs/directives/cadeira-do-dono.md (3 tabelas de cabeçalho exato e a ordem de custo) e renderActions cola a seção literal mais a linha das ações disponíveis na coluna do transporte; só builtins, sem I/O
flow/critic-run.tsBorda de I/O do runner: startSession (pré-condições, leitura do doc do catálogo no cwd e mailbox hexlog-critic-<slug>-XXXXXX em os.tmpdir() com rules.txt), askQuestion (ask.lock, spawn detached com kill de grupo, timeout por inatividade e teto, retry com backoff, contadores, SIGHUP/SIGINT/SIGTERM), closeMailbox e EXIT; tempos e leitor de /proc entram por parâmetro; sem import.meta
flow/critic.tsstart <slug> [--cwd <dir>] [--tool claude|agy], ask <mailbox>, close <mailbox> e rules --tool <t> [--cwd <dir>] (grava as regras geradas do catálogo em os.tmpdir() e imprime o caminho): só argv, env (HEXLOG_CRITIC_CLI) e saída sobre critic-run.ts; saídas em critic-run.ts#EXIT; o que a skill faz com cada uma, em flow-run, seção 6

Exit codes dos scripts de leitura

Exitexport.tstimeline.tsinsights.tsseat-report.ts
0íntegroíntegroíntegro (ou sem processos, sem filtro)íntegro, com os achados listados
1uso incorreto, campo inválido, errouso incorreto, nome inválido, errouso incorreto, filtro sem resultado, falha de leitura de um processo (linha insights failed: CODE: msg sob o título dele)uso incorreto, nome de tipo inválido, tipo de um papel inexistente no projeto (INVALID_INPUT), erro (seat-report failed: CODE: msg)
2dado 0.x (LEGACY_DATA) e PROCESS_CORRUPTED (cadeia adulterada incluída)dado 0.x, PROCESS_CORRUPTED e anexo ausente ou corrompidodado 0.x (LEGACY_DATA), PROCESS_CORRUPTED (cadeia adulterada ou process.json ilegível) e anexo ausente ou corrompidodado 0.x (LEGACY_DATA) e PROCESS_CORRUPTED

Regra única da tabela: 2 é dado quebrado (o operador resolve no dado, não no comando), 1 é o resto e 0 é íntegro. O insights agrega: processReport devolve o exitCode de cada processo (formatCliError na falha de leitura; 2 para cadeia ou anexo quebrado) e main devolve o maior, então um processo ilegível por IO_ERROR (1) junto com uma cadeia quebrada (2) sai 2. A falha de leitura imprime formatCliError (código e detalhes) sob o título do processo e não derruba os demais. Um process.json ilegível entra na enumeração (ProcessReader#list só confere que o manifesto existe) e sai como linha PROCESS_CORRUPTED do processo, não como erro da listagem.

Navigation Notes

  • A lógica de negócio dos dois scripts vive em src/guard.ts (expectedRules, applyGuard, verifyGuard, hookProbes, mcpRegistered) e src/installation.ts (installArtifact, registerGuard, verifyInstallation) — esses módulos recebem a execução externa por parâmetro e são testáveis sem chamar esbuild/claude de verdade (runRealHook, de src/guard.ts, é o único spawn, e src/installation.ts chama fs real: é quem grava os arquivos instalados). install.ts é só a fiação: injeta runRealHook, countTools (sobe o servidor num HOME descartável e conta tools.length) e registerMcp (claude mcp remove+add, substituível por HEXLOG_REGISTER_MCP=<script> nos testes).
  • Instalação é idempotente pelos bytes instalados (compara sha256 do build atual contra o instalado) e trata concorrência entre dois instaladores rodando ao mesmo tempo via troca atômica (renameSync) com fallback em ENOTEMPTY/EEXIST/ENOENT.
  • npm test (jest) roda tudo, incluindo:
    • test/package.spec.ts: dependencies/devDependencies do package.json têm exatamente os pacotes esperados, todos em faixa ^X.Y.Z (a versão resolvida fica no lock), engines.node é ^24.18.1.
    • test/installation.spec.ts e test/guard.spec.ts: os describes installArtifact e registerGuard chamam as funções direto; test/install.spec.ts: o describe scripts/install.ts (com with --check) roda o script como processo real (spawnSync), sempre com HOME temporário — nunca o HOME real.
    • test/insights.spec.ts: describe scripts/insights.ts, que roda o script como processo real (spawnSync) contra um XDG_DATA_HOME temporário: relatório de integridade e linha do tempo (com as condições with the alpha/run-2 filter e with the alpha/run-1 filter e a trava de que nada foi escrito no diretório de dados), sinais da chave, cadeia adulterada (inclui o process.json truncado e o caso misto de exit 1 e 2), uso incorreto e dado 0.x.
    • test/export.spec.ts: describe scripts/export.ts, que roda o script como processo real (spawnSync) contra um XDG_DATA_HOME temporário: sem e com --fields, uso incorreto e processo inexistente, integridade e read-only.
    • test/timeline.spec.ts: describe scripts/timeline.ts, que roda o script como processo real (spawnSync) contra um XDG_DATA_HOME temporário: --full (com --raw, texto ≥ 200 KB idêntico entre os delimitadores), escape de terminal (condição with terminal control characters in the record and its attachment: sem --raw, com --raw e com --json), texto legível (with only the project and the target), agent hostil, muitos registros, --json, read-only, integridade (exit 2) e uso incorreto e erros.
    • test/seat-report.spec.ts: describe scripts/seat-report.ts, que roda o script como processo real (spawnSync) contra um XDG_DATA_HOME temporário: ordem e exclusividade das oito seções, as marcas de "sem critério", lacuna aberta, aval e aval revogado, audit de retirada, resposta contestada, answeredBy ausente e não reconhecido, tipo inexistente no projeto (exit 1), --process, --types com nomes mapeados, read-only, escape de terminal, dado 0.x (exit 2) e uso incorreto (exit 1).
    • test/owner-seat-package.spec.ts: o pacote de definições de skills/hexlog-setup/references/owner-seat/ ensaiado em memória (ver test/AGENTS.md).
    • test/escape-controls.spec.ts: escapeControls sobre cada classe de controle (C0, DEL, C1, bidi, U+2028/U+2029, tag characters e os seletores de variação U+E0100 a U+E01EF), o que passa intacto (LF, TAB, acento, emoji, BOM) e a idempotência.
    • test/release-notes.spec.ts: releaseNotes por tabela (ordem dos blocos, rebaixe de ### fora de cerca, variantes de cerca do CommonMark, seção seguinte ignorada, sem abertura, sem PR, seção ausente ou vazia) e release-notes-cli.ts como processo real (spawnSync) sobre o CHANGELOG.md do repositório.
  • import.meta.main/import.meta.dirname são usados nos scripts que rodam como CLI para o modo executável direto — incompatíveis com o transform CJS do ts-jest, por isso src/installation.ts tem a sua hasDynamicRequire em vez de importar de build.ts.

Dependencies

Internal

  • build.ts: nenhuma (só resolve caminhos da raiz do repo)
  • install.ts: ./build.ts (build, repoRoot), ../src/adapters/fs/data-format.ts (detectLegacy), ../src/adapters/fs/io.ts (readIfPresent), ../src/archive.ts (archiveLegacy, inspectLegacy), ../src/directory.ts, ../src/guard.ts, ../src/installation.ts
  • cli-error.ts: ../src/compose.ts (composeReader), ../src/directory.ts, ../src/errors.ts (HexlogError, internalError, legacyDataError)
  • escape-controls.ts: nenhuma
  • release-notes.ts: nenhuma; release-notes-cli.ts: ./release-notes.ts
  • insights.ts: ./cli-error.ts, ../src/directory.ts (dataDir, só para a mensagem de "No processes found"), ../src/domain/chain.ts (tipo Link)
  • export.ts: ./cli-error.ts, ../src/domain/ids.ts, ../src/queries/query-service.ts (tipo QueryRecord)
  • timeline.ts: ./cli-error.ts, ./escape-controls.ts, ../src/domain/ids.ts, ../src/queries/query-service.ts
  • seat-report.ts: ./cli-error.ts, ./escape-controls.ts, ../src/domain/ids.ts, ../src/queries/query-service.ts (tipos QueryRecord e QueryService)
  • flow/marker.ts: nenhuma; flow/sync.ts: nenhuma (só node:crypto e node:util); flow/flow.ts: ./marker.ts, ./sync.ts; flow/gate.ts: ../cli-error.ts, ../../src/domain/ids.ts, ../../src/compose.ts (só o tipo); flow/mark.ts: ./gate.ts, ./marker.ts, ../cli-error.ts, ../../src/errors.ts; flow/report.ts: ./sync.ts, ../cli-error.ts, ../../src/domain/ids.ts; flow/reanchor-plan.ts: ./sync.ts, ../../src/domain/chain.ts, ../../src/domain/ids.ts, ../../src/domain/record.ts; flow/writer.ts: ../../src/compose.ts, ../../src/domain/chain.ts, ../../src/domain/ids.ts, ../../src/domain/record.ts, ../../src/errors.ts, ../../src/version.ts; flow/reanchor.ts: ./reanchor-plan.ts, ./sync.ts, ./writer.ts, ../cli-error.ts, ../../src/directory.ts, ../../src/domain/ids.ts; flow/sync-cli.ts: ./reanchor-plan.ts, ./sync.ts, ./writer.ts, ../cli-error.ts, ../../src/directory.ts, ../../src/domain/ids.ts, ../../src/domain/record.ts; flow/critic-tools.ts: nenhuma; flow/critic-catalog.ts: nenhuma; flow/critic-run.ts: ./critic-catalog.ts, ./critic-tools.ts, ../escape-controls.ts; flow/critic.ts: ./critic-run.ts, ./critic-tools.ts

External

  • esbuild
  • @modelcontextprotocol/client (Client, StdioClientTransport; devDependency)
  • es-toolkit (só o core; es-toolkit/compat não é importado)
  • zod (flow/writer.ts)
  • node:fs, node:os, node:path, node:child_process (execFileSync, spawnSync; spawn em flow/critic-run.ts), node:util (parseArgs, em cli-error.ts e flow/critic.ts)

Manual Notes

Diretrizes

  • fronteiras.md: scripts de leitura só por composeReader, execução externa injetada
  • instalacao-e-hooks.md: instalador, bundles fixos, skills dinâmicas e o efeito de mudar o hook ou o servidor
  • qualidade-e-testes.md: comandos antes de concluir

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.