{
  "content": {
    "icon": "bi-code-square",
    "id": "pag-keywords-action",
    "intro": "Every PAG keyword record, with what grounds it and how it is checked.",
    "subsections": [
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Input acquisition · lowers to READ_RESOURCE",
                "term": "Meaning"
              },
              {
                "description": "READ file INTO data",
                "term": "Example"
              },
              {
                "description": "[mode:observation](/records/reasoning/mode-observation)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-read",
        "title": "READ"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Output generation · lowers to PERSIST_ARTIFACT",
                "term": "Meaning"
              },
              {
                "description": "WRITE content TO file",
                "term": "Example"
              },
              {
                "description": "[axis:formalization](/records/reasoning/axis-formalization)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-write",
        "title": "WRITE"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Action invocation · lowers to EXECUTE_TOOL",
                "term": "Meaning"
              },
              {
                "description": "EXECUTE command WITH params",
                "term": "Example"
              },
              {
                "description": "[axis:formalization](/records/reasoning/axis-formalization)",
                "term": "Grounds"
              },
              {
                "description": "[EXECUTES](/records/pag/keyword-executes): EXECUTE is an action a step invokes, while EXECUTES is the verb a document header uses to state what the document does.",
                "term": "Distinct from"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-execute",
        "title": "EXECUTE"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Construction · lowers to COMPOSE_ARTIFACT",
                "term": "Meaning"
              },
              {
                "description": "CREATE artifact FROM template",
                "term": "Example"
              },
              {
                "description": "[mode:construction](/records/reasoning/mode-construction)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-create",
        "title": "CREATE"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Removal · an irreversible write, refused before it lands",
                "term": "Meaning"
              },
              {
                "description": "DELETE file_path",
                "term": "Example"
              },
              {
                "description": "[node:ver-refusal](/records/reasoning/node-ver-refusal)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-delete",
        "title": "DELETE"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Discovery · lowers to DISCOVER_RESOURCES",
                "term": "Meaning"
              },
              {
                "description": "FIND pattern IN scope",
                "term": "Example"
              },
              {
                "description": "[mode:observation](/records/reasoning/mode-observation)",
                "term": "Grounds"
              },
              {
                "description": "[FINDS](/records/pag/keyword-finds): FIND is an action a step invokes, while FINDS is the verb a document header uses to state what the document does.",
                "term": "Distinct from"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-find",
        "title": "FIND"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Inspection · lowers to ANALYZE_CONTENT",
                "term": "Meaning"
              },
              {
                "description": "ANALYZE target FOR condition",
                "term": "Example"
              },
              {
                "description": "[mode:observation](/records/reasoning/mode-observation)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-analyze",
        "title": "ANALYZE"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Verification · lowers to VALIDATE_ARTIFACT",
                "term": "Meaning"
              },
              {
                "description": "VALIDATE state AGAINST schema",
                "term": "Example"
              },
              {
                "description": "[node:ver-evidence](/records/reasoning/node-ver-evidence)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-validate",
        "title": "VALIDATE"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Confirmation against evidence",
                "term": "Meaning"
              },
              {
                "description": "VERIFY condition",
                "term": "Example"
              },
              {
                "description": "[node:ver-evidence](/records/reasoning/node-ver-evidence)",
                "term": "Grounds"
              },
              {
                "description": "[VERIFIES](/records/pag/keyword-verifies): VERIFY is an action a step invokes, while VERIFIES is the verb a document header uses to state what the document does.",
                "term": "Distinct from"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-verify",
        "title": "VERIFY"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Isolation · lowers to EXTRACT_FACTS",
                "term": "Meaning"
              },
              {
                "description": "EXTRACT data FROM source",
                "term": "Example"
              },
              {
                "description": "[mode:abstraction](/records/reasoning/mode-abstraction)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-extract",
        "title": "EXTRACT"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Aggregation",
                "term": "Meaning"
              },
              {
                "description": "COLLECT items INTO container",
                "term": "Example"
              },
              {
                "description": "[mode:abstraction](/records/reasoning/mode-abstraction)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-collect",
        "title": "COLLECT"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Selection",
                "term": "Meaning"
              },
              {
                "description": "FILTER items WHERE condition",
                "term": "Example"
              },
              {
                "description": "[mode:classification](/records/reasoning/mode-classification)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-filter",
        "title": "FILTER"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Comparison",
                "term": "Meaning"
              },
              {
                "description": "COMPARE a AGAINST b",
                "term": "Example"
              },
              {
                "description": "[mode:comparison](/records/reasoning/mode-comparison)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-compare",
        "title": "COMPARE"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Transformation · a lowering that names what it preserves",
                "term": "Meaning"
              },
              {
                "description": "CONVERT data TO format",
                "term": "Example"
              },
              {
                "description": "[invariant:epi-preserved-distinction](/records/reasoning/invariant-epi-preserved-distinction)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-convert",
        "title": "CONVERT"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Combination",
                "term": "Meaning"
              },
              {
                "description": "MERGE sources INTO target",
                "term": "Example"
              },
              {
                "description": "[mode:abstraction](/records/reasoning/mode-abstraction)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-merge",
        "title": "MERGE"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Division",
                "term": "Meaning"
              },
              {
                "description": "SPLIT data BY delimiter",
                "term": "Example"
              },
              {
                "description": "[substrate-node:difference](/records/reasoning/substrate-node-difference)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-split",
        "title": "SPLIT"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Ordering",
                "term": "Meaning"
              },
              {
                "description": "SORT items BY criteria",
                "term": "Example"
              },
              {
                "description": "[lens:sequential](/records/reasoning/lens-sequential)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-sort",
        "title": "SORT"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Prioritization · the ranking a worth gate reads",
                "term": "Meaning"
              },
              {
                "description": "RANK items BY score",
                "term": "Example"
              },
              {
                "description": "[node:tel-priority](/records/reasoning/node-tel-priority)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-rank",
        "title": "RANK"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Association · a declared edge, never a name match",
                "term": "Meaning"
              },
              {
                "description": "LINK source TO target",
                "term": "Example"
              },
              {
                "description": "[lens:relation](/records/reasoning/lens-relation), [invariant:epi-declared-dependency](/records/reasoning/invariant-epi-declared-dependency)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-link",
        "title": "LINK"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Output · lowers to REPORT_RESULT",
                "term": "Meaning"
              },
              {
                "description": "REPORT findings",
                "term": "Example"
              },
              {
                "description": "[node:ver-evidence](/records/reasoning/node-ver-evidence)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-report",
        "title": "REPORT"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Add to collection",
                "term": "Meaning"
              },
              {
                "description": "ADD item TO list",
                "term": "Example"
              },
              {
                "description": "[substrate-node:existence](/records/reasoning/substrate-node-existence)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-add",
        "title": "ADD"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Append to end",
                "term": "Meaning"
              },
              {
                "description": "APPEND value TO array",
                "term": "Example"
              },
              {
                "description": "[substrate-node:existence](/records/reasoning/substrate-node-existence)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-append",
        "title": "APPEND"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Insert at position",
                "term": "Meaning"
              },
              {
                "description": "INSERT item AT index",
                "term": "Example"
              },
              {
                "description": "[substrate-node:structure](/records/reasoning/substrate-node-structure)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-insert",
        "title": "INSERT"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Remove from collection",
                "term": "Meaning"
              },
              {
                "description": "REMOVE item FROM list",
                "term": "Example"
              },
              {
                "description": "[substrate-node:difference](/records/reasoning/substrate-node-difference)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-remove",
        "title": "REMOVE"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Relocation · a create at the destination, read before it lands",
                "term": "Meaning"
              },
              {
                "description": "MOVE file TO destination",
                "term": "Example"
              },
              {
                "description": "[node:ver-refusal](/records/reasoning/node-ver-refusal)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-move",
        "title": "MOVE"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Duplication · a second derivation of one fact, declared as such",
                "term": "Meaning"
              },
              {
                "description": "COPY file TO backup",
                "term": "Example"
              },
              {
                "description": "[invariant:epi-one-derivation](/records/reasoning/invariant-epi-one-derivation)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-copy",
        "title": "COPY"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Preservation of the last accepted state before a mutation",
                "term": "Meaning"
              },
              {
                "description": "BACKUP file TO location",
                "term": "Example"
              },
              {
                "description": "[node:ter-promotion](/records/reasoning/node-ter-promotion)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-backup",
        "title": "BACKUP"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Recovery of the last accepted state",
                "term": "Meaning"
              },
              {
                "description": "RESTORE FROM backup",
                "term": "Example"
              },
              {
                "description": "[node:ter-promotion](/records/reasoning/node-ter-promotion)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-restore",
        "title": "RESTORE"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Resource acquisition · lowers to READ_RESOURCE",
                "term": "Meaning"
              },
              {
                "description": "LOAD config FROM file",
                "term": "Example"
              },
              {
                "description": "[mode:observation](/records/reasoning/mode-observation)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-load",
        "title": "LOAD"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Communication · lowers to REPORT_RESULT",
                "term": "Meaning"
              },
              {
                "description": "SEND message TO recipient",
                "term": "Example"
              },
              {
                "description": "[axis:formalization](/records/reasoning/axis-formalization)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-send",
        "title": "SEND"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "action",
                "term": "Category"
              },
              {
                "description": "Timing control · waiting has a command",
                "term": "Meaning"
              },
              {
                "description": "WAIT FOR condition",
                "term": "Example"
              },
              {
                "description": "[node:ter-block](/records/reasoning/node-ter-block)",
                "term": "Grounds"
              },
              {
                "description": "coordination",
                "term": "Category"
              },
              {
                "description": "Post and wait as one operation · reports the diff since this reader last looked",
                "term": "Meaning"
              },
              {
                "description": "WAIT ON <surface> AS <reader> INTO <diff>",
                "term": "Example"
              },
              {
                "description": "[node:ter-block](/records/reasoning/node-ter-block)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-wait",
        "title": "WAIT"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Trial operation",
                "term": "Meaning"
              },
              {
                "description": "ATTEMPT operation",
                "term": "Example"
              },
              {
                "description": "[mode:intervention](/records/reasoning/mode-intervention)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-attempt",
        "title": "ATTEMPT"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Error termination · loud at the boundary",
                "term": "Meaning"
              },
              {
                "description": "FAIL WITH message",
                "term": "Example"
              },
              {
                "description": "[node:ver-refusal](/records/reasoning/node-ver-refusal)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-fail",
        "title": "FAIL"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "action",
                "term": "Category"
              },
              {
                "description": "Exit execution",
                "term": "Meaning"
              },
              {
                "description": "EXIT 1",
                "term": "Example"
              },
              {
                "description": "[node:ter-stop](/records/reasoning/node-ter-stop)",
                "term": "Grounds"
              },
              {
                "description": "state_machine",
                "term": "Category"
              },
              {
                "description": "Exit action",
                "term": "Meaning"
              },
              {
                "description": "EXIT: cleanup",
                "term": "Example"
              },
              {
                "description": "[representation:dynamical-systems](/records/reasoning/representation-dynamical-systems)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-exit",
        "title": "EXIT"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Return value · how a bounded reader ends",
                "term": "Meaning"
              },
              {
                "description": "RETURN result",
                "term": "Example"
              },
              {
                "description": "[node:ter-completion](/records/reasoning/node-ter-completion)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-return",
        "title": "RETURN"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Repetition",
                "term": "Meaning"
              },
              {
                "description": "ITERATE operation",
                "term": "Example"
              },
              {
                "description": "[representation:computation](/records/reasoning/representation-computation)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-iterate",
        "title": "ITERATE"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Deep analysis",
                "term": "Meaning"
              },
              {
                "description": "INVESTIGATE issue",
                "term": "Example"
              },
              {
                "description": "[mode:observation](/records/reasoning/mode-observation)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-investigate",
        "title": "INVESTIGATE"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Decision making",
                "term": "Meaning"
              },
              {
                "description": "DETERMINE outcome",
                "term": "Example"
              },
              {
                "description": "[mode:classification](/records/reasoning/mode-classification)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-determine",
        "title": "DETERMINE"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Constraint application",
                "term": "Meaning"
              },
              {
                "description": "ENFORCE rule",
                "term": "Example"
              },
              {
                "description": "[substrate-node:constraint](/records/reasoning/substrate-node-constraint)",
                "term": "Grounds"
              },
              {
                "description": "[ENFORCES](/records/pag/keyword-enforces): ENFORCE is an action a step invokes, while ENFORCES is the verb a document header uses to state what the document does.",
                "term": "Distinct from"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-enforce",
        "title": "ENFORCE"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Proof provision",
                "term": "Meaning"
              },
              {
                "description": "EVIDENCE claim",
                "term": "Example"
              },
              {
                "description": "[node:ver-evidence](/records/reasoning/node-ver-evidence)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-evidence",
        "title": "EVIDENCE"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Change distribution · the ripple through declared dependencies",
                "term": "Meaning"
              },
              {
                "description": "PROPAGATE updates",
                "term": "Example"
              },
              {
                "description": "[invariant:epi-declared-dependency](/records/reasoning/invariant-epi-declared-dependency)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-propagate",
        "title": "PROPAGATE"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Completion",
                "term": "Meaning"
              },
              {
                "description": "FINALIZE operation",
                "term": "Example"
              },
              {
                "description": "[node:ter-completion](/records/reasoning/node-ter-completion)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-finalize",
        "title": "FINALIZE"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Aggregation · a fusion that drops nothing live",
                "term": "Meaning"
              },
              {
                "description": "REDUCE items TO value",
                "term": "Example"
              },
              {
                "description": "[mode:abstraction](/records/reasoning/mode-abstraction)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-reduce",
        "title": "REDUCE"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Name modification · every referencing surface enumerated first",
                "term": "Meaning"
              },
              {
                "description": "RENAME file TO newname",
                "term": "Example"
              },
              {
                "description": "[invariant:epi-declared-dependency](/records/reasoning/invariant-epi-declared-dependency)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-rename",
        "title": "RENAME"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Arrangement",
                "term": "Meaning"
              },
              {
                "description": "ORDER items BY key",
                "term": "Example"
              },
              {
                "description": "[lens:sequential](/records/reasoning/lens-sequential)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-order",
        "title": "ORDER"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Annotation",
                "term": "Meaning"
              },
              {
                "description": "MARK item AS complete",
                "term": "Example"
              },
              {
                "description": "[axis:representation](/records/reasoning/axis-representation)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-mark",
        "title": "MARK"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Infer a future state",
                "term": "Meaning"
              },
              {
                "description": "PREDICT outcome FROM model",
                "term": "Example"
              },
              {
                "description": "[mode:prediction](/records/reasoning/mode-prediction)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-predict",
        "title": "PREDICT"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Group by kind",
                "term": "Meaning"
              },
              {
                "description": "CLASSIFY item BY type",
                "term": "Example"
              },
              {
                "description": "[mode:classification](/records/reasoning/mode-classification)",
                "term": "Grounds"
              },
              {
                "description": "[CLASSIFIES](/records/pag/keyword-classifies): CLASSIFY is an action a step invokes, while CLASSIFIES is the verb a document header uses to state what the document does.",
                "term": "Distinct from"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-classify",
        "title": "CLASSIFY"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Identify the mechanism",
                "term": "Meaning"
              },
              {
                "description": "EXPLAIN behavior",
                "term": "Example"
              },
              {
                "description": "[mode:explanation](/records/reasoning/mode-explanation)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-explain",
        "title": "EXPLAIN"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Discover the principle behind the examples",
                "term": "Meaning"
              },
              {
                "description": "REFLECT ON outcome",
                "term": "Example"
              },
              {
                "description": "[mode:reflection](/records/reasoning/mode-reflection)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-reflect",
        "title": "REFLECT"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Remove irrelevant detail",
                "term": "Meaning"
              },
              {
                "description": "ABSTRACT pattern FROM cases",
                "term": "Example"
              },
              {
                "description": "[mode:abstraction](/records/reasoning/mode-abstraction)",
                "term": "Grounds"
              },
              {
                "description": "[ABSTRACTS](/records/pag/keyword-abstracts): ABSTRACT is an action a step invokes, while ABSTRACTS is the verb a document header uses to state what the document does.",
                "term": "Distinct from"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-abstract",
        "title": "ABSTRACT"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Extend examples into a principle",
                "term": "Meaning"
              },
              {
                "description": "GENERALIZE FROM examples",
                "term": "Example"
              },
              {
                "description": "[mode:generalization](/records/reasoning/mode-generalization)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-generalize",
        "title": "GENERALIZE"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Characterize an object",
                "term": "Meaning"
              },
              {
                "description": "DESCRIBE structure",
                "term": "Example"
              },
              {
                "description": "[mode:description](/records/reasoning/mode-description)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-describe",
        "title": "DESCRIBE"
      },
      {
        "blocks": [
          {
            "entries": [
              {
                "description": "Express symbolically",
                "term": "Meaning"
              },
              {
                "description": "FORMALIZE rule AS predicate",
                "term": "Example"
              },
              {
                "description": "[mode:formalization](/records/reasoning/mode-formalization)",
                "term": "Grounds"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape",
                "term": "Checked by"
              },
              {
                "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the grammar data or a document that uses the keyword changes",
                "term": "Freshness"
              },
              {
                "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship",
                "term": "Refusal"
              },
              {
                "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean",
                "term": "Evidence"
              },
              {
                "description": "The grammar data, which every keyword in a document conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "pag-keyword-formalize",
        "title": "FORMALIZE"
      }
    ],
    "title": "action",
    "kind": "keywords"
  },
  "graph": {
    "narrative": true,
    "requires": [],
    "teaches": [],
    "traces": []
  },
  "href": "https://banes-lab.com/ontology/grammar#pag-keywords-action",
  "number": "216",
  "page": "ontology",
  "ref": "chapter:/ontology/grammar#pag-keywords-action",
  "relations": [
    {
      "links": [
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-mode-observation",
          "json": "https://banes-lab.com/json/records/reasoning/mode-observation",
          "label": "Observation",
          "markdown": "https://banes-lab.com/records/reasoning/mode-observation.md",
          "ref": "reasoning:mode-observation"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-axis-formalization",
          "json": "https://banes-lab.com/json/records/reasoning/axis-formalization",
          "label": "Formalization",
          "markdown": "https://banes-lab.com/records/reasoning/axis-formalization.md",
          "ref": "reasoning:axis-formalization"
        },
        {
          "href": "https://banes-lab.com/ontology/grammar#pag-keyword-executes",
          "json": "https://banes-lab.com/json/records/pag/keyword-executes",
          "label": "EXECUTES",
          "markdown": "https://banes-lab.com/records/pag/keyword-executes.md",
          "ref": "pag:keyword-executes"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-mode-construction",
          "json": "https://banes-lab.com/json/records/reasoning/mode-construction",
          "label": "Construction",
          "markdown": "https://banes-lab.com/records/reasoning/mode-construction.md",
          "ref": "reasoning:mode-construction"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-node-ver-refusal",
          "json": "https://banes-lab.com/json/records/reasoning/node-ver-refusal",
          "label": "Refusal",
          "markdown": "https://banes-lab.com/records/reasoning/node-ver-refusal.md",
          "ref": "reasoning:node-ver-refusal"
        },
        {
          "href": "https://banes-lab.com/ontology/grammar#pag-keyword-finds",
          "json": "https://banes-lab.com/json/records/pag/keyword-finds",
          "label": "FINDS",
          "markdown": "https://banes-lab.com/records/pag/keyword-finds.md",
          "ref": "pag:keyword-finds"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-node-ver-evidence",
          "json": "https://banes-lab.com/json/records/reasoning/node-ver-evidence",
          "label": "Evidence",
          "markdown": "https://banes-lab.com/records/reasoning/node-ver-evidence.md",
          "ref": "reasoning:node-ver-evidence"
        },
        {
          "href": "https://banes-lab.com/ontology/grammar#pag-keyword-verifies",
          "json": "https://banes-lab.com/json/records/pag/keyword-verifies",
          "label": "VERIFIES",
          "markdown": "https://banes-lab.com/records/pag/keyword-verifies.md",
          "ref": "pag:keyword-verifies"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-mode-abstraction",
          "json": "https://banes-lab.com/json/records/reasoning/mode-abstraction",
          "label": "Abstraction",
          "markdown": "https://banes-lab.com/records/reasoning/mode-abstraction.md",
          "ref": "reasoning:mode-abstraction"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-mode-classification",
          "json": "https://banes-lab.com/json/records/reasoning/mode-classification",
          "label": "Classification",
          "markdown": "https://banes-lab.com/records/reasoning/mode-classification.md",
          "ref": "reasoning:mode-classification"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-mode-comparison",
          "json": "https://banes-lab.com/json/records/reasoning/mode-comparison",
          "label": "Comparison",
          "markdown": "https://banes-lab.com/records/reasoning/mode-comparison.md",
          "ref": "reasoning:mode-comparison"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-invariant-epi-preserved-distinction",
          "json": "https://banes-lab.com/json/records/reasoning/invariant-epi-preserved-distinction",
          "label": "Preserved Distinction",
          "markdown": "https://banes-lab.com/records/reasoning/invariant-epi-preserved-distinction.md",
          "ref": "reasoning:invariant-epi-preserved-distinction"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-substrate-node-difference",
          "json": "https://banes-lab.com/json/records/reasoning/substrate-node-difference",
          "label": "Difference",
          "markdown": "https://banes-lab.com/records/reasoning/substrate-node-difference.md",
          "ref": "reasoning:substrate-node-difference"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-lens-sequential",
          "json": "https://banes-lab.com/json/records/reasoning/lens-sequential",
          "label": "Sequential",
          "markdown": "https://banes-lab.com/records/reasoning/lens-sequential.md",
          "ref": "reasoning:lens-sequential"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-node-tel-priority",
          "json": "https://banes-lab.com/json/records/reasoning/node-tel-priority",
          "label": "Branch Priority",
          "markdown": "https://banes-lab.com/records/reasoning/node-tel-priority.md",
          "ref": "reasoning:node-tel-priority"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-lens-relation",
          "json": "https://banes-lab.com/json/records/reasoning/lens-relation",
          "label": "Relation",
          "markdown": "https://banes-lab.com/records/reasoning/lens-relation.md",
          "ref": "reasoning:lens-relation"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-invariant-epi-declared-dependency",
          "json": "https://banes-lab.com/json/records/reasoning/invariant-epi-declared-dependency",
          "label": "Declared Dependency",
          "markdown": "https://banes-lab.com/records/reasoning/invariant-epi-declared-dependency.md",
          "ref": "reasoning:invariant-epi-declared-dependency"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-substrate-node-existence",
          "json": "https://banes-lab.com/json/records/reasoning/substrate-node-existence",
          "label": "Existence",
          "markdown": "https://banes-lab.com/records/reasoning/substrate-node-existence.md",
          "ref": "reasoning:substrate-node-existence"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-substrate-node-structure",
          "json": "https://banes-lab.com/json/records/reasoning/substrate-node-structure",
          "label": "Structure",
          "markdown": "https://banes-lab.com/records/reasoning/substrate-node-structure.md",
          "ref": "reasoning:substrate-node-structure"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-invariant-epi-one-derivation",
          "json": "https://banes-lab.com/json/records/reasoning/invariant-epi-one-derivation",
          "label": "One Derivation",
          "markdown": "https://banes-lab.com/records/reasoning/invariant-epi-one-derivation.md",
          "ref": "reasoning:invariant-epi-one-derivation"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-node-ter-promotion",
          "json": "https://banes-lab.com/json/records/reasoning/node-ter-promotion",
          "label": "Promotion",
          "markdown": "https://banes-lab.com/records/reasoning/node-ter-promotion.md",
          "ref": "reasoning:node-ter-promotion"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-node-ter-block",
          "json": "https://banes-lab.com/json/records/reasoning/node-ter-block",
          "label": "Blocked Run",
          "markdown": "https://banes-lab.com/records/reasoning/node-ter-block.md",
          "ref": "reasoning:node-ter-block"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-mode-intervention",
          "json": "https://banes-lab.com/json/records/reasoning/mode-intervention",
          "label": "Intervention",
          "markdown": "https://banes-lab.com/records/reasoning/mode-intervention.md",
          "ref": "reasoning:mode-intervention"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-node-ter-stop",
          "json": "https://banes-lab.com/json/records/reasoning/node-ter-stop",
          "label": "Stop Condition",
          "markdown": "https://banes-lab.com/records/reasoning/node-ter-stop.md",
          "ref": "reasoning:node-ter-stop"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-representation-dynamical-systems",
          "json": "https://banes-lab.com/json/records/reasoning/representation-dynamical-systems",
          "label": "Dynamical Systems",
          "markdown": "https://banes-lab.com/records/reasoning/representation-dynamical-systems.md",
          "ref": "reasoning:representation-dynamical-systems"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-node-ter-completion",
          "json": "https://banes-lab.com/json/records/reasoning/node-ter-completion",
          "label": "Completion",
          "markdown": "https://banes-lab.com/records/reasoning/node-ter-completion.md",
          "ref": "reasoning:node-ter-completion"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-representation-computation",
          "json": "https://banes-lab.com/json/records/reasoning/representation-computation",
          "label": "Computation",
          "markdown": "https://banes-lab.com/records/reasoning/representation-computation.md",
          "ref": "reasoning:representation-computation"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-substrate-node-constraint",
          "json": "https://banes-lab.com/json/records/reasoning/substrate-node-constraint",
          "label": "Constraint",
          "markdown": "https://banes-lab.com/records/reasoning/substrate-node-constraint.md",
          "ref": "reasoning:substrate-node-constraint"
        },
        {
          "href": "https://banes-lab.com/ontology/grammar#pag-keyword-enforces",
          "json": "https://banes-lab.com/json/records/pag/keyword-enforces",
          "label": "ENFORCES",
          "markdown": "https://banes-lab.com/records/pag/keyword-enforces.md",
          "ref": "pag:keyword-enforces"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-axis-representation",
          "json": "https://banes-lab.com/json/records/reasoning/axis-representation",
          "label": "Representation",
          "markdown": "https://banes-lab.com/records/reasoning/axis-representation.md",
          "ref": "reasoning:axis-representation"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-mode-prediction",
          "json": "https://banes-lab.com/json/records/reasoning/mode-prediction",
          "label": "Prediction",
          "markdown": "https://banes-lab.com/records/reasoning/mode-prediction.md",
          "ref": "reasoning:mode-prediction"
        },
        {
          "href": "https://banes-lab.com/ontology/grammar#pag-keyword-classifies",
          "json": "https://banes-lab.com/json/records/pag/keyword-classifies",
          "label": "CLASSIFIES",
          "markdown": "https://banes-lab.com/records/pag/keyword-classifies.md",
          "ref": "pag:keyword-classifies"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-mode-explanation",
          "json": "https://banes-lab.com/json/records/reasoning/mode-explanation",
          "label": "Explanation",
          "markdown": "https://banes-lab.com/records/reasoning/mode-explanation.md",
          "ref": "reasoning:mode-explanation"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-mode-reflection",
          "json": "https://banes-lab.com/json/records/reasoning/mode-reflection",
          "label": "Reflection",
          "markdown": "https://banes-lab.com/records/reasoning/mode-reflection.md",
          "ref": "reasoning:mode-reflection"
        },
        {
          "href": "https://banes-lab.com/ontology/grammar#pag-keyword-abstracts",
          "json": "https://banes-lab.com/json/records/pag/keyword-abstracts",
          "label": "ABSTRACTS",
          "markdown": "https://banes-lab.com/records/pag/keyword-abstracts.md",
          "ref": "pag:keyword-abstracts"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-mode-generalization",
          "json": "https://banes-lab.com/json/records/reasoning/mode-generalization",
          "label": "Generalization",
          "markdown": "https://banes-lab.com/records/reasoning/mode-generalization.md",
          "ref": "reasoning:mode-generalization"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-mode-description",
          "json": "https://banes-lab.com/json/records/reasoning/mode-description",
          "label": "Description",
          "markdown": "https://banes-lab.com/records/reasoning/mode-description.md",
          "ref": "reasoning:mode-description"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-mode-formalization",
          "json": "https://banes-lab.com/json/records/reasoning/mode-formalization",
          "label": "Formalization",
          "markdown": "https://banes-lab.com/records/reasoning/mode-formalization.md",
          "ref": "reasoning:mode-formalization"
        }
      ],
      "relation": "links-to"
    }
  ],
  "route": null,
  "section": "pag-keywords-action",
  "summary": "Every PAG keyword record, with what grounds it and how it is checked.",
  "tab": "grammar",
  "title": "action",
  "siblings": {
    "next": {
      "href": "https://banes-lab.com/ontology/grammar#pag-keywords-control-flow",
      "json": "https://banes-lab.com/json/ontology/grammar/pag-keywords-control-flow",
      "label": "control_flow",
      "markdown": "https://banes-lab.com/ontology/grammar/pag-keywords-control-flow.md",
      "ref": "chapter:/ontology/grammar#pag-keywords-control-flow"
    },
    "previous": null
  },
  "up": {
    "href": "https://banes-lab.com/ontology/grammar",
    "json": "https://banes-lab.com/json/api/pages/ontology/grammar",
    "label": "Ontology · Grammar",
    "markdown": "https://banes-lab.com/api/pages/ontology/grammar.md",
    "ref": "api:/ontology/grammar"
  }
}