ai-execution-protocol 0.1.0__tar.gz

ai_execution_protocol-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AI Execution Protocol
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ai_execution_protocol-0.1.0/PKG-INFO

@@ -0,0 +1,180 @@
+Metadata-Version: 2.4
+Name: ai-execution-protocol
+Version: 0.1.0
+Summary: Experimental AI execution protocol for safer agent workflows, minimal context, risk classification, validation, and evidence-based delivery.
+Author: AI Execution Protocol
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/rodneigk2/ai-execution-protocol
+Project-URL: Repository, https://github.com/rodneigk2/ai-execution-protocol.git
+Project-URL: Issues, https://github.com/rodneigk2/ai-execution-protocol/issues
+Keywords: ai,agent,codex,protocol,risk,validation,prompt
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# AI Execution Protocol
+
+Framework experimental para orientar agentes de IA em tarefas tecnicas com mais
+seguranca, contexto minimo, validacao e controle de risco.
+
+O alvo atual e Codex. O protocolo e otimizado para Codex agora, mas foi
+organizado para continuar portavel para outras IAs no futuro.
+
+## Objetivo
+
+Evitar que a IA execute pedidos de forma impulsiva, perigosa ou fora de escopo.
+
+O framework ajuda a IA a:
+
+- entender a intencao antes de agir;
+- classificar o risco da tarefa;
+- ler apenas o contexto necessario;
+- mapear impacto antes de alterar arquivos;
+- pedir confirmacao em acoes sensiveis;
+- validar o resultado antes de entregar;
+- explicar limites e risco residual.
+
+## Ideia central
+
+```text
+Entender -> classificar risco -> mapear impacto -> executar -> validar -> entregar
+```
+
+O protocolo nao tenta transformar toda tarefa em um processo pesado. A regra e
+proporcionalidade: tarefa simples deve ser rapida; tarefa critica exige mais
+mapa, confirmacao e evidencia.
+
+## Status
+
+Projeto em fase de pesquisa e evolucao.
+
+Este repositorio contem uma proposta tecnica, nao uma garantia de seguranca nem
+uma fonte normativa definitiva. Testes reais, revisao humana e criterio tecnico
+continuam obrigatorios em tarefas criticas.
+
+## Estrutura
+
+- `AGENTS.md`: instrucao principal para agentes no projeto.
+- `INDEX.yaml`: mapa estruturado para navegacao rapida.
+- `config.yaml`: configuracao do alvo atual e versao do protocolo.
+- `docs/`: explicacoes conceituais em Markdown.
+- `protocol/`: regras operacionais curtas em YAML.
+- `cases/`: casos estruturados para testar o comportamento da IA.
+- `examples/`: exemplos humanos de uso do framework.
+- `schema/`: contratos para manter os YAML padronizados.
+- `eval/`: rubrica e exemplos de avaliacao.
+- `scripts/`: automacoes de instalacao, validacao e avaliacao.
+- `responses/`: exemplos de respostas para avaliacao.
+- `benchmarks/`: comparacoes entre execucao com e sem protocolo.
+- `model-runs/`: respostas reais por modelo para comparacao.
+- `real-runs/`: templates ou registros de execucoes reais auditaveis.
+- `dist/minimal/`: pacote minimo gerado para instalar em outros projetos.
+
+## Como usar como agente
+
+1. Leia `INDEX.yaml`.
+2. Confirme o alvo atual em `config.yaml`.
+3. Leia `protocol/fast-path.yaml`.
+4. Use `protocol/router.yaml` para escolher o menor contexto suficiente.
+5. Abra apenas os arquivos indicados pela rota.
+6. Execute, valide e entregue com evidencia.
+
+## Como estudar o framework
+
+Comece por:
+
+- `docs/00-visao-geral.md`
+- `docs/01-modelo-de-execucao.md`
+- `docs/02-niveis-de-risco.md`
+- `docs/03-mapeamento-antes-de-alterar.md`
+- `docs/05-validacao-e-entrega.md`
+- `docs/14-publicacao.md`
+
+Use `docs/` para entender a metodologia. Use `protocol/` quando quiser aplicar
+as regras em uma tarefa real.
+
+## Validacao local
+
+Execute a validacao geral:
+
+```powershell
+python scripts/health_check.py
+```
+
+Execute a bateria estrutural extra:
+
+```powershell
+python scripts/framework_tests.py
+```
+
+Meca custo aproximado de leitura por rota:
+
+```powershell
+python scripts/token_report.py
+```
+
+## Instalacao em outro projeto
+
+Projeto novo:
+
+```powershell
+ai-protocol init .
+```
+
+Projeto existente:
+
+```powershell
+ai-protocol install .
+```
+
+Previa sem alterar arquivos:
+
+```powershell
+ai-protocol install . --dry-run
+```
+
+Instalacao local via PowerShell:
+
+```powershell
+.\install.ps1 C:\caminho\projeto -Force
+```
+
+Instalacao local via npm:
+
+```powershell
+npm run install-protocol -- C:\caminho\projeto
+npm run dry-run-protocol -- C:\caminho\projeto
+```
+
+Instalacao local via Python:
+
+```powershell
+python scripts/install_protocol.py --target C:\caminho\projeto --force
+python scripts/verify_install.py --target C:\caminho\projeto
+```
+
+O final esperado da verificacao e `PASS`.
+
+## Publicacao
+
+Antes de publicar, revise `docs/14-publicacao.md`.
+
+Resumo minimo:
+
+- nao publique `.env`, chaves, tokens, senhas, logs reais ou dados de cliente;
+- mantenha artefatos gerados fora do Git quando nao forem necessarios;
+- use `.gitignore`;
+- publique com `README.md`, `LICENSE`, `docs/`, `protocol/`, `cases/`,
+  `examples/`, `schema/`, `eval/` e `scripts/` quando fizer sentido;
+- preserve o posicionamento como pesquisa experimental e framework em evolucao.
+
+## Licenca
+
+Distribuido sob a licenca MIT. Veja `LICENSE`.

