Grabadora Asset Core Puerta de Decisión
Docs
Documentos de Decision Gate

Evaluación de puertas determinista, reproducible con decisiones auditables.

Documentación de Asset Core

Contrato de Autoría de LLM

Propósito y Audiencia

Qué: El contrato canónico de un solo documento para la autoría de Decision Gate impulsada por LLM. Por qué: Hacer cumplir verificaciones deterministas respaldadas por evidencia antes de acciones consecuentes. Quién: Equipos que integran agentes LLM con Decision Gate en flujos de trabajo fijos o bucles de autoautoría. Requisitos previos: evidence_flow_and_execution_model.md

Este es el documento principal que se debe entregar a un LLM. Otras guías son opcionales para mayor profundidad. Para un único camino de incorporación humana que cubra la ejecución protegida, la evaluación de DG como habilidad y la composición recursiva, consulte skill_pathways_onboarding.md.

Implementación de Referencia

Para una implementación de reclamación legal concreta de este contrato (operación determinista offline más operación de opt-in en vivo), consulte:

Invariantes No Negociables

  1. Decision Gate es un límite de ejecución, no un análisis asesor.
  2. Las afirmaciones fácticas que están marcadas como requeridas deben resolverse mediante evidencia, no mediante la confianza del modelo.
  3. Las acciones consecuentes deben ser bloqueadas cuando las reclamaciones requeridas no están resueltas.
  4. precheck es solo de iteración; los caminos consecuentes requieren evaluación en vivo.
  5. Las discrepancias de capacidad fallan de manera cerrada.

Secuencia de Herramientas Canónicas

Utiliza esta secuencia para cada flujo de trabajo:

  1. Capability discovery
    • providers_list
    • provider_contract_get
    • provider_check_schema_get
  2. Authoring
    • Extraer reclamaciones
    • Construir claim_inventory
    • Compilar claim_condition_map
  3. Fast loop
    • schemas_register
    • precheck
  4. Consequential boundary
    • scenario_define (si no está ya definido)
    • scenario_start
    • escenario_siguiente
  5. Audit/debug
    • runpack_export y/o evidence_query según lo permita la política

Cruce de Habilidades

Este documento sigue siendo el protocolo normativo. Las habilidades son envolturas operativas para utilizar el protocolo de manera consistente.

Habilidades del repositorio canónico:

  • skills/decision-gate-authoring
  • skills/decision-gate-verification
  • skills/decision-gate-capability-discovery

Paso de peatones:

Sección del playbookHabilidad principalSecuencia de herramientas concreta
Secuencia de herramientas canónicadecision-gate-authoringproviders_list -> provider_contract_get -> provider_check_schema_get -> schemas_register -> precheck -> scenario_define -> scenario_start -> scenario_next
Apretón de manos de descubrimiento de capacidadesdecision-gate-capability-discoveryproviders_list -> provider_contract_get -> provider_check_schema_get
Contrato de descomposición de reclamacionesdecision-gate-authoringextracción de reclamaciones + generación de claim_inventory (respaldado por contrato)
Contrato de compilación de condicionesdecision-gate-authoring + decision-gate-capability-discoveryverificación de esquemas + validación de comparadores/tipos antes de claim_condition_map
Contrato de ejecución + Reglas de parada duradecision-gate-authoring + decision-gate-verificationbucle rápido de precheck, luego scenario_start en vivo + scenario_next, luego runpack_export + runpack_verify
Bloque de aviso de agente canónicolas tres habilidadesinstrucciones de habilidad compactas que preservan este contrato (no una segunda fuente de verdad)

decision_gate_docs_search consultas para apoyar flujos de trabajo de habilidades:

{
  "query": "llm authoring capability discovery handshake providers_list provider_check_schema_get",
  "max_sections": 4
}

{
  "query": "precheck versus live scenario_next hard stop rules enforcement_verdict",
  "max_sections": 4
}

{
  "query": "runpack_export runpack_verify trust lane verified asserted",
  "max_sections": 4
}

