hexlog / test
AGENTS.md4 starsChanged 19 days agoMITView on GitHub
Parent context: ../AGENTS.md Generated: 2026-09-17 · Updated: 2026-10-17
- Reads credentials
- Commits and pushes
In this repository18 other files it gives its agents.
- AGENTS.mdAGENTS.md
- docs/AGENTS.mdAGENTS.md
- hook/AGENTS.mdAGENTS.md
- scripts/AGENTS.mdAGENTS.md
- skills/AGENTS.mdAGENTS.md
- skills/hexlog/AGENTS.mdAGENTS.md
- skills/hexlog-flow/AGENTS.mdAGENTS.md
- skills/hexlog-setup/AGENTS.mdAGENTS.md
- src/AGENTS.mdAGENTS.md
- CLAUDE.mdCLAUDE.md
- flow-auditSkill
- flow-gapsSkill
- flow-owner-seatSkill
- flow-runSkill
- friction-miningSkill
- hexlog-flowSkill
- hexlog-setupSkill
- hexlogSkill
The file
Files
test
Parent context: ../AGENTS.md
Generated: 2026-09-17 · Updated: 2026-10-17
Purpose
Suíte jest/ts-jest do hexlog: testa o .ts fonte diretamente (unit, property-based e via MCP real em memória) e cobre com e2e real o que as sessões de fato executam (bundle .mjs, hook empacotado, instalador, concorrência de processos).
Key Files
| File | Description | ||
helpers.ts | Não é spec. createTempDir(prefix): cria hexlog-<prefix>-XXXXXX sob os.tmpdir() e registra em cleanup.ts (caminho padrão para diretório temporário de teste); ARCHIVE_COMMAND (o comando que a recusa LEGACY_DATA põe em details); parseJson(schema, text), jsonLines<T>(out) (parseia uma saída JSONL), listFiles(dir, extension, ignoredDirs?) (arquivos de uma extensão sob dir, em qualquer profundidade), at(items, index), detail(path, code) (o detalhe de erro esperado, com qualquer message), recordId(process, n) (id determinístico <process>:<n com 8 dígitos> para os specs de domínio) captureError(fn) (o HexlogError lançado por uma função síncrona), idsOf(page) (ids da página), cursorOf(page) (o cursor que a página deve ter) e walkPages(query, input) (todas as páginas de uma consulta, até 20 rodadas); anchoredIn(...) e restsOn(...) (as relações do fluxo, usadas pelos specs de reancoragem e de relatório); expectNoLeak(error, secret): confere que nem message nem details do HexlogError trazem secret; rejectionOf(promise, secret): espera a rejeição com HexlogError, aplica expectNoLeak e a devolve; captureLog(): logger que junta os LogRecord em records; errno(code) (erro cru do fs com caminho absoluto na mensagem), createDataHome() (um XDG_DATA_HOME temporário com o <D> vazio, devolve { xdg, dataDir }), copyToXdg(source) (copia para <xdg>/hexlog, o <D> que os scripts resolvem) e snapshot(root) (caminho → sha256:mtimeMs para provar que um script não escreveu); scriptWrites(steps, dataDir) e spyOnWriteSync (roteiro de fs.writeSync para escrita curta e ENOSPC; o helper usa import fs from 'node:fs' porque o spy só intercepta o objeto padrão). O erro de domínio estruturado da 1.0 vai em content[0].text e é afirmado por mcp/environment.ts#expectError. A trava de lint só barra mkdtempSync: mkdtemp assíncrono, alias e import()/require passam. Base da maioria das specs. | ||
cleanup.ts | Não é spec. setupFilesAfterEnv do jest: guarda o registro de registerTempDir (consumido por helpers.ts#createTempDir) e apaga tudo no afterAll, inclusive com teste vermelho. Só importa node:fs e @jest/globals: puxar src/ aqui carrega o módulo antes do jest.mock de um spec. | ||
global-setup.ts | Não é spec. globalSetup do jest: cria hexlog-suite-* com mkdtempSync sob o TMPDIR recebido e exporta process.env.TMPDIR para ele, herdado pelos workers. Apaga também as variáveis locais do Git (git rev-parse --local-env-vars; se o git não inicia, a saída vazia não derruba o setup), que um hook disparado de worktree vinculada exporta e fariam os specs com git operar no repositório real. É, com helpers.ts, o único lugar de test/ que pode chamar mkdtempSync. Um kill -9 no jest pula o globalTeardown e deixa o hexlog-suite-* para trás (limpeza manual em docs/directives/qualidade-e-testes.md). | ||
global-teardown.ts | Não é spec. globalTeardown do jest: se hexlog-suite-* não estiver vazio, falha a execução listando o que sobrou, depois apaga o diretório (só age em basename hexlog-suite-, nunca num TMPDIR real). Vale com e sem -t. | ||
boundaries.spec.ts | Travas de fronteira de eslint.boundaries.js (boundaryBlocks) pela API ESLint sobre fixtures/boundaries/: imports proibidos em domain/shared/commands/queries (builtins exceto node:crypto, ajv/ajv-formats/minisearch e subcaminhos, SDK do MCP, adapters, compose.ts), sondas aninhadas por camada, direção (domain sem commands/queries/mcp/shared; src/mcp/** sem builtins, adapters nem compose.ts, que só server.ts, scripts e testes importam; src/adapters/** sem commands, queries nem mcp; scripts/** sem adapters nem mcp, exceto install.ts e build.ts), commands ↔ queries, max-lines 800 só em commands/queries, src/ports.ts (raiz de src/, sem builtins, infra, adapters nem compose.ts) e src/mcp/kernel.ts sem importar ./tools/**. Só conta mensagem com severidade 2. Arestas de cima: shared/ e ports.ts sem commands/queries/mcp, commands/queries sem mcp, cada uma com o par que pode importar. | ||
config-wiring.spec.ts | Prova que eslint.config.js liga as travas: calculateConfigForFile num processo filho ESM (o jest em CJS não carrega a config) e severidade 2 de no-restricted-imports/max-lines em src/commands, no-restricted-imports em src/mcp/kernel.ts e no-restricted-syntax em test/**. | ||
no-flow-terms.spec.ts | Por AST, nenhum identificador nem literal de todo src/, hook/ e scripts/ (menos scripts/flow/, código do fluxo por definição) usa termo de fluxo (phase, fase, plan, plano, critic, milestone, verdict, claim, omc e similares), com separação por camelCase. | ||
domain/ids.spec.ts | src/domain/ids.ts: Name, Hash, Instant, Target, RecordId, TypeNames (nome de tipo repetido recusado com a mensagem duplicate type name), alias, processOf e RESERVED_PROCESS_NAMES. | ||
domain/record.spec.ts | src/domain/record.ts: HexRecord, Author (surrogate solto recusado em agent, model e client, com o path do campo e a mensagem must not contain a lone surrogate), Relation/RelationInput (to como id ou @alias: de @a até @ mais 63 caracteres passa, @, @A, @-a e @ mais 64 recusados; sem kind e sem as recusado), BatchItem, withCanonicalLimit (valor sem forma canônica passa; acima do teto, a mensagem nomeia o que foi limitado e o teto) e os tetos DATA_MAX_CHARS, BATCH_MAX e RELATIONS_MAX (no teto passa, teto mais um recusa). | ||
domain/chain.spec.ts | src/domain/chain.ts: sha256hex, fingerprint, hashLink, hashOfJcs (ordem das chaves irrelevante), anchor (com vetores fixos do formato em disco), isValidLink (razões invalid-line/diverging-seq/hash-mismatch) e os tetos de Batch, sem fs. | ||
domain/relations.spec.ts | src/domain/relations.ts: checkRelation (regras e details[].code), hasCycle, buildVigency e needsReview. | ||
domain/vigency.property.spec.ts | Property tests (fast-check) das funções de src/domain/relations.ts (buildVigency, checkRelation, hasCycle, needsReview). | ||
domain/relation-graph.ts | Helper dos specs de propriedade de domain/ (não é spec): rootOf e lineages (as linhagens de supersedes, o oráculo), withShuffle (os registros gerados com os mesmos em outra ordem de leitura) e withRelation (anexa uma relação a um registro), usados por domain/vigency.property.spec.ts e domain/inheritance.property.spec.ts. | ||
domain/definitions.spec.ts | src/domain/definitions.ts: schemas RecordType/RelationName/Gate, semver (bumpVersion), classificação de mudança de tipo e de relação, attachmentFields e o teto canônico de RELATION_GATE_MAX_CHARS em RelationName (from/to) e Gate (where, nas duas bordas) e a conferência de cada tipo, relação e gate de fixtures/domains/ contra os schemas. | ||
domain/gate.spec.ts | src/domain/gate.ts: GateQuestion (inclusive a recusa de no_fork), Selector, matchesSelector/matchesTargetPrefix e evaluateGate. | ||
domain/inheritance.spec.ts | src/domain/inheritance.ts#buildInheritance: por tabela, o que sobe por espécie, o que nunca herda, aresta direta igual, linhagem revogada, ativação por processo, corte por contradicts, ordem determinística e needsReview com Inheritance. | ||
domain/inheritance.property.spec.ts | Property tests (fast-check) de buildInheritance: inativo dá vazio, pontas que sobem são vigentes, independe da ordem dos registros, aresta direta e contradicts removem a herdada; e, por exemplo, um ciclo de supersedes de log forjado termina sem herdar nada. | ||
domain/inheritance.budget.spec.ts | Orçamento de buildVigency + buildInheritance sobre uma cadeia de 8.000 versões de supersedes com um supports por versão, em ordem crescente e decrescente dos registros: mediana de 3 rodadas ≤ 1000 ms; e o pior caso do corte, com um contradicts vigente por apoio numa linhagem decrescente, pelo mínimo das rodadas ≤ 1000 ms. Só roda em npm run test:budget. | ||
domain/formats.spec.ts | src/domain/formats.ts: isGitSha (hexadecimal minúsculo de 7 a 40 caracteres; recusa HEAD, 6 e 41 caracteres, maiúsculas e quebra de linha final) e FORMAT_CATALOG/catalogNames (hoje só git-sha). | ||
domain/schema-walk.spec.ts | src/domain/schema-walk.ts: walkSubschemas (ponteiros RFC 6901; cada palavra-chave de subschema único, de lista com o índice no ponteiro (allOf, anyOf, oneOf, prefixItems) e de mapa com a chave no ponteiro (properties, patternProperties, $defs, definitions, dependentSchemas, dependencies), dependencies em array ignorado, const/enum/default/examples não percorridos), expandedSize ($ref citado duas vezes conta duas, referências que dobram em tempo linear, saturação) e countNodes (todo objeto, array e escalar, e para depois do limite), withoutFreePatterns (sem mutar a entrada, mantendo o campo pattern de properties) e hasKeywordAt (ponteiro com ~0/~1 e índice de array; false para ponteiro ausente, índice fora do array, alvo que não é objeto e ponteiro que passa por null). | ||
adapters/atomic.spec.ts | src/adapters/fs/atomic.ts: writeFileAtomic (substituição, exclusividade, limpeza do temporário, falha de fsync, link negado e nome do temporário). | ||
adapters/data-format.spec.ts | src/adapters/fs/data-format.ts: LEGACY_NAME, dataRoot e detectLegacy, e o vínculo de RESERVED_PROCESS_NAMES (src/domain/ids.ts) com as pastas do formato em disco. | ||
adapters/lock.spec.ts | src/adapters/fs/lock.ts: exclusão do lock por pid (D-12) com filhos de fixtures/lock-holder.ts, roubo de órfão (inclusive store.write depois do kill -9), dono vivo pausado, lock-lost sob carga e os ramos de erro de I/O do lock. | ||
adapters/lock-helpers.ts | Helpers dos specs de lock com filhos (não é spec): runFixture e startChild (modo e argumento tipado por fixtures/fixture-args.ts#LockHolderArgs), startHolder, startKilledHolder (dono morto por SIGKILL com o lock plantado), liveForeignPid (pid de um filho vivo que não é este processo), createProcess, runWriteStress, trackChild (registra um filho criado fora dos helpers) e killChildren, usados por adapters/lock.spec.ts e adapters/lock.budget.spec.ts. | ||
adapters/lock.budget.spec.ts | Medição das taxas de lock-lost/lock-busy do estresse de 8 filhos x 25 gravações, repetido em várias rodadas (LOCK_BUDGET_ROUNDS, inteiro positivo, padrão 20; o CI usa 5); imprime uma linha por rodada e assere a integridade da cadeia; assere também o prazo de 1 s do roubo de lock órfão: acquire (createLockManager) e store.write (createProcessStore). Só roda em npm run test:budget. | ||
adapters/fsync-spy.ts | Helper dos specs dos stores (não é spec): spyOnFsync(onFsync) espia fs.fsyncSync com passagem para o real; countFsyncs() conta files e directories (por fstatSync(fd).isDirectory()) e countFsyncsOf(file) conta só os fsync dados no inode de file; usado por adapters/atomic.spec.ts, adapters/attachment-store.spec.ts, adapters/definition-store.spec.ts, adapters/lock.spec.ts e adapters/process-store.spec.ts. | ||
adapters/fs-spies.ts | Helper dos specs de adapters de disco (não é spec): spyOnRename(intercept?) e spyOnOpen(onOpen) espiam fs.renameSync e fs.openSync com passagem para o real, e o intercept pode lançar ou mexer no disco antes do rename; usado por adapters/atomic.spec.ts, adapters/lock.spec.ts, adapters/process-store.spec.ts e adapters/process-store.release.spec.ts. | ||
adapters/process-store.spec.ts | src/adapters/fs/process-store.ts: create/read/readManifest (só o process.json, sem ler o log)/list/write, fsync por lote, kill -9 no meio do lote (filhos de fixtures/crash-writer.ts), process.exit() do dono entre a linha em disco e a liberação do lock (modo write-exit de fixtures/lock-holder.ts: o próximo write rouba o lock pelo pid morto e a cadeia segue íntegra), truncamento em cada offset, escrita curta, teto de 64 MiB do log na leitura e na escrita (PROCESS_TOO_LARGE, com log esparso, contado em bytes com ç e ã, write sem line sobre o log no teto), corte em cada byte de UTF-8 e só ENOENT valendo "processo ausente". | ||
adapters/process-store.release.spec.ts | src/adapters/fs/process-store.ts#createProcessStore: falha do release do lock em write: só o try falha (o erro principal sai e nada é logado como release-failed), só o release falha (o erro do release sai, a linha fica durável e o lock vira órfão) e os dois falham (o erro principal sai inalterado e o do release vai só ao log); espia fs.renameSync para falhar a liberação uma vez. | ||
adapters/definition-store.spec.ts | src/adapters/fs/definition-store.ts: layout de D-02 por tipo de definição, ordem numérica das versões, imutabilidade (write devolve false e preserva os bytes, corrida entre dois escritores), recusa de definição fora do schema do domínio no write (INTERNAL, invalid-definition, sem gravar), fsync do diretório só na escrita que publica a versão, arquivo legado <nome>.json ignorado, erros de nome/versão (unknown-name, inclusive para pasta vazia, versus unknown-version com a lista versions não vazia) e IO_ERROR só com o errno. | ||
adapters/attachment-store.spec.ts | src/adapters/fs/attachment-store.ts: putText/putPath (bytes e hash exatos, deduplicated, teto de 1 MiB), fsync de arquivo e de diretório na gravação, IO_ERROR na gravação sem vazar o caminho, corrida em processo entre dois put do mesmo texto, read/status com blob adulterado, ausente ou symlink, memo de verificação (o ctime é visto sem setTimeout) e as recusas de putPath (fora do cwd, dentro do dataDir, cwd e dataDir que são symlink, symlink, hardlink, arquivo não regular). O status de FIFO e as recusas not-regular rodam no filho fixtures/attachment-probe.ts (execFileSync com timeout), para um open sem O_NONBLOCK falhar por tempo em vez de travar o jest. | ||
adapters/regexp-spy.ts | Espia de RegExp dos specs do validador (não é spec): withRegExpSpy(sentinela, run) conta construções e execuções (test/exec) de regex cuja fonte contém a sentinela e restaura o global em finally; usado por adapters/validator.spec.ts. | ||
adapters/validator.spec.ts | src/adapters/validator.ts: checkSchema (metaschema com caminho relativo ao schema, erro de compilação com path vazio, formato attachment, sem vazar caminho, sem guardar $id, recusa de $id de metaschema e de $async; pattern e patternProperties recusados com pattern-not-allowed e o ponteiro certo em cada palavra-chave de subschema, o pattern alcançado por $ref para dado (com a espia de RegExp sem construção) e o $ref para o metaschema aceito, const/enum/default que não são subschema, e $ref cíclico) e validate (compila uma vez por objeto de schema, Detail[] em kebab-case, todas as violações do dado abaixo do COST_CEILING inclusive em anyOf e uma por subschema acima dele, sem travar com $defs que dobram e com milhares de itens reprovados, o valor medido (got N) em maxLength, minLength, maximum e minimum, erros sem repetição com teto de 50 e too-many-errors, escape de ~ e / no JSON Pointer, nome recusado por propertyNames; describe with a pattern or patternProperties in the schema: dado que o regex recusaria é aceito, sem construção nem execução, regex inválido que o ajv plain lança compila, e o corner de additionalProperties/unevaluatedProperties false). | ||
adapters/search.spec.ts | src/adapters/search.ts: texto indexável (type, target, strings de data), relevância e desempate, acento e caixa, prefixo e fuzzy, AND com fallback para OR (também sobre allowed), termo repetido deduplicado (inclusive variante de caixa) sem custo extra, consulta em branco e recall, terms (propriedade com fast-check: sem termo não acha, com termo acha o registro que contém o texto), precisão e determinismo sobre fixtures/records-corpus.ts. | ||
adapters/search.cache.spec.ts | createSearchIndex: cache (acerto sem remontar, crescimento incremental, hash do último divergente, log menor que o indexado (motor efêmero, índice quente mantido), despejo do menos usado por caracteres indexados, processo acima do orçamento não guardado, alcance projeto nunca guardado, inclusive o ref cujo process é '*', e equivalência com o índice sem cache) e busca (terms em minúsculas e sem acento, sem termo para só marcas combinantes, prefixo, uma edição em termo de cinco caracteres, AND com fallback para OR (metade dos termos, arredondada para cima), allowed com e sem fallback, relevância antes da ordem do log e empate na ordem do log); espia MiniSearch.prototype.addAll. | ||
adapters/search-helpers.ts | Helper dos specs de busca (não é spec): makeRecord(overrides), registro de teste com id sequencial, usado por adapters/search.spec.ts e adapters/search.cache.spec.ts. | ||
adapters/search.budget.spec.ts | Orçamento de createSearchIndex: construção + consulta sobre 10.000 registros sem cache, mediana ≤ 4000 ms e pior caso ≤ 7000 ms, e consulta repetida com o índice em cache, mediana ≤ 250 ms e pior caso ≤ 500 ms (corpus de ~1,2 KB por registro e vocabulário aberto; o orçamento de queries/query.budget.spec.ts mede o caminho completo). Só roda em npm run test:budget. | ||
adapters/load.budget.spec.ts | Orçamento: carregar e verificar 5.000 registros, com o mínimo de 5 medições ≤ 500 ms (ruído de CPU só soma tempo, então o mínimo é a métrica estável), com o corpus de fixtures/records-corpus.ts. Só roda em npm run test:budget. | ||
adapters/process-store.budget.spec.ts | Orçamento do onLoad de createProcessStore: corpus de cerca de 30 MiB dimensionado por bytes, 1 aquecimento e 5 medições de ProcessStore.read, com a diferença dos mínimos com e sem onLoad até 150 ms (pega a violação de lines-not-records, não micro-regressão). Só roda em npm run test:budget. | ||
adapters/otel.spec.ts | src/adapters/telemetry/otel.ts: createOtelTelemetry (span e métricas por chamada com exporters de captura, estados export e probe e a limpeza deles, exporters que nunca resolvem, SDK que lança, OTEL_* hostil sem vazamento e temporalidade cumulativa, o orçamento do shutdown, e o execute do kernel com um handler que reporta o alvo e recusa PROCESS_TOO_LARGE, para provar o span do ramo de depois do decide sem corpus de 64 MiB). O exporter OTLP real não envia dentro do jest (CJS recusa o import() do módulo de rede), então o envio pela rede é provado pelo processo filho fixtures/otel-sender.ts contra o receptor local de otlp-receiver.ts. | ||
otlp-receiver.ts | Helper dos specs de telemetria (não é spec): listen(behavior) sobe um receptor node:http em 127.0.0.1 (ok responde 200 a tudo, mute aceita e nunca responde) e devolve { origin, hits, close }; Hit, Receiver e OtlpBody (os campos do corpo OTLP/JSON que os specs leem) e delay; usado por adapters/otel.spec.ts e stdio.e2e.spec.ts. | ||
adapters/settings.spec.ts | src/adapters/telemetry/settings.ts#readTelemetrySettings: endpoint ausente ou vazio, cabeçalhos k=v percent-decodificados e par malformado ignorado; nenhuma outra variável é lida. | ||
adapters/shutdown.spec.ts | src/adapters/telemetry/shutdown.ts#bindShutdown: EOF do stdin, beforeExit, SIGTERM e SIGINT com proc falso e timers falsos, o orçamento de 1.750 ms no EOF, o segundo sinal que sai na hora, o shutdown que nunca resolve e o que lança ou rejeita (o exit ainda sai). | ||
adapters/noop.spec.ts | src/adapters/telemetry/noop.ts#noopTelemetry: enabled falso, run chamado uma vez, degraded indefinido e shutdown que resolve. | ||
shared/loader.spec.ts | src/shared/loader.ts: parseLog, isValidLine, verifyProcess, checkExpectedHead e loadVerified. | ||
shared/loader.property.spec.ts | Property tests (fast-check) de checkExpectedHead: o head de antes de apagar um sufixo do log vira head-not-found, e o hash de qualquer prefixo segue aceito depois de o log crescer. | ||
shared/pages.spec.ts | src/shared/pages.ts: isHighSurrogate (as duas bordas da faixa aceitas; o vizinho de fora e NaN recusados) e sliceChars: corte sem partir par surrogate (recuo, avanço), nextOffset nulo e percurso completo por páginas bem formadas. | ||
compose.spec.ts | src/compose.ts: compose monta os serviços de escrita e de consulta sobre os adaptadores reais (createProcess e register gravam uma linha, a mesma key dá replayed e o logger recebe batch-replayed), e isLegacy (D-13) com o dataDir vazio e com layout 0.x. composeReader só expõe o lado de leitura (query, loadProcess, isLegacy, list, listProjects) sobre o que compose gravou, e o list dele enumera o processo com process.json ilegível que o list da consulta recusa. | ||
commands/attachment.spec.ts | src/commands/attachment.ts: cada recusa de attach sai antes de qualquer porta (porta falsa que conta gravações), a ordem fixa das recusas (D-15), o teto de 255 bytes UTF-8 por segmento do path, a entrada aceita que chega à porta e attach sobre o adaptador real (.md e .txt gravam os bytes exatos, .json dentro de <D> dá bad-extension, e a recusa não cria nada em <D>). | ||
commands/definition.spec.ts | src/commands/definition.ts sobre porta em memória: defineType/defineRelation/defineGate com versões imutáveis (quebra sem breaking: true recusada, major com breaking: true), replay idempotente, escritor concorrente que ocupa a versão alvo (replay, nova decisão, quebra, tentativas esgotadas sem sobrescrever), tetos da definição e checkSchema do validador (path prefixado com /schema, sem /schema/schema e sem novo corte). | ||
commands/process.spec.ts | src/commands/process.ts#createProcess (D-18) sobre portas em memória: fixa a versão vigente de cada tipo, relação e gate com os hashes do JCS de cada bloco, recusas, e processo já existente (created falso, manifesto intocado e stale com a vigente). | ||
commands/register.spec.ts | src/commands/process.ts#register até o nível 3 de D-06: gravação do lote numa linha (elos encadeados, batch só no primeiro, at do clock, apelidos e as), forma do lote, manifesto da origem, recusas estáticas (details por registro, no máximo 51), chave e precedência (replay, IDEMPOTENCY_CONFLICT, marker) e leitura única do log da origem. Todas as violações de schema de cada registro inválido do lote num só INVALID_RECORD (com o path de cada registro, o tamanho medido, com o 2º passe até o COST_CEILING e o aviso violations-capped acima dele), e TYPE_NOT_PINNED de um registro vencendo o INVALID_RECORD de dado de um anterior. | ||
commands/register-state.spec.ts | register nos níveis 4 a 6 de D-06: destinos de outro processo (D-10, RELATION_NOT_FOUND, stale-destination), regras de D-10 no próprio processo (FORK_REJECTED, type-mismatch, target-mismatch, CYCLE_REJECTED), anexos (D-16), ordem das checagens de estado (a recusa estática vence PROCESS_TOO_LARGE, que sai na leitura sob o lock e no veto do lote; o teto real fica em adapters/process-store.spec.ts e commands/register.real.spec.ts). Linha montada inválida (uuid injetado) dá INTERNAL sem gravar. | ||
commands/register.real.spec.ts | register sobre os adaptadores de disco de verdade (a composição real de compose()), num dataDir temporário: linha verificável com relação a outro processo e anexo reais, PROCESS_TOO_LARGE na leitura e no veto do lote, cauda rasgada com reenvio da mesma key e escrita curta com ENOSPC (certa e incerta). Lote com registros inválidos recusa com todas as violações de cada um e não grava nada. | ||
commands/register.concurrency.spec.ts | register concorrente em processos filhos sobre o compose real, com o modo register de fixtures/lock-holder.ts: dois supersedes ao mesmo destino dão um aceito e um FORK_REJECTED, e duas gravações com a mesma key dão uma gravada e um replayed (D-05), repetido em ROUNDS rodadas; e, de forma determinística, um register fica parado no lock de um filho write-gated (o filho register imprime a linha lock-wait antes de o pai soltar o goFile) e só grava depois que ele solta. Também: register A→B grava sem esperar o lock vivo de B (só o lock da origem é tomado). | ||
commands/fakes.ts | Helper dos specs de commands/ e de quem precisa das mesmas constantes (não é spec): constantes (PROJECT, ORIGIN, NOW, AUTHOR, tipos NOTE e DOC), manifestOf, createUuids, fakeProcessStore (create e write de verdade, sem lock, manifesto devolvido por structuredClone como o parse do adaptador, mensagem de PROCESS_TOO_LARGE igual à do adaptador, com contadores de leitura, create, gravação e fsync do replay, e readsOf por processo), fakeDefinitionStore (DefinitionStore com write que devolve false se a versão existe, gancho racing para o escritor concorrente e contagem de reads e writes), fakeAttachments (só status, conta as consultas), setup, note, refusal, verifiedOf, composeIn(home, clock?) (o compose real sobre o createDataHome(), sem log, relógio padrão fixo em NOW), seedNoteProcess (<xdg>/hexlog com o tipo note e um processo criados pelo compose real, com register(key, item)) e runScript (roda scripts/<script>.ts num filho com XDG_DATA_HOME). | ||
queries/query-setup.ts | Helper dos specs de queries/ e de domains.spec.ts (não é spec): diskStores e diskQueryService (a fiação dos stores de disco, usada também pelos specs de orçamento), querySetup (serviços de escrita e de consulta sobre os adaptadores de disco num dataDir temporário, relógio injetado, com logPath, tamper e tamperLine para ler e adulterar o log), defineDomain (define um fluxo de fixtures/domains/ pelo serviço de definições), instant, finding (registro finding de um alvo e um texto) e seeded; idsOf, cursorOf e walkPages vêm de helpers.ts. | ||
queries/query.spec.ts | src/queries/query-service.ts#queryRecords: vigentes por padrão e includeNonCurrent, filtros type/where/targetPrefix combinados por E, ids e relatedTo nas bordas, INVALID_FILTER (text sem termo pesquisável: no-terms; o limit inválido e o teto de text ficam em query-service.spec.ts), attachmentStatus de cada anexo citado e needsReview (D-09: só o alcance processo × projeto; a prova vencida pela linhagem fica em domain/relations.spec.ts), e fields: sem fields a página é a de sempre, só o data é recortado (envelope, relações e anotações completos), fields: [] sem data, filtros sobre o data inteiro, {} quando nenhum campo existe e nomes hostis (__proto__, constructor); relations: counts troca in/out por inCounts/outCounts por nome, sem mapa vazio e contando arestas não vigentes, none omite os quatro campos, full é o padrão do serviço, e needsReview e attachmentStatus não mudam. | ||
queries/query-service.spec.ts | Unitário de src/queries/query-service.ts#createQueryService (alvo do mutate de stryker.config.json), sobre ProcessReader, AttachmentReader e SearchIndex falsos em memória, com os logs montados por anchor e hashLink e sem disco (a integração sobre o disco fica em queries/query.spec.ts e nos irmãos). QueryService.queryRecords: envelope, dado e relações, process ausente no alcance processo, needsReview, hint de target próximo, limit (INVALID_FILTER em /limit; 0 só com changesSince e sem cursor), text (no-terms, acima de QUERY_TEXT_MAX_CHARS recusado antes dos termos, no teto aceito), fields, attachmentStatus, cursor (percurso sem repetir nem pular, última página sem cursor, alcance projeto, maxChars no limite e um caractere acima, primeiro registro maior que o teto, log que mudou, último registro fora do resultado e marcador ausente em /cursor) e changesSince (entered e left, só na primeira página, marcador ausente em /changesSince). QueryService.evaluateGate: recusas de targets antes de qualquer leitura (with-target, empty, full-with-targets), GATE_NOT_FOUND, marcador lido, evidência por contagens, leitura só do processo do gate sem pergunta de alcance projeto, alcance por pergunta e targets (um resultado por alvo, um só marcador, lote que falha inteiro). QueryService.verifyChain: ok com a contagem de registros, anexo ausente ou corrompido como quebra, cadeia quebrada, head-not-found e corte das quebras de anexo em MAX_BREAKS com o total. | ||
queries/navigation.spec.ts | queryRecords por text, ids e relatedTo: do termo do texto antigo à versão vigente e do termo ao veredito que apoia a evidência, com os dados e as relações de entrada e saída lidos em cada passo; relatedTo com relations: counts. | ||
queries/order.spec.ts | Ordem de saída de queryRecords (D-24): alcance processo por seq mesmo com o relógio andando para trás, alcance projeto por (at, processo, seq), text por relevância com o mesmo desempate, página 2 e changes na mesma ordem. | ||
queries/scope.spec.ts | Alcance de queryRecords (D-24): processo lê só o pedido e o marcador tem uma entrada; in e out.current de outro processo só no alcance projeto; cadeia quebrada falha fechado nomeando o processo; projeto inexistente é PROJECT_NOT_FOUND, projeto sem processos devolve página vazia e o log acima do teto é PROCESS_TOO_LARGE nomeando o processo; process ausente e processo inexistente recusados. | ||
queries/pagination.spec.ts | queryRecords: página e cursor (D-20): as páginas somam a lista sem repetir (propriedade com fast-check sobre limit), borda da última página e consulta vazia, estabilidade da página 1 (substituição ou processo novo entre as páginas não muda a lista da página 1), cursor adulterado, de outro projeto, de outro text ou do alcance projeto usado no processo (o type, o includeNonCurrent, o alcance processo usado no projeto e o outro processo ficam em query-service.spec.ts), maxChars e registro maior que o teto saindo sozinho, o teto contando a página recortada por fields (cenário da #85) e fields e relations fora do hash do cursor (a página 2 pode pedir outros, nos dois sentidos para fields). Limite padrão de 50 e maxChars um caractere acima do tamanho (o exato e o um abaixo ficam em query-service.spec.ts). | ||
queries/cursor.spec.ts | src/queries/cursor.ts: ida e volta do cursor (texto opaco de base64url, sem checksum), tetos de entrada (CURSOR_MAX_CHARS), adulteração (truncado, JSON inválido, campo extra ou ausente, tudo INVALID_CURSOR). O hash dos filtros (hashOfJcs) fica em domain/chain.spec.ts. Cursor com exatamente CURSOR_MAX_CHARS cai em malformed, não em too-long. Mensagens: toda INVALID_CURSOR cita cursor (longo demais, JSON inválido ou campo inválido) e, no detalhe, manda refazer a consulta sem cursor; o detalhe de malformed diz not valid JSON, o de too-long declara o teto e details não traz stack nem caminho absoluto. | ||
queries/changes.spec.ts | queryRecords com changesSince: entered e left com o motivo, foto anterior + entered − left igual a uma foto nova nos dois alcances, includeNonCurrent sem left, no-longer-matches quando outro registro passa a casar no AND, mudanças só na página 1 e marcador de processo inexistente recusado. | ||
queries/tamper.spec.ts | Linha antiga adulterada: a chamada seguinte detecta sem reiniciar o serviço, a busca por text não serve o índice de antes, página seguinte e changesSince também falham, e cursor ou evaluateGate com marker na linha rejeitada pela adulteração da anterior dão PROCESS_CORRUPTED, não MARKER_NOT_FOUND. | ||
queries/hostile-names.spec.ts | Contrato do serviço de consulta com nomes hostis: .. e a/b como processo ou projeto dão INVALID_INPUT invalid-name em toda operação que os recebe, e attachments e constructor são nomes válidos que dão PROCESS_NOT_FOUND; relação chamada constructor é contada em inCounts sem herdar do protótipo. A barreira real é dos adaptadores; o spec trava o que o serviço expõe. | ||
queries/read-only.spec.ts | (ISP) createQueryService só enxerga os Reader das portas: write, create, putText e putPath não existem nos tipos de Deps (@ts-expect-error, conferido pelo npm run typecheck) e o serviço aceita um fake só de leitura. | ||
queries/project-scope.spec.ts | O alcance projeto com includeNonCurrent reproduz a timeline 0.x de um alvo. | ||
queries/gate.spec.ts | evaluateGate: não grava e devolve o marcador do que leu, o scope por pergunta (as quatro perguntas ficam em domain/gate.spec.ts), higiene da cadeia, PROCESS_NOT_FOUND, o gate de achados e previstos (com perguntas de alcance projeto) e o lote de 50 targets, que lê cada processo uma vez (jest.spyOn no read do store), nos alcances processo e projeto (as recusas de targets e o GATE_NOT_FOUND ficam em query-service.spec.ts). | ||
queries/inheritance.spec.ts | queryRecords e evaluateGate com herança por createEnvironment: inheritedIn/inheritedOut e as contagens, origin, processo legado igual ao de antes, needsReview, corte, alcance processo e projeto, cursor, counts somando as mesmas arestas que full lista sobre cinco registros, relatedTo só pelas arestas gravadas, e a opção inherit do gate. | ||
queries/select.spec.ts | buildView e boundaryHint (#179): a herança é preguiçosa (buildInheritance roda uma vez por página com registros, zero vezes com limit: 0 e changesSince, e a vista passada do changesSince não soma uma 2ª conta) e o boundaryHint varre todo registro lido, inclusive o revogado, com e sem includeNonCurrent. | ||
queries/verify-chain.spec.ts | verifyChain: processo íntegro, vazio ou inexistente, diagnóstico que não grava, linha adulterada vira ok: false, linha rasgada reparada, expectedHead (head do último elo ou de um anterior passa, único elo ou cauda apagada vira head-not-found, teto de breaks; a matriz de exemplos fica em shared/loader.spec.ts e no property), e anexos citados ausentes ou corrompidos (D-16) somados às quebras da cadeia. | ||
queries/list.spec.ts | list sem projeto (projetos e contagem de processos), com projeto (processos e definições com a versão mais nova), com projeto e processo (o que o manifesto fixou) e os erros PROJECT_NOT_FOUND, PROCESS_NOT_FOUND e INVALID_INPUT. | ||
queries/describe-type.spec.ts | describeType: com process, o tipo fixado sem version (mesmo com versão nova no projeto); sem process, a vigente ou a version pedida; TYPE_NOT_FOUND em /type e em /version, TYPE_NOT_PINNED em /type, PROCESS_NOT_FOUND e process com version como INVALID_INPUT antes de qualquer leitura; tipo legado com pattern/patternProperties, com e sem process, sai sem as duas palavras-chave e com a cadeia íntegra. | ||
queries/read-attachment.spec.ts | readAttachment: texto inteiro pelo hash, paginação por offset e next, página que não parte par surrogate, offset no fim e além do fim, ATTACHMENT_NOT_FOUND e ATTACHMENT_CORRUPTED. | ||
queries/query.budget.spec.ts | Orçamento de queryRecords sobre 5.000 registros de fixtures/records-corpus.ts: primeira página sem text mediana ≤ 500 ms, com text e índice em cache ≤ 750 ms e com índice frio ≤ 3000 ms; pior caso ≤ 2× a mediana; e, com o corpus de supersedes e a herança ligada ou desligada no manifesto, o mínimo de 5 primeiras páginas ≤ 500 ms. Só roda em npm run test:budget. | ||
queries/project.budget.spec.ts | Orçamento do alcance projeto (10 processos × 500 registros): queryRecords sem text e evaluateGate com pergunta de alcance projeto, mediana ≤ 500 ms e pior caso ≤ 1000 ms. Só roda em npm run test:budget. | ||
mcp/environment.ts | Não é spec. errorBodyOf/expectError (leem o erro de content[0].text e travam a ausência de structuredContent em isError) e createEnvironment: cliente MCP em memória ligado a createServer sobre o compose real (adaptadores de disco num dataDir temporário, relógio fixo, isLegacy real), com call (reprova a chamada cujo log traz tool-over-cap e a que devolve Output validation error), ok, fail(name, args?, code?) (com code afirma esse código de erro por expectError), seedLegacy (dado 0.x em <D>), logs (os registros que o servidor mandou ao logger, na ordem) e as opções clientInfo (enviado por _meta em cada chamada) e telemetry (a Telemetry repassada ao compose e ao createServer; sem ela vale noopTelemetry). Também exporta o que os specs de tool dividem: PROJECT, NOTE_SCHEMA, TOOL_NAMES e ToolName (as 12 tools; o spec com uma entrada por tool tipa por ToolName), servicesOver(environment) (serviços reais sobre o <D> do servidor, a referência para comparar a resposta da tool), registerNote (uma nota num processo), registerBulk (count notas iguais em lotes de BATCH_MAX, devolve os ids) e nest(levels) (objeto com levels níveis contando a raiz dos args como o nível 1). | ||
mcp/kernel.spec.ts | src/mcp/kernel.ts: execute (LEGACY_DATA antes do serviço, INVALID_INPUT com details, INTERNAL sem stack, client do envelope), toHexlogError, advertise e a recusa de __proto__; o logger que lança nunca muda o resultado; a sonda de telemetria (trace com o nome da tool, end uma vez com ms e code, LEGACY_DATA), o aviso telemetry-degraded com um degraded saudável, que lança ou com um probe.end que lança, e a ausência de project, process e mensagens de erro no log e na sonda. | ||
mcp/telemetry-attribution.spec.ts | execute com uma Telemetry falsa sobre createEnvironment({ telemetry }): os LoadReport crus que só essa camada mostra, com o recordLoad isolado por chamada por AsyncLocalStorage. register sobre um log acima do teto (leitura sem tamanho, depois o alvo com bytes e sem lines), create_process repetido (alvo e depois leitura do mesmo processo, sem tamanho) e list com process (só esse processo, como leitura). A atribuição ao span de cada tool é provada pelo adaptador real no describe execute de adapters/otel.spec.ts. | ||
mcp/query.page.spec.ts | queryPage de src/mcp/tools/query.ts: maxChars em PAGE_CHARS_CAP, changes cortado em CHANGES_ITEMS_CAP por lista com omitted (acima do teto em entered, em left, nos dois e exatamente no teto), fields repassado ao serviço e relations assumido como counts, com full e none preservados. registerQueryTools por um servidor falso que só captura a config e o handler de registerTool, sem compose nem transporte (exceção em docs/directives/qualidade-e-testes.md): nome, title e READ_ANNOTATIONS das cinco tools de leitura; a descrição de cada uma com os termos do contrato; o evidence padrão do evaluate_gate (failing sem targets, counts com targets); os tetos de entrada (where e changesSince em chaves, text em QUERY_TEXT_MAX_CHARS, ids em 200, fields em 50 nomes e sem nome vazio, limit em 200, scope só process ou project, de 1 a 50 targets, surrogate solto recusado em where, text e changesSince, tudo no servidor falso e não pelo servidor real) e a chave since apontada para changesSince; um caso por fragmento da descrição de cada tool; os esquemas de saída (cada campo mantido, tipo errado recusado); e o corte de evidence do evaluate_gate em EVIDENCE_ITEMS_CAP por lista, com omitted, também em lote de targets. | ||
mcp/query-ergonomics.spec.ts | query pela tool, ajustes de ergonomia (a descrição e a mensagem de unrecognized_keys ficam em mcp/query.page.spec.ts): limit: 0 com changesSince devolve só changes (a entrada pode ser o id de um registro do processo) e sem changesSince dá INVALID_FILTER em /limit; targetPrefix de resposta vazia traz hint com o target que começa pelo prefixo sem a fronteira de ., e não traz hint quando há registros. | ||
mcp/tools.spec.ts | as 12 tools, com um único listTools no beforeAll (readOnlyHint nas 6 de leitura, alwaysLoad, title e anotações completas, inputSchema dentro das restrições do Claude Code), descrição ≤ 2.048 (o texto da descrição da query e das demais tools de leitura fica em mcp/query.page.spec.ts), soma dos outputSchema < 24.280, em tools/call a versão criada por define_* e cada tool de leitura devolvendo o que o serviço devolve, attach por path e read_attachment paginado em PAGE_CHARS_CAP, author gravado pelo register (client do envelope, model só quando informado), changes com omitted e releitura completa, corte de evidence do evaluate_gate (com evidence: full) e fields da query (recorte do data e o cenário de registros que estouram o teto sem fields e cabem com fields: []). | ||
mcp/lean-responses.spec.ts | Respostas enxutas pela tool, também com a herança de relações da linhagem de supersedes (query com inheritedInCounts, inheritedIn e none; evaluate_gate com inherit e evidence.inherited): evaluate_gate com padrão failing (contagens sem ids; ids só do que reprova), evidence: full idêntico ao do serviço byte a byte, counts, targets (um resultado por target na ordem, um só marker, padrão counts no lote e o replay de um target com o marker do lote trazendo os ids), target mantendo a forma de uma pergunta, as recusas INVALID_INPUT (with-target, lista vazia, mais de 50, full-with-targets) e o corte em EVIDENCE_ITEMS_CAP com omitted (com evidence: failing e full, e no lote), exatamente 50 targets aceitos; e query com padrão relations: counts (inCounts/outCounts sem in/out), full idêntico ao do serviço byte a byte, none, fields: [] com counts cabendo mais registros por página e relations desconhecido dando INVALID_INPUT. | ||
mcp/legacy.spec.ts | com dado 0.x em <D> as 12 tools respondem LEGACY_DATA com o comando em details, e a mesma instância volta a funcionar sem reinício depois de remover o dado. | ||
mcp/quarantine.spec.ts | Runbook de quarentena de docs/dados.md de ponta a ponta pelo servidor em memória: processo adulterado dá PROCESS_CORRUPTED no alcance projeto, fs.rename para fora de <D>, e então o alcance projeto volta, create_process recria o nome, a busca por text não serve o índice velho, o processo movido segue no disco, e a relação que apontava para ele sai sem current (nova dá RELATION_NOT_FOUND, missing em /records/0/relations/0). | ||
mcp/errors.spec.ts | entrada fora do schema dá INVALID_INPUT com details[].path em todas as tools (nunca INTERNAL nem "Input validation error"; casos representativos do teto de register), read_attachment, __proto__ recusado em register, query.where e define_gate e exceção não HexlogError → INTERNAL sem stack, aninhamento acima de 64 níveis nos args crus (too-deep; o data de register com 61 níveis passa e com 62 é recusado). Os tetos de entrada da query ficam em mcp/query.page.spec.ts; entradas exatamente no teto de read_attachment passam do zod. | ||
archive.spec.ts | src/archive.ts: inspectLegacy lista sem alterar <D>, archiveLegacy gera o .tar, relê e confere sha256 antes de apagar (falha de verificação, arquivo alterado ou novo entre a lista e a remoção nunca apagam o que não foi listado; o pacote é fixado no disco antes do primeiro unlink), hard link e erro de fs abortam com ArchiveError, retomada reaproveita o .tar válido mais novo, diretório 0.x sem arquivo é removido e a segunda execução não faz nada, lock 0.x vivo (holder de 0 byte conta como morto) e servidor 0.x vivo (/proc/<pid>/cmdline, também pelo realpath do libDir; /proc ausente ou sem pid, ou cmdline ilegível fora de ENOENT/ESRCH/EACCES/EPERM, também aborta) abortam, com a checagem repetida logo antes da remoção (servidor vivo que surge, e lock cujo pid passa a estar vivo, via process.kill simulado). Copia fixtures/legacy-0x/ para um diretório temporário. | ||
domains.spec.ts | Fluxos de fixtures/domains/ configurados só por tipos, nomes de relação e gates, pelo serviço de definições: gate plano-pronto do OMC (inclusive com scope project e a revisão de plano sem diff recusada na escrita), prova vencida do rdsc e TYPE_NOT_PINNED para tipo que o fluxo não definiu. | ||
directory.spec.ts | dataDir: XDG_DATA_HOME absoluto, vazio ou relativo → fallback ~/.local/share/hexlog. | ||
errors.spec.ts | Unitário de src/errors.ts (alvo do mutate de stryker.config.json): HexlogError (código, mensagem e details guardados, details vazio por padrão), o construtor genérico domainError (um detalhe que repete a mensagem, extras depois de path, code e message na ordem recebida, extra undefined omitido e null mantido), as fábricas de código fixo numa tabela (internalError, invalidInput, brokenChain, reservedName, legacyDataError, invalidArgs e invalidRecord: código, mensagem fixa e details de cada uma), pointer (RFC 6901, ~ escapado antes de /), capDetails (teto de 50 com too-many-errors e a contagem do que foi omitido, somando a do aviso que já vinha na lista, repetição de path, code e message descartada antes do corte) e issueDetails (cada issue do Zod vira um detalhe sob o prefixo, com o path escapado, repetida descartada e o mesmo teto de 50), fromIssues, fromDetails (prefixo no path de cada detalhe, sem mutar a entrada), mapDetails (erro novo de mesmo código e mensagem, todo detalhe mapeado, sem mutar a origem) e withPath (o que não é HexlogError volta intacto; reescreve o path de todo detalhe e põe process depois dele só quando dado). | ||
changelog.spec.ts | CHANGELOG.md contra src/version.ts#VERSION: tem a seção [Não lançado] e a versão do package.json tem seção datada (## [x.y.z] - AAAA-MM-DD) com ao menos uma entrada, e o rodapé da seção datada mais recente aponta para compare/v<anterior>...v<versão>. | ||
skill-coherence.spec.ts | Coerência das skills (skills/hexlog, hexlog-flow, hexlog-setup e suas references/) × código real: extratores próprios (crase fora de bloco cercado, nome de tool em src/mcp/tools/*.ts, constantes SCREAMING_SNAKE_CASE de src/domain/ e mcp/kernel.ts, catálogo de ErrorCode de src/errors.ts, nomes de função declarados em src/**/*.ts, citações caminho/arquivo.ts#símbolo relativas a src/), com as regex de citação de linha testadas sobre string literal; cruza cada tool/código/função citados contra o código, trava exatamente 12 tools e a contagem de códigos de erro, e confere cada citação contra a substring esperada da declaração (citationExpectations de cada caso de skill). Os campos citados em crase que não são tool vêm da FIELD_NAME_ALLOWLIST (lista plana, toda skill) e da SKILL_FIELD_ALLOWLIST (só a skill nomeada, como os campos de saída da query na hexlog-flow). Doc nunca cita linha de arquivo. | ||
skill-model.spec.ts | Exemplos de modelo de skills/hexlog-setup/references/*.example.json e documentos de skills/**/*.md: forma dos exemplos, validados por zod (chaves lidas das tabelas do model-schema.md, unit obrigatório com maxLength 200 em todo tipo de fase, sem pattern, nomes de processo válidos, distintos e iguais a scripts/flow/marker.ts#slugOf do caminho, nome do projeto que cabe no nome da skill sem ajuste, valores renderizados em uma linha e sem aspas duplas nem \, format: "attachment" só no primeiro nível, derivesFrom em toda ligação e em todo no_pending); o exemplo de três fases e o mínimo contra o servidor real (createEnvironment): define_type, define_relation, define_gate e evaluate_gate (uma passagem e uma reprovação com a evidência apontando a fase sem sucessora ligada); varreduras dos .md das skills (editedSkills, o termo antigo do mapa de fluxo, targetIdPattern, flow.md só na SKILL.md da hexlog-flow, sem OMC nem settings.json na hexlog-setup, título de armadilhas só na hexlog, list antes do primeiro define_* no corpo da SKILL.md do setup) o roteiro de interview-guide.md (teto do nome do projeto), o runbook docs/setup-aceitacao.md (item de checklist em toda seção), a seção de requisitos de docs/instalacao.md e a varredura dos termos aposentados do setup em README.md, AGENTS.md e docs/. Também varre os templates references/owner-seat*.template.md (sem termo do fluxo de desenvolvimento, chaves de regra do documento de critérios em minúsculas, números e hífen, sem repetição) e a seção ownerSeat do model-schema.md (ao menos um campo, nenhum caminho absoluto, ~ ou $HOME). Trava ainda, nos templates da cadeira, a seção Scope do contrato (proíbe a escrita fora da resposta e diz que é instrução, não barreira), o ok do dev antes da receita agy, o teto de 120 caracteres da chave de regra no documento de critérios e a ausência de linha Status e de --setting-sources nas receitas. | ||
owner-seat-package.spec.ts | Ensaia em memória (mcp/environment.ts#createEnvironment) o pacote de skills/hexlog-setup/references/owner-seat/, lido por flow-data.ts#namesIn e definitionOf com o parâmetro dir: cada definição aceita pelo servidor e em replay unchanged, o gate gaps (falha com lacuna aberta, passa com a premissa que a fecha, volta a falhar com ela revogada), a query do audit e do dependente (needsReview quando a resposta é revogada, dependente superado só marcado se regravou o supports), a recusa de campo novo em processo criado antes do pacote e do revokes entre processos (cross-process-currency), classifyTypeChange (campos acrescentados compatible, maxLength menor breaking), a recusa de dado inválido por campo e de ponta de relação com endpoint-type pelo register real, os limites aceitos dos enums e do maxLength, e os required do pacote. | ||
seat-report.spec.ts | scripts/seat-report.ts como processo real (spawnSync) contra um XDG_DATA_HOME temporário semeado por commands/fakes.ts#composeIn: as oito seções na ordem fixa e exclusivas, as marcas de "sem critério" (basis ausente distinto de basis desconhecido), lacuna aberta e fechada, lacuna superada com a substituta aberta, resposta com evidence e dependente sem aval, aval, aval revogado e audit de retirada, resposta contestada e a lacuna reaberta, answeredBy humano, ausente e não reconhecido (valor entre aspas), resposta humana de agent owner-seat-* e aval do mesmo autor marcados, --process, --types com nomes mapeados, papel sem registro com tipo inexistente no projeto (exit 1), escape de terminal e quebra de linha em cada campo que o agente grava (agent, model, client, rule, question, action e o sufixo [audited by …]), as classes que só o escapeControls cobre, contagem (N) do título, volume acima do padrão de 50 do serviço, diretório de dados intacto (hash e mtime), dado 0.x e log adulterado (exit 2) e uso incorreto (exit 1). | ||
package.spec.ts | Invariantes de manifesto e superfície contra o repo real: nenhum import fora do repo em src//hook//scripts//test/; dependencies/devDependencies/engines.node têm exatamente os pacotes esperados, cada um em faixa ^X.Y.Z (o spec trava o conjunto e o formato da faixa, não a versão); VERSION de src/version.ts bate com package.json.version; .gitignore contém dist/; sem bin; nenhum arquivo de src/ importa módulo de servidor de rede nem chama .listen(; sem diretório cli; sem console/process.stdout.write em src/; src/directory.ts só importa node:* e es-toolkit. | ||
lint-staged.config.spec.ts | lint-staged.config.ts: a sequência de tarefas dos *.ts, dos *.md e dos *.example.json e o recorte de specs (núcleo fixo em todo commit .ts; y.ts em qualquer pasta casa y*.spec.ts em qualquer pasta de test/, inclusive src/adapters/fs/lock.ts para test/adapters/lock.spec.ts; spec em stage roda a si mesmo). | ||
spec-naming.spec.ts | Varredura de src/, scripts/, hook/ e .claude/hooks/ contra a regra de nome de docs/directives/qualidade-e-testes.md: arquivo sem spec de mesmo nome (por lint-staged.config.ts#namePatterns) fora de EXCEPTIONS reprova, entrada obsoleta da lista reprova e, em nome repetido na produção, só conta o spec que cita o caminho do arquivo. | ||
commitlint.config.spec.ts | commitlint.config.js pelo commitlint real (node_modules/.bin, mensagem no stdin, spawnSync com timeout): header convencional sem corpo passa, tipo ausente, header de 81 caracteres e corpo reprovam (80 passa), e o commit do Dependabot passa só com o rodapé Signed-off-by: dependabot[bot]. | ||
pre-commit.spec.ts | .husky/pre-commit: lê o hook e afirma que ele chama lint-staged --concurrent false, para as chaves rodarem em série. | ||
stryker-config.spec.ts | stryker.config.json: todo caminho de mutate e de jest.config.testMatch aponta para um arquivo que existe. | ||
bash-guard.spec.ts | Hook hook/bash-guard.ts via spawnSync direto (stdin JSON do protocolo PreToolUse): nega acesso a D, permite o que não alcança D, nega token ou comando hostil (glob acima dos tetos ou do orçamento por comando, faixa de chave, token que lança) e falha aberto só em entrada inválida, e a mensagem de deny cita exatamente as tools que o servidor anuncia com readOnlyHint. Também constrói o bundle real (via fixtures/build-entry.ts) e confirma que não contém o shim do esbuild. | ||
guard.spec.ts | src/guard.ts e registerGuard: applyGuard (idempotente sobre o template, a matcher/tipo reparados, o hook movido de uma entrada compartilhada e o trio de um <D> antigo; preserva o hook alheio, o comentário e as regras que o usuário escreveu; recusa settings.json malformado com INVALID_INPUT e o ponteiro do campo; o trio de um <D> antigo só sai pelo predicado fechado), verifyGuard (as 4 regras de deny, hook, hook-matcher e, com o hook real instalado num HOME com espaço, hook-not-denying, hook-not-allowing, hook-file, node, artifact-modified e mcp), expectedRules (o texto exato das 4 regras) e registerGuard (grava por writeFileAtomic com o .bak-hexlog, devolve removed, segue o link simbólico do settings.json, recusa settings.json ausente ou inválido e traduz EPERM/ENOTSUP do hard link do backup). | ||
installation.spec.ts | src/installation.ts: installArtifact com os bundles reais (instala sob ~/.local/lib/hexlog/<versão>/ com manifest.json, decide pelos bytes instalados na 2ª execução, reinstala e repara com aviso, recusa com INTERNAL e details vazio, sem deixar a pasta da versão, quando a sonda deny ou allow do hook falha, o servidor não sobe ou não lista as 12 tools ou o bundle tem Dynamic require of; a concorrência real de processos roda por fixtures/concurrent-install.ts), writeSkillFolder (cópia, troca atômica, varredura dos temporários legados por sufixo e dos .hexlog-skill-* de pid morto, falha de rmSync ou de listagem ignorada, skills/ como link para outro filesystem, nome inválido recusado) e verifyInstallation sobre uma instalação real feita por install-helpers.ts#installBaseline. | ||
install.spec.ts | scripts/install.ts como processo real, com HOME e XDG_DATA_HOME temporários e o claude mcp add/remove trocado por fixtures/fake-mcp-install.ts (HEXLOG_REGISTER_MCP): aborta antes de gravar o settings.json se a troca da skill falha, recusa argumento desconhecido (exit 1, nada escrito), --check (instalação completa, hook-file e skill-file:<nome> ausentes, outro cwd, <D> ilegível com ENOTDIR) e, sobre a cópia de fixtures/legacy-0x/: sem flag lista o que arquivaria e deixa <D> intacto, --archive-0x arquiva e depois instala (com lock vivo aborta sem apagar), --check --archive-0x não escreve nada, removed deny rule: por item e segunda execução sem arquivar. | ||
install-helpers.ts | Não é spec. Apoio dos specs do instalador: repoRoot, buildSettingsTemplate(home) (o settings.json de uma reinstalação do zero), denyOf(text) (as regras de permissions.deny), packageVersion(), runInstaller(home, D, args, cwd?) (o processo real), createInstallHome(prefix), installBaseline() (uma instalação real num HOME descartável, de que o --check e o verifyInstallation partem) e useHome(home) (aponta HOME do processo de teste para home, sem XDG_DATA_HOME, e devolve o restore: o hook real herda o process.env). | ||
stdio.e2e.spec.ts | e2e contra o bundle real de src/server.ts (build por processo filho, fixtures/build-entry.ts), nunca src/*.ts: o bundle sem o shim Dynamic require of, LEGACY_DATA sobre cópia de fixtures/legacy-0x/, INVALID_INPUT estruturado, client gravado a partir do clientInfo, query com fields: [] sem data e uma chamada de cada uma das 12 tools (um caso por comportamento sobre a mesma sessão: sem erro, stdout só JSON-RPC, stderr só registros JSON sem INTERNAL, o start e exatamente TOOLS_COUNT registros tool). Cada caso fecha o cliente por withClient, que devolve o stderr só depois do client.close(). Também confere que o bundle anuncia TOOLS_COUNT tools, describe_type entre elas, e que um tipo com pattern exponencial e texto de 300 caracteres volta INVALID_RECORD com max-length em segundos, não travado. Uma linha de stdin acima de 10 MiB deixa o evento transport-error no stderr antes de o servidor sair, e um envelope com 100 mil chaves extras deixa a linha abaixo de 1 KiB, com issues e sem message. Os describes with HEXLOG_OTEL_ENDPOINT … sobem filhos por spawn direto contra o receptor local de otlp-receiver.ts: telemetria desligada (o SIGTERM mata por sinal, prova de que nenhum handler foi instalado), ligada com ambiente OTEL_* hostil (só o receptor da chave própria recebe, com os cabeçalhos certos, e o lote final sai no EOF), porta fechada (aviso telemetry-degraded por chamada), receptor mudo (chamadas rápidas e saída em até 3 s do EOF) e SIGTERM com saída 143. | ||
cli-error.spec.ts | scripts/cli-error.ts#formatCliError: Error e texto lançado viram INTERNAL com exit 1, e LEGACY_DATA sai com exit 2. | ||
insights.spec.ts | CLI somente-leitura scripts/insights.ts via spawnSync sobre compose: filtro projeto/projeto/processo, cadeia íntegra ou adulterada, sinais da chave (possível duplicata sem chave, chave em excesso como proxy de lote de 1 registro, e percentual de lotes com chave por tipo), anexo adulterado (attachments: BROKEN), primeiro elo quebrado (0 valid records e timeline: unavailable (chain broken)), cadeia ou anexo adulterado saem com 2, falha de leitura com IO_ERROR na linha do processo (exit 1) e o caso misto com cadeia quebrada (o maior, 2), process.json truncado com o relatório completo e a linha PROCESS_CORRUPTED do processo (exit 2), uso incorreto (exit 1), dado 0.x sai com 2 e a mensagem do LEGACY_DATA (só aqui) e não altera o dataDir. | ||
export.spec.ts | CLI somente-leitura scripts/export.ts via spawnSync sobre compose: uma linha JSON por registro na ordem do log (incluindo o não vigente), paginação por cursor, --fields sobre as chaves de QueryRecord (sem valor, flag desconhecida e argumento a mais saem com o uso), cadeia adulterada sai com 2 sem exportar e <D> intacto. Dado 0.x sai com 2 (LEGACY_DATA) e process.json truncado sai com 2 (PROCESS_CORRUPTED). | ||
timeline.spec.ts | CLI somente-leitura scripts/timeline.ts via spawnSync sobre compose: consulta de alcance projeto com não vigentes por prefixo de target, --full --raw com texto ≥ 200 KB idêntico entre os delimitadores, escape de terminal sem --raw (ESC, OSC, C1, bidi, DEL e CR viram \uXXXX; TAB e LF passam), --raw com o byte exato e --json com o mesmo escape sem perda, --json com attachmentText, exit 2 com cadeia, process.json ou blob quebrado, uso incorreto (exit 1) e árvore do dataDir intacta. Dado 0.x sai com 2 (LEGACY_DATA). | ||
read-scripts-inheritance.spec.ts | scripts/export.ts (inheritedIn, inheritedOut e --fields) e scripts/timeline.ts (inherited in:/inherited out: com origin) sobre um processo com herança. | ||
escape-controls.spec.ts | scripts/escape-controls.ts: escapeControls troca 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) por \uXXXX visível, deixa passar LF, TAB, acento, emoji com ZWJ, BOM, o ponto de código logo depois da faixa de tag, os caracteres de formato do risco aceito e os vizinhos da faixa de seletores, mantém uma string JSON com tag character e separador de linha legível de volta pelo JSON.parse, e é idempotente. | ||
release-notes.spec.ts | scripts/release-notes.ts e scripts/release-notes-cli.ts: releaseNotes (abertura, linha do PR, subseções rebaixadas fora de cerca de código, bloco de instalação, seção ausente ou vazia, variantes de cerca do CommonMark) e o CLI como processo real (spawnSync) sobre o CHANGELOG.md do repositório, com exit 1 em uso incorreto (inclui --repo fora de dono/nome ou sem --pr) e versão sem seção. | ||
directives.spec.ts | Trava dos documentos: todo link .md relativo, @ do CLAUDE.md e citação de arquivo com título de seção em crase resolvem; cada doc vivo de docs/directives/ é importado pelo CLAUDE.md ou carregado por symlink em .claude/rules/ (com paths entre aspas no doc e sem @path em prosa), respeita os tetos de linhas e o que o CLAUDE.md importa respeita o de bytes; nenhum AGENTS.md tem os títulos extraídos (Fronteiras, Working In This Directory, Testing Requirements, Common Patterns) e o link para docs/directives/ só vem depois de ## Manual Notes; os termos de seleção da checagem não aparecem no que o agente lê; formato das premissas de estrategia.md (extração por scanPremises/parsePremises de scripts/flow/sync.ts); name e citações das skills locais do fluxo, as seções dos ADRs 0010, 0011 e 0012 e as regras do doc da cadeira do dono (bullet de até 400 caracteres) nas skills de entrada. Ignora docs/pesquisa/. | ||
flow-definitions.spec.ts | Ensaia em memória (mcp/environment.ts#createEnvironment) as definições de .hexlog/ (tipos, relações e gates): registro válido de cada tipo, pontas das relações (uma tabela de endpoint-type), gates pre-pr (só no_pending, sem verification) e gaps, as duas gerações do processo de diretrizes, premise (com o answeredBy opcional: enum recusado, ausência válida e mudança compatible), evidence e fills-gap, o commit que não é git-sha recusado com code: 'format', o lote com key repetida e o lote obsoleto (IDEMPOTENCY_CONFLICT, FORK_REJECTED), os hashes devolvidos por define_* e um trabalho completo da abertura ao verify_chain. | ||
flow-sync.spec.ts | scripts/flow/sync.ts: planSync sem ambiente (guarda invalid-path, teto de relações, lotes de 50 e 11, chaves, regra interpretada, premissas de estrategia) e aplicado em lotes sobre o servidor (carga, edição, closes, remoção, lápide, falha parcial e gates) e parsePremises. | ||
flow-helpers.ts | Não é spec. Ambiente (openEnvironment, openBareEnvironment, closeEnvironment, environment), dados de exemplo (opening, decisionData, gapData, findingData, workRecord, premise), leitura (queryAll, outEdgesOf, passed) e a rotina de sync (inputFor, runSync, staleBatch, seedDirective, seedPremise) de flow-definitions.spec.ts e flow-sync.spec.ts. | ||
flow-data.ts | Não é spec. Carrega as definições de .hexlog/ num createEnvironment (defineFlowDefinitions, que aceita o schema de um tipo antigo, createFlowEnvironment, definitionOf, namesIn, estes dois com o parâmetro dir para ler outra pasta de definições, como o pacote da cadeira) e grava registros do fluxo (registerFlowRecord); createLegacyLineageProcess abre um processo sem lineageInheritance, como os de antes da herança. Usado por flow-helpers.ts, flow-report-fixture.ts, flow-scripts.spec.ts, gate.spec.ts, reanchor.spec.ts e writer.spec.ts. | ||
gate.spec.ts | scripts/flow/gate.ts pre-pr <slug> por processo real (spawnSync) sobre o histórico de um servidor de createEnvironment copiado para um XDG_DATA_HOME temporário: sai 0 com pre-pr e gaps verdes, sai 1 listando o finding URGENT sem resolves-finding e a gap sem fechador, sai 2 com dado 0.x e sai 1 com o uso para argumentos inválidos. | ||
flow-hooks.spec.ts | Hook .claude/hooks/flow-hooks.ts por processo real (spawnSync) num repositório git temporário com worktree e origin/* criados à mão: pre-pr (create_pull_request, gh pr create, gh pr ready e update_pull_request, marcador por branch e sha, -R, owner: e --undo, aspas e heredoc), com a mensagem de cada recusa conferida (NO_MARKER só onde falta o marcador), entrada ilegível e git falhando negados, o modo subagent-start (um it por comportamento sobre um Act único: regra curta de devolver a lacuna nova na primeira das três linhas) e o modo desconhecido (slug e mark já não são do hook). | ||
flow-scripts.spec.ts | CLIs de scripts/flow/ por processo real: flow.ts roda slug (recusa main, develop, directives-N, audits e os nomes de RESERVED_PROCESS_NAMES, que trava a cobertura de marker.ts#RESERVED_SLUGS); mark.ts grava no git-common-dir compartilhado, com a árvore suja, e recusa sem gravar com gate vermelho ou branch que não gera o slug; marker.ts só importa node:*. | ||
flow-settings.spec.ts | Entradas de .claude/settings.json: os matchers de PR e de Bash terminam em ` | exit 2e saem com 2 semnode, a lista allowdos scripts do fluxo, oallowdocritic.ts, o askdeinstall.ts, de reanchor.ts --applye desync-cli.ts --apply(e nenhumallowdosync-cli.ts) com o alcance do padrão e a ausência do relatório em hooks`. | |
flow-repo.ts | Não é spec. Repositório git temporário (createRepo, estado em repoState), runNode, runHook e os atalhos do hook (bash, mcpCreate, preHook, writeMarker, expectDenied, expectAllowed) de flow-hooks.spec.ts, flow-scripts.spec.ts e flow-settings.spec.ts. | ||
report.spec.ts | scripts/flow/report.ts por processo real (spawnSync), sobre o fixture de flow-report-fixture.ts (histórico de um servidor de createEnvironment copiado para um XDG_DATA_HOME temporário e um repositório git temporário com origin/develop criado à mão): motivos only-objective, only-sentinel, only-objective+sentinel e doc-amended, critical-gap (lacuna crítica aberta, fechada por simulated, sem o doc no diff, por directive, sem answeredBy ou com aval posterior à emenda) e rests-on-simulated, vigência e paridade com a tool query, base trocada ou inválida, avisos em stderr sem saída (slug e base recusados, processo inexistente, dado 0.x) por it.each, leitura do processo de diretrizes que falha (PROCESS_NOT_FOUND), teto de 100 linhas e de 10 uncited=, com as bordas exatas (100 linhas, 10 premissas) sem corte. | ||
flow-report-fixture.ts | Não é spec. createReportFixture grava os processos do relatório (um por cenário), o XDG_DATA_HOME com e sem directives-9 e o repositório git de report.spec.ts. | ||
reanchor-plan.spec.ts | scripts/flow/reanchor-plan.ts importado direto, sem processo filho: estados da âncora (same, changed, gone, ambiguous, stale) por tipo, lista de relações regravadas e as que vão ao dono, supersedes de saída, supports com e sem herança de linhagem, isLatestGeneration (comparação numérica), idempotência, lotes de até 50 com key pelo conteúdo, verifyReanchor e o teto de formatPlan. | ||
writer.spec.ts | scripts/flow/writer.ts: checkInstalled com o git injetado (servidor ausente, versão, manifest.json ausente ou de tipo inválido, dirty, commit nulo e diff de src/), gitDiffQuiet contra um repositório git temporário (igual, diferente, commit desconhecido, raiz que não é repositório, mudança fora de src/ e cwd fora da raiz) e openWriter sobre um compose real (grava um lote com o autor dado, replay da key, recusa por código instalado, dado 0.x e autor inválido) e o attach (hash dos bytes, blob em attachments/ do projeto, mesmo hash na repetição, recusa de arquivo que não é .md/.txt e de arquivo fora do cwd). | ||
critic-tools.spec.ts | scripts/flow/critic-tools.ts importado direto, sem processo filho: resolveTool, buildCommand de cada ferramenta (id explícito, --mcp-config= com o prompt por último, sem --tools/--allowedTools), parseTurn/foldTurn sobre streams reais gravados, classifyFailure, truncateText, buildPrompt e buildRules (cláusulas das regras-base e o bloco de ações) | ||
critic-catalog.spec.ts | scripts/flow/critic-catalog.ts importado direto: parseCatalog sobre o doc real e sobre texto sintético (cabeçalho esperado quando falta tabela), renderActions por coluna, coerência do enum actionUsed com o catálogo e a trava de imports sem fs nem src/ | ||
critic-run.spec.ts | scripts/flow/critic-run.ts por fixtures/critic-driver.ts num filho com o CLI falso no PATH (fixtures/fake-critic-cli.ts): runTurn (relógio de inatividade, teto, kill do grupo com neto, teto de texto), startSession (inclusive doc do catálogo ilegível e rules.txt), closeMailbox e procStartTime; o askQuestion fica em critic-run.ask.spec.ts | ||
critic-run.ask.spec.ts | askQuestion de scripts/flow/critic-run.ts, pelo mesmo driver e CLI falso de critic-run.spec.ts: mailbox sem rules.txt, retomada, retry com backoff, broken, ask.lock de pid morto ou startTime diferente, falha de credencial, teto de pergunta e prompt. Casa com critic-run.ts no lint-staged | ||
critic.spec.ts | CLI scripts/flow/critic.ts por spawn com o CLI falso no PATH: argv, precedência de --tool e HEXLOG_CRITIC_CLI até o session.json, o verbo rules, as saídas de 0 a 7 e SIGTERM no meio de um ask (grupo morto, lock solto, mailbox mantida) | ||
critic-helpers.ts | Não é spec. Apoio dos specs do critic: installShims (shims claude e agy no PATH), criticEnv, runDriver (chama fixtures/critic-driver.ts por runProcess), runProcess, makeMailbox, leitores do session.json e das respostas, SPEC_TIMEOUT, NO_BINARY e o tipo Reply | ||
reanchor.spec.ts | CLI scripts/flow/reanchor.ts por processo real (spawnSync) com XDG_DATA_HOME por copyToXdg e HOME temporário com .claude.json e manifest.json: dry-run que não muda o dado e avisa do código instalado, --apply que regrava só as âncoras idênticas e não grava de novo, gate.ts igual antes e depois, recusas (--to que não é a maior geração, uso, problema do código instalado) e dado 0.x com exit 2. | ||
sync.spec.ts | scripts/flow/sync.ts importado direto, sem processo filho: validateExtracted (tetos iguais ao maxLength dos tipos de .hexlog/, pontos de código no lugar de unidades UTF-16, slug repetido, estrategia) e verifySync (o log relido contra o plano, inclusive relação de nome fixado). | ||
sync-cli.spec.ts | CLI scripts/flow/sync-cli.ts por processo real (spawnSync), com XDG_DATA_HOME e HOME temporários: check, plan em dry-run, teto estourado, documento alterado sem regras no stdin, plan --apply (lotes gravados e conferidos, repetição que não grava), lote recusado, recusa por código instalado e processo ausente ou que não é a maior geração. |
Subdirectories
| Directory | Purpose |
fixtures/ | Corpus determinístico, scripts de build sob demanda e probes executados como processo filho (see fixtures/AGENTS.md) |
Navigation Notes
fixtures/legacy-0x/é dado real do 0.x, gerado pelas tools 0.x (ocreateServerdo 0.x comClientMCP eInMemoryTransport,HOMEeXDG_DATA_HOMEtemporários, relógio fixo em2026-01-01T00:00:00.000Z, só nos eventos deevents.jsonl) a partir do commit40be7aede28b3d0014bdb2a0462e24f97de1af1d; o gerador era descartável e não é versionado. Sequência no projetoalpha, processomain:register_vocabulary(ownercore,milestoneType: [approved]),register_type(note, comattachment),register_gate(custom-gate),attachment(text: relatorio integral),create_process,registerde um marcoapproved(targethex:target:fixture) eregisterde umnotecitando o anexo.alpha/schemas/note.json(formato legado plano, que o 0.x atual não grava) é cópia byte a byte dealpha/schemas/note/1.0.json. OsregisteredAtdeschemas/,gates/evocabulary/são do relógio real (2026-10-03T09:21:15), não do relógio fixo. Os ids dos eventos têm UUIDv7 do run: os specs hasheiam o que leem.
Dependencies
Internal
src/*— a árvore testada (domain,shared,adapters,commands,queries,mcp,compose.ts,server.ts,archive.ts,guard.ts,installation.ts).scripts/build.ts— construído sob demanda pelas specs de artefato, via os fixtures de build.scripts/install.ts— rodado como processo real porinstall.spec.tse, viainstall-helpers.ts#installBaseline, porinstallation.spec.ts.scripts/insights.ts,scripts/export.tsescripts/timeline.ts— rodados como processo real porinsights.spec.ts,export.spec.tsetimeline.spec.ts, sobre dados gravados porcompose;scripts/release-notes.tsescripts/release-notes-cli.ts— importado direto e rodado como processo real porrelease-notes.spec.ts;scripts/escape-controls.ts— importado direto porescape-controls.spec.tsetimeline.spec.ts.hook/bash-guard.ts— testado direto (fonte) e como bundle.scripts/flow/report.ts,mark.ts,gate.tseflow.ts— rodados como processo real porflow-scripts.spec.ts(markeflow.ts slug),report.spec.ts(report) egate.spec.ts(gate); os specs nunca importam suas funções.scripts/flow/reanchor-plan.tsescripts/flow/writer.ts— importados direto porreanchor-plan.spec.tsewriter.spec.ts;scripts/flow/reanchor.ts— rodado como processo real porreanchor.spec.ts, e oaskde--applyem.claude/settings.jsonconferido porflow-settings.spec.ts.scripts/flow/critic-tools.ts— importado direto porcritic-tools.spec.ts;scripts/flow/critic-catalog.ts— importado direto porcritic-catalog.spec.ts;scripts/flow/critic-run.ts— chamado porfixtures/critic-driver.tsem processo filho (critic-run.spec.tsecritic-run.ask.spec.ts);scripts/flow/critic.ts— rodado como processo real porcritic.spec.ts, e oallowdele em.claude/settings.jsonconferido porflow-settings.spec.ts.scripts/flow/marker.ts— lido porflow-scripts.spec.ts(só importanode:*), importado pelo hook e, peloslugOf, porskill-model.spec.ts..claude/hooks/flow-hooks.ts— rodado como processo real porflow-hooks.spec.ts.scripts/flow/sync.ts#planSync— importado direto porflow-sync.spec.ts,flow-definitions.spec.tseflow-scripts.spec.ts;directives.spec.tsimportaparsePremisesescanPremises, eflow-sync.spec.tstambémparsePremises;sync.spec.tscobrevalidateExtractedeverifySync.scripts/flow/sync-cli.ts— rodado como processo real porsync-cli.spec.ts, e oaskde--applyem.claude/settings.jsonconferido porflow-settings.spec.ts..hexlog/— definições (types/,relations/,gates/) ensaiadas porflow-definitions.spec.ts.
External
jest,ts-jest,@jest/globals— runner e transform.fast-check— property-based testing.@modelcontextprotocol/client(Client,StdioClientTransport) e@modelcontextprotocol/server(InMemoryTransport) — cliente/transporte MCP de teste.
Manual Notes
Diretrizes
- qualidade-e-testes.md: comandos antes de concluir, orçamentos, convenções dos specs, bundle e fixtures
- documentacao.md: famílias de ID, que os títulos de teste não carregam
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
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.