ai_execution_protocol-0.1.0/README.md

@@ -0,0 +1,159 @@
+# AI Execution Protocol
+
+Framework experimental para orientar agentes de IA em tarefas tecnicas com mais
+seguranca, contexto minimo, validacao e controle de risco.
+
+O alvo atual e Codex. O protocolo e otimizado para Codex agora, mas foi
+organizado para continuar portavel para outras IAs no futuro.
+
+## Objetivo
+
+Evitar que a IA execute pedidos de forma impulsiva, perigosa ou fora de escopo.
+
+O framework ajuda a IA a:
+
+- entender a intencao antes de agir;
+- classificar o risco da tarefa;
+- ler apenas o contexto necessario;
+- mapear impacto antes de alterar arquivos;
+- pedir confirmacao em acoes sensiveis;
+- validar o resultado antes de entregar;
+- explicar limites e risco residual.
+
+## Ideia central
+
+```text
+Entender -> classificar risco -> mapear impacto -> executar -> validar -> entregar
+```
+
+O protocolo nao tenta transformar toda tarefa em um processo pesado. A regra e
+proporcionalidade: tarefa simples deve ser rapida; tarefa critica exige mais
+mapa, confirmacao e evidencia.
+
+## Status
+
+Projeto em fase de pesquisa e evolucao.
+
+Este repositorio contem uma proposta tecnica, nao uma garantia de seguranca nem
+uma fonte normativa definitiva. Testes reais, revisao humana e criterio tecnico
+continuam obrigatorios em tarefas criticas.
+
+## Estrutura
+
+- `AGENTS.md`: instrucao principal para agentes no projeto.
+- `INDEX.yaml`: mapa estruturado para navegacao rapida.
+- `config.yaml`: configuracao do alvo atual e versao do protocolo.
+- `docs/`: explicacoes conceituais em Markdown.
+- `protocol/`: regras operacionais curtas em YAML.
+- `cases/`: casos estruturados para testar o comportamento da IA.
+- `examples/`: exemplos humanos de uso do framework.
+- `schema/`: contratos para manter os YAML padronizados.
+- `eval/`: rubrica e exemplos de avaliacao.
+- `scripts/`: automacoes de instalacao, validacao e avaliacao.
+- `responses/`: exemplos de respostas para avaliacao.
+- `benchmarks/`: comparacoes entre execucao com e sem protocolo.
+- `model-runs/`: respostas reais por modelo para comparacao.
+- `real-runs/`: templates ou registros de execucoes reais auditaveis.
+- `dist/minimal/`: pacote minimo gerado para instalar em outros projetos.
+
+## Como usar como agente
+
+1. Leia `INDEX.yaml`.
+2. Confirme o alvo atual em `config.yaml`.
+3. Leia `protocol/fast-path.yaml`.
+4. Use `protocol/router.yaml` para escolher o menor contexto suficiente.
+5. Abra apenas os arquivos indicados pela rota.
+6. Execute, valide e entregue com evidencia.
+
+## Como estudar o framework
+
+Comece por:
+
+- `docs/00-visao-geral.md`
+- `docs/01-modelo-de-execucao.md`
+- `docs/02-niveis-de-risco.md`
+- `docs/03-mapeamento-antes-de-alterar.md`
+- `docs/05-validacao-e-entrega.md`
+- `docs/14-publicacao.md`
+
+Use `docs/` para entender a metodologia. Use `protocol/` quando quiser aplicar
+as regras em uma tarefa real.
+
+## Validacao local
+
+Execute a validacao geral:
+
+```powershell
+python scripts/health_check.py
+```
+
+Execute a bateria estrutural extra:
+
+```powershell
+python scripts/framework_tests.py
+```
+
+Meca custo aproximado de leitura por rota:
+
+```powershell
+python scripts/token_report.py
+```
+
+## Instalacao em outro projeto
+
+Projeto novo:
+
+```powershell
+ai-protocol init .
+```
+
+Projeto existente:
+
+```powershell
+ai-protocol install .
+```
+
+Previa sem alterar arquivos:
+
+```powershell
+ai-protocol install . --dry-run
+```
+
+Instalacao local via PowerShell:
+
+```powershell
+.\install.ps1 C:\caminho\projeto -Force
+```
+
+Instalacao local via npm:
+
+```powershell
+npm run install-protocol -- C:\caminho\projeto
+npm run dry-run-protocol -- C:\caminho\projeto
+```
+
+Instalacao local via Python:
+
+```powershell
+python scripts/install_protocol.py --target C:\caminho\projeto --force
+python scripts/verify_install.py --target C:\caminho\projeto
+```
+
+O final esperado da verificacao e `PASS`.
+
+## Publicacao
+
+Antes de publicar, revise `docs/14-publicacao.md`.
+
+Resumo minimo:
+
+- nao publique `.env`, chaves, tokens, senhas, logs reais ou dados de cliente;
+- mantenha artefatos gerados fora do Git quando nao forem necessarios;
+- use `.gitignore`;
+- publique com `README.md`, `LICENSE`, `docs/`, `protocol/`, `cases/`,
+  `examples/`, `schema/`, `eval/` e `scripts/` quando fizer sentido;
+- preserve o posicionamento como pesquisa experimental e framework em evolucao.
+
+## Licenca
+
+Distribuido sob a licenca MIT. Veja `LICENSE`.