Descubrimiento de Capacidades Handshake

El descubrimiento de capacidades es obligatorio antes de la compilación de condiciones en dominios arbitrarios.

1) Listar proveedores

{}

Utilice la carga útil anterior con providers_list.

2) Obtener contrato del proveedor

{
  "provider_id": "json"
}

Utilice la carga útil anterior con provider_contract_get.

3) Obtener detalles del esquema de verificación

{
  "provider_id": "json",
  "check_id": "path"
}

Utilice la carga útil anterior con provider_check_schema_get.

Como mínimo, recopila:

  • allowed_comparators
  • params_schema
  • result_schema

Contrato de Descomposición de Reclamaciones

Cada declaración fáctica de candidato debe estar representada en claim_inventory.

Reglas de clasificación:

  • gatable = true solo cuando la reclamación puede ser verificada de manera determinista contra una fuente de evidencia.
  • gating_required = true para reclamaciones que bloquean acciones consecuentes si no se resuelven.
  • gatable = false requiere un reason no vacío.

Se admiten dos modos de operación:

  • Flujo de trabajo fijo: los humanos predefinen las clases de reclamaciones requeridas (por ejemplo, citas legales).
  • Auto-redacción: el agente extrae reclamaciones en tiempo de ejecución y compila condiciones a partir de capacidades descubiertas.

Se espera que la especificidad del dominio sea: las reclamaciones dependen de las fuentes de datos y el acceso de cada equipo.

Contrato de Compilación de Condiciones

Para cada reclamo gatable = true, compila una o más condiciones utilizando:

  • provider_id
  • check_id
  • params
  • comparador
  • esperado
  • trust_min_lane

Requisitos de compilación:

  1. El comparador debe estar en allowed_comparators de provider_check_schema_get.
  2. params debe conformarse a params_schema.
  3. expected debe ser compatible con result_schema y la semántica del comparador.
  4. Los valores de condition_id deben ser únicos dentro del escenario.

Contrato de Ejecución

Bucle de iteración rápida (afirmado)

  1. Registrar esquema a través de schemas_register.
  2. Ejecutar precheck contra la carga útil afirmada.
  3. Corrija el mapeo de reclamaciones, el esquema o las condiciones hasta que las reclamaciones requeridas se evalúen como estados de aprobación.

Límite consecuente (verificado)

Antes de cualquier acción consecuente:

  1. Asegúrese de que el escenario esté definido (scenario_define).
  2. Crear ejecución (scenario_start).
  3. Ejecutar evaluación en vivo (scenario_next).
  4. Proceda solo si el resultado de la decisión es aprobar/avanzar/completar para su política de límites.

Reglas de Parada Dura (NO SE DEBE CONTINUAR)

No permitir acción consecuente cuando cualquiera de las condiciones a continuación sea verdadera:

  1. Una reclamación gatable requerida no tiene mapeo en claim_condition_map.
  2. Una condición mapeada requerida resuelve false o unknown.
  3. scenario_next no devuelve un resultado de pase permitido para el límite de liberación.
  4. La política requiere verificado pero solo se utiliza evidencia afirmada.
  5. La validación del contrato del proveedor/comprobador/comparador/tipo falla.

Bloque de Aviso del Agente Canónico

Pegue esto en el aviso de su sistema de agente, luego vincule la capa de herramienta a las herramientas DG MCP.

You are the Decision Gate Authoring Agent. Follow this protocol exactly.

Inputs:
- draft_output: candidate output text or structured payload
- consequence_boundary: the action that must be blocked unless gates pass
- policy_defaults:
  - required_risk_levels: ["high", "critical"]
  - required_min_lane: "verified"

Required outputs (all four):
1) claim_inventory
2) capability_matrix
3) claim_condition_map
4) enforcement_verdict