ai_execution_protocol-0.1.0/ai_execution_protocol/__init__.py

@@ -0,0 +1,3 @@
+"""AI Execution Protocol installer package."""
+
+__version__ = "0.1.0"

ai_execution_protocol-0.1.0/ai_execution_protocol/__main__.py

@@ -0,0 +1,5 @@
+from .cli import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

ai_execution_protocol-0.1.0/ai_execution_protocol/cli.py

@@ -0,0 +1,283 @@
+#!/usr/bin/env python3
+"""CLI for installing the minimal AI protocol into a project."""
+
+from __future__ import annotations
+
+import argparse
+import shutil
+from datetime import datetime
+from importlib import resources
+from pathlib import Path
+
+
+MARKER_START = "<!-- AI_PROTOCOL_BEGIN -->"
+MARKER_END = "<!-- AI_PROTOCOL_END -->"
+AIIGNORE_LINES = [
+    "results/",
+    "benchmarks/generated/",
+    "model-runs/generated/",
+    "dist/",
+    "scripts/__pycache__/",
+    "*.pyc",
+]
+REQUIRED_PROTOCOL_FILES = [
+    "README.yaml",
+    "fast-path.yaml",
+    "router.yaml",
+    "modes.yaml",
+    "execution-rules.yaml",
+    "risk-levels.yaml",
+    "mapping-checklists.yaml",
+    "validation-checklist.yaml",
+    "context-rules.yaml",
+    "context-compiler.yaml",
+    "formatting-rules.yaml",
+    "prompt-economy.yaml",
+    "spec-driven.yaml",
+]
+REQUIRED_FILES = [
+    "AGENTS.md",
+    ".aiignore",
+    *[f"protocol/{name}" for name in REQUIRED_PROTOCOL_FILES],
+]
+REQUIRED_TEXT = {
+    "AGENTS.md": [
+        "AI_PROTOCOL_BEGIN",
+        "protocol/fast-path.yaml",
+        "protocol/router.yaml",
+        "Classifique o risco antes de agir",
+        "Nenhum arquivo deve passar de 400 linhas.",
+    ],
+    ".aiignore": [
+        "results/",
+        "dist/",
+        "*.pyc",
+    ],
+    "protocol/router.yaml": [
+        "feature_or_spec",
+        "spec-driven.yaml",
+        "prompt_improvement",
+    ],
+    "protocol/spec-driven.yaml": [
+        "protocol_is_base_spec_is_tool",
+        "do_not_create_spec_for_low_value_tasks",
+    ],
+}
+
+
+def protocol_source() -> resources.abc.Traversable:
+    return resources.files("ai_execution_protocol").joinpath("protocol")
+
+
+def minimal_agents() -> str:
+    return """# AGENTS.md
+
+## Regra principal
+
+<!-- AI_PROTOCOL_BEGIN -->
+
+Use `protocol/fast-path.yaml` como entrada operacional minima.
+
+Siga `.aiignore` antes de abrir relatorios gerados.
+
+Este protocolo e obrigatorio para tarefas tecnicas neste projeto. Antes de
+editar, classifique risco, escolha rota e valide a entrega.
+
+## Ordem de leitura
+
+1. `protocol/fast-path.yaml`
+2. `protocol/router.yaml`
+3. Arquivo YAML especifico em `protocol/` conforme a rota.
+
+## Regras de execucao
+
+- Classifique o risco antes de agir.
+- Use o menor contexto suficiente.
+- Leia apenas os arquivos indicados por `protocol/router.yaml`.
+- Quando houver contexto grande, historico longo ou risco de confusao, use
+  `protocol/context-compiler.yaml` antes de abrir muitos arquivos.
+- Use `protocol/spec-driven.yaml` para feature, refatoracao grande ou tarefa
+  critica, sem criar spec pesada para tarefa simples.
+- Sempre entregue `Prompt original` e `Prompt melhorado da IA`; em baixo risco,
+  prefira micro formato legivel com `PO`, `PM` e `OK`.
+- Nao edite arquivo que nao foi identificado como candidato.
+- Preserve documentos, regras de IDE e configuracoes de framework existentes,
+  salvo pedido explicito do usuario.
+- Se o risco subir, atualize a classificacao antes de continuar.
+- Para nivel critico, peca confirmacao antes de acao sensivel.
+- Quando houver risco de quebrar fluxo existente, entregue uma lista do que
+  testar.
+- Entregue com evidencia em poucas linhas: mudanca, validacao, limite e risco
+  residual.
+- Explique o resultado em linguagem clara para uma pessoa leiga entender.
+
+## Convivencia com arquivos existentes
+
+Quando houver conflito, siga esta prioridade:
+
+1. pedido atual do usuario;
+2. este bloco obrigatorio em `AGENTS.md`;
+3. regras especificas da IDE ou do projeto;
+4. docs e historico somente quando a rota pedir.
+
+Nao sobrescreva `README.md`, `docs/`, `.cursorrules`, `CLAUDE.md`,
+`.github/copilot-instructions.md` ou configs de framework sem pedido claro.
+
+## Regras de organizacao
+
+- Nenhum arquivo deve passar de 400 linhas.
+- Organize primeiro para legibilidade por IA.
+- Use YAML para regras operacionais.
+- Evite duplicar a mesma regra em muitos lugares.
+
+<!-- AI_PROTOCOL_END -->
+"""
+
+
+def protocol_block() -> str:
+    text = minimal_agents()
+    start = text.index(MARKER_START)
+    end = text.index(MARKER_END) + len(MARKER_END)
+    return text[start:end]
+
+
+def backup_path(path: Path, backup_root: Path) -> None:
+    if not path.exists():
+        return
+    backup_root.mkdir(parents=True, exist_ok=True)
+    destination = backup_root / path.name
+    if path.is_dir():
+        shutil.copytree(path, destination)
+    else:
+        shutil.copy2(path, destination)
+
+
+def copy_protocol(target: Path, force: bool, backup_root: Path) -> None:
+    if target.exists() and not force:
+        return
+    if target.exists():
+        backup_path(target, backup_root)
+        shutil.rmtree(target)
+    target.mkdir(parents=True, exist_ok=True)
+    source = protocol_source()
+    for name in REQUIRED_PROTOCOL_FILES:
+        (target / name).write_text(source.joinpath(name).read_text(encoding="utf-8"), encoding="utf-8")
+
+
+def install_agents(target: Path) -> None:
+    block = protocol_block()
+    if not target.exists():
+        target.write_text(minimal_agents(), encoding="utf-8")
+        return
+
+    text = target.read_text(encoding="utf-8")
+    if MARKER_START in text and MARKER_END in text:
+        before, rest = text.split(MARKER_START, 1)
+        _, after = rest.split(MARKER_END, 1)
+        merged = before.rstrip() + "\n\n" + block + after
+    else:
+        merged = block + "\n\n## Instrucoes existentes do projeto\n\n" + text
+    target.write_text(merged.strip() + "\n", encoding="utf-8")
+
+
+def install_aiignore(target: Path) -> None:
+    existing = target.read_text(encoding="utf-8").splitlines() if target.exists() else []
+    lines = list(existing)
+    for item in AIIGNORE_LINES:
+        if item not in lines:
+            lines.append(item)
+    target.write_text("\n".join(lines).strip() + "\n", encoding="utf-8")
+
+
+def print_dry_run(target_root: Path, force: bool) -> None:
+    print(f"DRY-RUN target -> {target_root.resolve()}")
+    print(("update" if (target_root / "AGENTS.md").exists() else "create") + ":AGENTS.md")
+    print(("update" if (target_root / ".aiignore").exists() else "create") + ":.aiignore")
+    protocol_dir = target_root / "protocol"
+    if protocol_dir.exists() and force:
+        print("backup:protocol/")
+        print("replace:protocol/")
+    elif protocol_dir.exists():
+        print("keep:protocol/")
+    else:
+        print("create:protocol/")
+
+
+def install(target: str, force: bool, dry_run: bool = False) -> int:
+    target_root = Path(target).resolve()
+    if dry_run:
+        print_dry_run(target_root, force)
+        return 0
+
+    target_root.mkdir(parents=True, exist_ok=True)
+    backup_root = target_root / ".ai-protocol-backup" / datetime.now().strftime("%Y%m%d%H%M%S")
+
+    if (target_root / "AGENTS.md").exists():
+        backup_path(target_root / "AGENTS.md", backup_root)
+    if (target_root / ".aiignore").exists():
+        backup_path(target_root / ".aiignore", backup_root)
+
+    install_agents(target_root / "AGENTS.md")
+    install_aiignore(target_root / ".aiignore")
+    copy_protocol(target_root / "protocol", force, backup_root)
+
+    print(f"installed protocol -> {target_root}")
+    return verify(target)
+
+
+def verify(target: str) -> int:
+    root = Path(target).resolve()
+    errors: list[str] = []
+
+    for item in REQUIRED_FILES:
+        path = root / item
+        if not path.exists():
+            errors.append(f"missing:{item}")
+            continue
+        if path.is_file() and len(path.read_text(encoding="utf-8").splitlines()) > 400:
+            errors.append(f"line_limit:{item}")
+
+    for item, snippets in REQUIRED_TEXT.items():
+        path = root / item
+        if not path.exists() or not path.is_file():
+            continue
+        text = path.read_text(encoding="utf-8")
+        for snippet in snippets:
+            if snippet not in text:
+                errors.append(f"missing_text:{item}:{snippet}")
+
+    if errors:
+        print("FAIL")
+        for error in errors:
+            print(error)
+        return 1
+
+    print("PASS")
+    return 0
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(prog="ai-protocol")
+    subparsers = parser.add_subparsers(dest="command")
+
+    install_parser = subparsers.add_parser("install", help="Install protocol into a project")
+    install_parser.add_argument("target", nargs="?", default=".", help="Project root")
+    install_parser.add_argument("--no-force", action="store_true", help="Do not replace existing protocol folder")
+    install_parser.add_argument("--dry-run", action="store_true", help="Show planned changes without writing files")
+
+    init_parser = subparsers.add_parser("init", help="Initialize protocol in a new project")
+    init_parser.add_argument("target", nargs="?", default=".", help="Project root")
+    init_parser.add_argument("--no-force", action="store_true", help="Do not replace existing protocol folder")
+    init_parser.add_argument("--dry-run", action="store_true", help="Show planned changes without writing files")
+
+    verify_parser = subparsers.add_parser("verify", help="Verify protocol installation")
+    verify_parser.add_argument("target", nargs="?", default=".", help="Project root")
+
+    args = parser.parse_args()
+    if args.command in {"install", "init"}:
+        return install(args.target, force=not args.no_force, dry_run=args.dry_run)
+    if args.command == "verify":
+        return verify(args.target)
+
+    parser.print_help()
+    return 1

ai_execution_protocol-0.1.0/ai_execution_protocol/protocol/README.yaml

@@ -0,0 +1,35 @@
+id: protocol_index
+type: index
+format: yaml
+protocol_version: 0.1.0
+purpose: ai_operational_rules
+source_docs: ../docs
+constraints:
+  max_lines_per_file: 400
+  ai_first_readability: true
+  compact_rules: true
+files:
+  - path: fast-path.yaml
+    purpose: minimum_rules_to_start_any_task
+  - path: router.yaml
+    purpose: choose_minimum_files_to_read_by_task
+  - path: modes.yaml
+    purpose: choose_fast_balanced_or_strict_behavior
+  - path: execution-rules.yaml
+    purpose: execution_flow_and_core_behavior
+  - path: risk-levels.yaml
+    purpose: risk_classification_and_confirmation
+  - path: mapping-checklists.yaml
+    purpose: pre_change_maps_by_risk
+  - path: validation-checklist.yaml
+    purpose: validation_and_final_delivery
+  - path: context-rules.yaml
+    purpose: context_window_file_size_memory
+  - path: context-compiler.yaml
+    purpose: compile_minimum_context_package_and_canonical_state
+  - path: formatting-rules.yaml
+    purpose: ai_readable_file_format
+  - path: prompt-economy.yaml
+    purpose: improve_prompts_without_token_bloat
+  - path: spec-driven.yaml
+    purpose: use_light_or_full_specs_only_when_they_reduce_risk