Protocol:
1. Discover provider capabilities using providers_list, provider_contract_get, provider_check_schema_get.
2. Extract factual claims from draft_output.
3. Build claim_inventory:
   - Set gatable=true only for deterministically checkable claims.
   - Set gating_required=true for claims whose failure must block consequence_boundary.
   - Include non-empty reason for every gatable=false claim.
4. Build claim_condition_map for all gatable=true claims.
5. Validate mappings against provider check contracts (comparators, params, value types).
6. Run precheck for fast iteration.
7. Before consequence_boundary, run live scenario_start + scenario_next.
8. Set enforcement_verdict.can_proceed=true only if all required gatable claims are resolved by passing live-evaluated conditions at required trust lane.

Hard-stop behavior:
- If any required gatable claim is unmapped, unknown, false, or lane-invalid, set can_proceed=false and emit explicit blocking_reasons.
- Never treat model confidence or self-verification text as evidence.

Plantillas JSON Integradas

claim_inventory (requerido)

{
  "claim_inventory": [
    {
      "claim_id": "claim_001",
      "claim_text": "Case X exists in court records",
      "gatable": true,
      "gating_required": true,
      "reason": "Deterministic external lookup available",
      "evidence_source_hint": "court_records_api",
      "risk_level": "high"
    }
  ]
}

capability_matrix (requerido)

{
  "capability_matrix": [
    {
      "provider_id": "json",
      "check_id": "path",
      "allowed_comparators": ["equals", "exists", "not_exists", "in_set"],
      "params_schema_ref": "provider_check_schema_get:json:path:params_schema",
      "result_schema_ref": "provider_check_schema_get:json:path:result_schema"
    }
  ]
}

claimconditionmap (requerido)

{
  "claim_condition_map": [
    {
      "claim_id": "claim_001",
      "condition_id": "case_exists",
      "provider_id": "rest",
      "check_id": "json_path",
      "params": {
        "url": "https://api.example.com/cases/lookup?id=925-F3d-1339",
        "jsonpath": "$.exists"
      },
      "comparator": "equals",
      "expected": true,
      "trust_min_lane": "verified"
    }
  ]
}

enforcement_verdict (requerido)

{
  "enforcement_verdict": {
    "can_proceed": false,
    "blocking_reasons": [
      "required claim claim_001 unresolved",
      "live evaluation not complete"
    ],
    "required_claims_unresolved": ["claim_001"]
  }
}

Camino Dorado Mínimo (Un Flujo de Extremo a Extremo)

Este flujo es intencionalmente mínimo y alineado con el comportamiento actual de las herramientas OSS.

Consejo de Windows: PowerShell/CMD no soportan curl en múltiples líneas al estilo bash. Usa un comando de una sola línea o cadenas de PowerShell aquí. Consejo de preajuste: Comienza con configs/presets/quickstart-dev.toml para uso local.

Paso 1: Definir escenario

curl -s http://127.0.0.1:4000/rpc \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/call",
    "params": {
      "name": "scenario_define",
      "arguments": {
        "spec": {
          "scenario_id": "llm-precheck",
          "namespace_id": 1,
          "spec_version": "v1",
          "stages": [
            {
              "stage_id": "main",
              "entry_packets": [],
              "gates": [
                {
                  "gate_id": "quality",
                  "requirement": { "Condition": "report_ok" }
                }
              ],
              "advance_to": { "kind": "terminal" },
              "timeout": null,
              "on_timeout": "fail"
            }
          ],
          "conditions": [
            {
              "condition_id": "report_ok",
              "query": {
                "provider_id": "json",
                "check_id": "path",
                "params": { "file": "report.json", "jsonpath": "$.summary.failed" }
              },
              "comparator": "equals",
              "expected": 0,
              "policy_tags": []
            }
          ],
          "policies": [],
          "schemas": [],
          "default_tenant_id": 1
        }
      }
    }
  }'

Paso 2: Registrar el esquema de prechequeo

curl -s http://127.0.0.1:4000/rpc \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 2,
    "method": "tools/call",
    "params": {
      "name": "schemas_register",
      "arguments": {
        "record": {
          "tenant_id": 1,
          "namespace_id": 1,
          "schema_id": "llm-precheck",
          "version": "v1",
          "schema": {
            "type": "object",
            "additionalProperties": false,
            "properties": {
              "report_ok": { "type": "number" }
            },
            "required": ["report_ok"]
          },
          "description": "LLM precheck payload schema",
          "created_at": { "kind": "logical", "value": 1 },
          "signing": null
        }
      }
    }
  }'

Paso 3: Preverificación (bucle rápido)

curl -s http://127.0.0.1:4000/rpc \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 3,
    "method": "tools/call",
    "params": {
      "name": "precheck",
      "arguments": {
        "tenant_id": 1,
        "namespace_id": 1,
        "scenario_id": "llm-precheck",
        "spec": null,
        "stage_id": "main",
        "data_shape": { "schema_id": "llm-precheck", "version": "v1" },
        "payload": { "report_ok": 0 }
      }
    }
  }'

Forma de respuesta esperada:

{
  "decision": {
    "kind": "complete",
    "stage_id": "main"
  },
  "gate_evaluations": [
    {
      "gate_id": "quality",
      "status": "true",
      "trace": [
        { "condition_id": "report_ok", "status": "true" }
      ]
    }
  ]
}

Paso 4: Límite en vivo (requerido antes de la acción consecuente)

# scenario_start
curl -s http://127.0.0.1:4000/rpc \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 4,
    "method": "tools/call",
    "params": {
      "name": "scenario_start",
      "arguments": {
        "scenario_id": "llm-precheck",
        "run_config": {
          "tenant_id": 1,
          "namespace_id": 1,
          "run_id": "run-1",
          "scenario_id": "llm-precheck",
          "dispatch_targets": [],
          "policy_tags": []
        },
        "started_at": { "kind": "unix_millis", "value": 1710000000000 },
        "issue_entry_packets": false
      }
    }
  }'

# scenario_next
curl -s http://127.0.0.1:4000/rpc \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 5,
    "method": "tools/call",
    "params": {
      "name": "scenario_next",
      "arguments": {
        "scenario_id": "llm-precheck",
        "request": {
          "run_id": "run-1",
          "tenant_id": 1,
          "namespace_id": 1,
          "trigger_id": "trigger-1",
          "agent_id": "agent-1",
          "time": { "kind": "unix_millis", "value": 1710000000000 },
          "correlation_id": null
        },
        "feedback": "trace"
      }
    }
  }'

Proceda solo si la decisión en vivo cumple con su política de aprobación.

Recuperación de Fallos y Escalamiento

Si la validación o evaluación falla:

  1. Capability mismatch
    • Volver a consultar provider_check_schema_get y corregir la discrepancia entre comparador/parámetros/tipo de resultado.
  2. precheck hold or tool error
    • Validar la carga útil contra la forma de los datos; asegurar que los IDs de condición se alineen con las claves de la carga útil.
  3. Live run hold/fail
    • Inspeccionar runpack (runpack_export) o llamar a evidence_query (si la política de divulgación lo permite).
  4. Trust lane mismatch
    • Si la política requiere verificado, no apruebe evidencia solo afirmada.
  5. Unclear claim classification
    • Escalar al propietario de la política humana; por defecto gating_required = true para reclamaciones de alto riesgo.

Profundizaciones específicas del proveedor:

Glosario

Inventario de reclamaciones: Lista legible por máquina de reclamaciones candidatas y clasificación de acceso. Matriz de capacidades: Capacidades de proveedor/verificadas descubiertas a partir de herramientas DG. Mapa de condiciones de reclamación: Mapeo determinista de reclamaciones accesibles a condiciones DG. Preverificación: Simulación de evidencia afirmada, sin mutación del estado de ejecución. Ejecución en vivo: Evaluación obtenida del proveedor que muta el estado de ejecución y apoya la auditoría de ejecución. Acción consecuente: Cualquier acción que cambie el estado externo, libere salida o comprometa una decisión.