{
  "content": {
    "icon": "bi-braces",
    "id": "grammar",
    "label": "Grammar",
    "layout": "grid",
    "sections": [
      {
        "icon": "bi-braces",
        "id": "bnf-grammar",
        "intro": "PAG is defined by a context-free grammar written in Backus–Naur form (BNF), and its rules fall into five categories. The planning and coordination productions are the grammar's own records, each grounded to a reasoning record, and the statement, expression and flowchart rules expand the terminals those records leave open. The scan described in [well-formedness](/pag/guide#well-formedness) reads tokens rather than patterns, although the grammar itself admits a pattern literal in a condition.",
        "subsections": [
          {
            "blocks": [
              {
                "code": "# Instruction\n<instruction> ::= <frontmatter> <optional_meta_block> <optional_document_declaration> <body>\n<frontmatter> ::= \"---\" <yaml_content> \"---\"\n<optional_meta_block> ::= <meta_block> | ε\n<optional_document_declaration> ::= <document_declaration> | ε\n<document_declaration> ::= \"THIS\" <document_type> <document_verb> <description>\n<document_type> ::= \"AGENT\" | \"WORKFLOW\" | \"PROTOCOL\" | \"POLICY\" | \"CHECKLIST\" | \"TEMPLATE\" | \"TASK\" | \"INSTRUCTION\" | \"PROMPT\" | \"COMMAND\" | \"TEST\"\n| \"DEBUG\" | \"VERIFICATION\" | \"DISTILLATION\" | \"AUDIT\" | \"TRANSLATION\" | \"COMPOSITION\"\n<document_verb> ::= \"IS\" | \"ENFORCES\" | \"EXECUTES\" | \"HAS\" | \"PERFORMS\" | \"PROVIDES\" | \"IMPLEMENTS\" | \"DEFINES\" | \"MANAGES\" | \"COORDINATES\" | \"GENERATES\"\n| \"RESOLVES\" | \"FINDS\" | \"FIXES\" | \"VERIFIES\" | \"CLASSIFIES\" | \"DISTILLS\" | \"ABSTRACTS\" | \"ELIMINATES\" | \"AUDITS\" | \"MEASURES\" | \"SCORES\" | \"CORRECTS\" | \"RENDERS\" | \"COMPOSES\" | \"FOLDS\"\n<description> ::= <text>\n<body> ::= <node>+ <repair_edge>* <optional_invariant_block> <optional_report_block>\n<optional_invariant_block> ::= <invariant_block> | ε\n<optional_report_block> ::= <report_block> | ε\n\n# Meta block\n<meta_block> ::= \"%%\" \"META\" \"%%\" \":\" <meta_field>+\n<meta_field> ::= \"objective\" \":\" <string>\n| \"priority\" \":\" <authority_chain>\n| \"trust\" \":\" <trust_assignment> (\",\" <trust_assignment>)*\n| \"jurisdiction\" \":\" <scope> \"|\" \"external\" \":\" <scope>\n| \"recursion_limit\" \":\" <number>\n<authority_chain> ::= <identifier> (\">\" <identifier>)*\n<trust_assignment> ::= <identifier> \"=\" (\"TRUSTED\" | \"UNTRUSTED\" | <identifier>)\n<scope> ::= <text>\n\n# Node\n<node> ::= <node_header> <node_meta_tag>* <contract> <optional_output_contract> <handoff_gate>\n<node_header> ::= \"#\" \"NODE\" <node_number> \"—\" <node_title> \"[\" <layer> \"·\" <axis> \"·\" <math_type> \"·\" \"yields:\" <shape> \"]\"\n<node_number> ::= <digit>+\n<node_title> ::= <text>\n<layer> ::= \"epistemic\" | \"conative\" | \"evaluative\"\n<axis> ::= \"ontology\" | \"teleology\" | \"analysis\" | \"reasoning\" | \"formalization\" | \"verification\" | \"representation\" | \"termination\"\n<math_type> ::= \"set-theory\" | \"logic\" | \"graph\" | \"algebra\" | \"analysis\" | \"optimization\" | \"topology\" | \"computation\" | \"probability\" | \"information-theory\" | \"dynamical-systems\"\n<shape> ::= \"set\" | \"boolean\" | \"edge-list\" | \"ranking\" | \"procedure\" | \"artifact\" | <text>\n<node_meta_tag> ::= \"@purpose\" \":\" <string>\n| \"@axis_question\" \":\" <string>\n| \"@cue\" \":\" <string>\n| \"@genesis\" \":\" <substrate_stage>\n| \"@mandatory\"\n<substrate_stage> ::= \"existence\" | \"difference\" | \"relation\" | \"structure\" | \"transformation\" | \"constraint\" | \"emergence\"\n\n# Contract\n<contract> ::= \"CONTRACT\" \":\" \"input\" \":\" <contract_input> \"transform\" \":\" <directive>+ <optional_preserves> <optional_constraints> \"output\" \":\" <text> <optional_freshness> <optional_handoff_summary>\n<contract_input> ::= \"NODE\" <node_number> <text> | <slot> | <declared_variable> | <text>\n<optional_preserves> ::= (\"preserves\" \":\" <distinction_set>) | ε\n<distinction_set> ::= <text> (\",\" <text>)*\n<optional_constraints> ::= (\"constraints\" \":\" <text>) | ε\n<optional_freshness> ::= (\"freshness\" \":\" <fingerprint> \"+\" <fingerprint>) | ε\n<fingerprint> ::= <text>\n<optional_handoff_summary> ::= (\"handoff\" \":\" <text>) | ε\n<optional_output_contract> ::= (\"#\" \"OUTPUT\" \"CONTRACT\" <declaration_statement>+) | ε\n<slot> ::= \"{\" <identifier> (\".\" <identifier>)* \"}\"\n<declared_variable> ::= <variable_name>\n\n# Handoff gate\n<handoff_gate> ::= \"HANDOFF\" \"GATE\" <optional_gate_qualifier> \":\" <optional_rule_id> <check_line>+ <optional_refusal_line> <optional_standing_line> <result_line>\n<optional_gate_qualifier> ::= (\"(\" <text> \")\") | ε\n<optional_rule_id> ::= (\"rule_id\" \":\" <string> \"yields\" \":\" <shape>) | ε\n<check_line> ::= <check_marker> <check_condition> \"(\" \"evidence\" \":\" <text> \")\" <optional_population_clause>\n<check_marker> ::= \"[check]\" | \"ASSERT\" | \"REQUIRE\"\n<check_condition> ::= <boolean_expr>\n<optional_population_clause> ::= <population_clause> | ε\n<population_clause> ::= \"over\" \":\" <set> \"measured\" \":\" <count> \"/\" <count>\n<set> ::= <text>\n<count> ::= <number> | <text>\n<optional_refusal_line> ::= (\"refuse\" \":\" <condition> \"before\" <write>) | ε\n<write> ::= <semantic_operation> | <text>\n<optional_standing_line> ::= (\"standing\" \":\" \"moved-set\" <set>) | ε\n<result_line> ::= \"result\" \":\" \"pass\" \"->\" <next_node> (\"|\" <failure_name> \"->\" \"REPAIR\" \"(\" \"owner\" \":\" <owner_node> \")\")+ \"|\" \"unknown\" \"->\" \"BLOCKED\"\n<verdict> ::= \"pass\" | \"fail\" | \"unknown\"\n<next_node> ::= \"NODE\" <node_number> | \"TERMINATE\"\n<failure_name> ::= <text>\n<owner_node> ::= \"NODE\" <node_number> | <identifier>\n<repair_edge> ::= \"#\" \"REPAIR\" \"EDGE\" <text>\n\n# Invariant block\n<invariant_block> ::= \"#\" \"CROSS-NODE\" \"INVARIANTS\" <invariant_record>+\n<invariant_record> ::= \"INVARIANT\" <name> \":\" <property> \"over\" \":\" <set> \"binds\" \":\" <parties> \"objector\" \":\" (<check_ref> | \"none\")\n<name> ::= <identifier>\n<property> ::= <text>\n<parties> ::= <text>\n<check_ref> ::= \"[check]\" <text>\n\n# Report block\n<report_block> ::= \"REPORT\" \":\" <report_field>+\n<report_field> ::= \"subject\" \":\" <node_ref>\n| \"verdict\" \":\" <verdict>\n| \"domain\" \":\" \"declared\" <count> \"measured\" <count>\n| \"populations\" \":\" <partition_list>\n| \"inputs\" \":\" <fingerprint_list>\n| \"code\" \":\" <fingerprint>\n| \"output\" \":\" <fingerprint>\n| \"refusals\" \":\" <count> <reason_list>\n| \"unresolved\" \":\" <count> <reason_list>\n| \"completion\" \":\" \"saturated\" <boolean> \"complete\" <boolean> \"verified\" <boolean>\n<node_ref> ::= \"NODE\" <node_number>\n<partition_list> ::= <text> <count> (\",\" <text> <count>)*\n<fingerprint_list> ::= <text> <fingerprint> (\",\" <text> <fingerprint>)*\n<reason_list> ::= \"[\" <text> (\",\" <text>)* \"]\"\n\n# Macro\n<macro> ::= \"USE\" \"TEMPLATE\" <template_name>\n<template_name> ::= <identifier>\n\n# Rule\n<rule_declaration> ::= \"RULE\" <rule_name> \":\" <rule_body>\n<rule_name> ::= <identifier>\n<rule_body> ::= <when_clause>* <directive>+\n<when_clause> ::= \"WHEN\" <condition> \":\" <directive>+",
                "kind": "code",
                "language": "bnf",
                "title": "BNF grammar"
              }
            ],
            "content": "These rules cover [document structure](/pag/guide#document-structure), the meta block, nodes, contracts, handoff gates, invariant records and the report.",
            "title": "Planning rules"
          },
          {
            "blocks": [
              {
                "code": "# Directive\n<directive> ::= <optional_task_marker> <optional_meta_tag> <optional_context_cue> <directive_body>\n<directive_body> ::= <action_expr>\n| <control_flow>\n| <declaration_statement>\n| <transform_statement>\n| <discovery_statement>\n| <iteration_statement>\n| <function_declaration>\n| <announcement_statement>\n| <state_machine_declaration>\n| <dag_declaration>\n| <priority_queue_declaration>\n| <priority_queue_operation>\n| <surface_declaration>\n| <wait_statement>\n| <flowchart_declaration>\n| <mermaid_declaration>\n| <ascii_flowchart_block>\n| <macro>\n<optional_task_marker> ::= <task_marker> | ε\n<task_marker> ::= \"[\" <task_state> \"]\"\n<task_state> ::= \" \" | \"x\" | \">\"\n<optional_meta_tag> ::= <node_meta_tag> | ε\n<optional_context_cue> ::= (\"@cue\" \":\" <string>) | ε\n\n# Action expression\n<action_expr> ::= <action_verb> <modifier>* <action_target> <optional_action_args>\n<action_verb> ::= <semantic_operation>\n| \"EXECUTE\" | \"READ\" | \"WRITE\" | \"DELETE\" | \"REMOVE\" | \"ANALYZE\"\n| \"CREATE\" | \"FIND\" | \"REPORT\" | \"VALIDATE\" | \"VERIFY\"\n| \"COLLECT\" | \"EXTRACT\" | \"LINK\" | \"DETERMINE\" | \"CLASSIFY\"\n| \"INVESTIGATE\" | \"FILTER\" | \"COMPARE\" | \"CONVERT\" | \"MERGE\" | \"SPLIT\" | \"MARK\"\n| \"SORT\" | \"RANK\" | \"ORDER\" | \"INSERT\" | \"APPEND\"\n| \"ADD\" | \"MOVE\" | \"COPY\" | \"BACKUP\" | \"RESTORE\" | \"LOAD\"\n| \"ITERATE\" | \"ATTEMPT\" | \"ENFORCE\" | \"RENAME\"\n| \"FAIL\" | \"EXIT\" | \"RETURN\" | \"WAIT\" | \"SEND\"\n| \"REDUCE\" | \"PROPAGATE\" | \"FINALIZE\" | \"EVIDENCE\"\n| \"PREDICT\" | \"EXPLAIN\" | \"REFLECT\" | \"ABSTRACT\" | \"GENERALIZE\" | \"DESCRIBE\" | \"FORMALIZE\"\n<semantic_operation> ::= \"DISCOVER_RESOURCES\" | \"READ_RESOURCE\" | \"SEARCH_CONTENT\" | \"ANALYZE_CONTENT\" | \"EXTRACT_FACTS\" | \"CALCULATE_METRIC\"\n| \"COMPOSE_ARTIFACT\" | \"VALIDATE_ARTIFACT\" | \"PERSIST_ARTIFACT\" | \"EXECUTE_TOOL\" | \"REQUEST_DECISION\" | \"REPORT_RESULT\"\n<modifier> ::= \"MUST\" | \"NEVER\" | \"ALWAYS\" | \"REQUIRED\" | \"MANDATORY\"\n<action_target> ::= <tool_name> | <path> | <variable_name>\n<tool_name> ::= \"SYSTEM\" | \"USER\" | \"SERVICE\"\n<optional_action_args> ::= <parenthesized_args> | <bare_args> | ε\n<parenthesized_args> ::= \"(\" <arg_list> \")\"\n<bare_args> ::= <arg_list>\n<arg_list> ::= <arg> (\",\" <arg>)*\n<arg> ::= <identifier> | <literal> | <expression>\n\n# Control flow\n<control_flow> ::= <if_statement>\n| <for_loop>\n| <while_loop>\n| <try_catch>\n| <goto_statement>\n| <label_declaration>\n| <flow_marker>\n<if_statement> ::= \"IF\" <condition> \":\" <directive>+\n(\"ELSE\" \"IF\" <condition> \":\" <directive>+)*\n<optional_else_clause>\n<optional_else_clause> ::= (\"ELSE\" \":\" <directive>+) | ε\n<for_loop> ::= \"FOR\" \"EACH\" <iterator> \"IN\" <collection> \":\" <directive>+\n<while_loop> ::= \"WHILE\" <condition> \":\" <directive>+\n<try_catch> ::= \"TRY\" \":\" <directive>+\n\"CATCH\" <optional_exception_var> \":\" <directive>+\n<optional_exception_var> ::= <exception_var> | ε\n<exception_var> ::= <identifier>\n<goto_statement> ::= \"GOTO\" <label_identifier>\n<label_declaration> ::= <label_identifier> \":\"\n<label_identifier> ::= <identifier>\n<flow_marker> ::= \"START\" <optional_label>\n| \"LOOP\" <optional_backto>\n| \"END\"\n| \"STOP\"\n<optional_label> ::= <identifier> | ε\n<optional_backto> ::= (\"BACKTO\" <identifier>) | ε\n\n# Declaration statement\n<declaration_statement> ::= \"SET\" <variable_name> \"=\" <expression>\n| \"DECLARE\" <variable_name> \":\" <type_annotation>\n<type_annotation> ::= \"string\" | \"number\" | \"boolean\" | \"array\" | \"object\" | \"file\" | \"context\"\n\n# Transform statement\n<transform_statement> ::= <backup_directive> <edit_directive> <optional_analyze_directive>\n<backup_directive> ::= \"BACKUP\" <path> \"TO\" <backup_location>\n| \"COPY\" <path> \"TO\" <backup_location>\n<edit_directive> ::= \"PERSIST_ARTIFACT\" <artifact> \"TO\" <destination>\n| \"WRITE\" <path> <write_spec>\n| \"EXECUTE_TOOL\" <edit_command> \"WITH\" \"timeout\" \":\" <number>\n<edit_command> ::= <identifier>\n<artifact> ::= <variable_name>\n<analyze_directive> ::= \"VALIDATE_ARTIFACT\" <artifact> \"AGAINST\" <verification_condition>\n<optional_analyze_directive> ::= <analyze_directive> | ε\n<backup_location> ::= <path>\n<write_spec> ::= \"CONTENT\" <string>\n| \"FROM\" <source_file>\n| \"INTO\" <destination>\n| <string>\n<source_file> ::= <path>\n<destination> ::= <path>\n<verification_condition> ::= <condition>\n\n# Discovery statement\n<discovery_statement> ::= <discovery_action> <optional_verification_check>\n<discovery_action> ::= \"DISCOVER_RESOURCES\" <pattern> <optional_scope> \"INTO\" <collection_var>\n| \"SEARCH_CONTENT\" <search_scope> \"FOR\" <search_term> \"INTO\" <collection_var>\n| \"FIND\" <search_term> \"IN\" <search_location>\n<verification_check> ::= \"IF\" \"exists\" \":\" <directive>+\n| \"ANALYZE\" <expression> <comparison_op> <expression>\n<optional_verification_check> ::= <verification_check> | ε\n<optional_scope> ::= \"IN\" <search_scope> | ε\n<search_scope> ::= <path>\n<search_location> ::= <path>\n<search_term> ::= <string>\n<collection_var> ::= <variable_name>",
                "kind": "code",
                "language": "bnf",
                "title": "BNF grammar"
              }
            ],
            "content": "These rules cover directives, actions, control flow and declarations.",
            "title": "Statement rules"
          },
          {
            "blocks": [
              {
                "code": "# Expressions\n<expression> ::= <pipeline_expr>\n<pipeline_expr> ::= <logical_or_expr> (\"|>\" <logical_or_expr>)*\n<logical_or_expr> ::= <logical_and_expr> (\"OR\" <logical_and_expr>)*\n<logical_and_expr> ::= <equality_expr> (\"AND\" <equality_expr>)*\n<equality_expr> ::= <relational_expr> ((\"===\" | \"!==\") <relational_expr>)*\n<relational_expr> ::= <additive_expr> ((\"<\" | \">\" | \"<=\" | \">=\") <additive_expr>)*\n| <additive_expr> \"MATCHES\" <pattern>\n| <additive_expr> \"FOR\" <expression>\n| <additive_expr> \"BETWEEN\" <expression>\n<additive_expr> ::= <multiplicative_expr> ((\"+\" | \"-\") <multiplicative_expr>)*\n<multiplicative_expr> ::= <unary_expr> ((\"*\" | \"/\" | \"%\") <unary_expr>)*\n<unary_expr> ::= (\"!\" | \"NOT\" | \"-\" | \"+\") <postfix_expr>\n| <postfix_expr>\n<postfix_expr> ::= <primary_expr> <postfix_op>*\n<postfix_op> ::= \"[\" <expression> \"]\"\n| \".\" <identifier>\n| \"(\" <optional_arg_list> \")\"\n<primary_expr> ::= <array_literal>\n| <object_literal>\n| <literal>\n| <identifier>\n| \"(\" <expression> \")\"\n<array_literal> ::= \"[\" <optional_expression_list> \"]\"\n<object_literal> ::= \"{\" <optional_key_value_pairs> \"}\"\n<expression_list> ::= <expression> (\",\" <expression>)*\n<optional_expression_list> ::= <expression_list> | ε\n<key_value_pair> ::= <object_key> \":\" <expression>\n<object_key> ::= <identifier> | <string> | <number>\n<key_value_pairs> ::= <key_value_pair> (\",\" <key_value_pair>)*\n<optional_key_value_pairs> ::= <key_value_pairs> | ε\n<function_call> ::= <function_name> \"(\" <optional_arg_list> \")\"\n<optional_arg_list> ::= <arg_list> | ε\n<condition> ::= <expression>\n<boolean_expr> ::= <logical_or_expr>\n<verification_expr> ::= <expression>\n<term> ::= <multiplicative_expr>\n<factor> ::= <primary_expr>\n<pattern> ::= <string> | <regex_literal>\n<regex_literal> ::= \"/\" <regex_pattern> \"/\" <optional_regex_flags>\n<optional_regex_flags> ::= <regex_flags> | ε\n<regex_pattern> ::= <any_regex_character>+\n<regex_flags> ::= <letter>+\n<comparison_op> ::= \"===\" | \"!==\" | \"<\" | \">\" | \"<=\" | \">=\"\n\n# Lexical\n<identifier> ::= <letter> (<letter> | <digit> | \"_\" | \"-\")*\n<variable_name> ::= <identifier>\n<function_name> ::= <identifier>\n<node_name> ::= <identifier>\n<path> ::= <directory_path> | <file_path>\n<directory_path> ::= <path_segment> (\"/\" <path_segment>)* \"/\"\n<file_path> ::= <path_segment> (\"/\" <path_segment>)* <optional_file_extension>\n<path_segment> ::= <identifier>\n<optional_file_extension> ::= (\".\" <identifier>) | ε\n<literal> ::= <number> | <string> | <boolean>\n<number> ::= <digit>+ <optional_decimal>\n<optional_decimal> ::= (\".\" <digit>+) | ε\n<string> ::= '\"' <char>* '\"' | \"'\" <char>* \"'\"\n<boolean> ::= \"true\" | \"false\"\n<digit> ::= \"0\" | \"1\" | \"2\" | \"3\" | \"4\" | \"5\" | \"6\" | \"7\" | \"8\" | \"9\"\n<letter> ::= \"a\"..\"z\" | \"A\"..\"Z\"\n<char> ::= <any_character>\n<text> ::= <char>+\n<yaml_content> ::= <text>\n<any_character> ::= <letter> | <digit> | <whitespace> | <symbol>\n<symbol> ::= \"_\" | \"-\" | \".\" | \",\" | \":\" | \";\" | \"!\" | \"?\" | \"@\" | \"#\" | \"$\" | \"%\" | \"^\" | \"&\" | \"*\" | \"(\" | \")\" | \"[\" | \"]\" | \"{\" | \"}\" | \"<\" | \">\" | \"/\" | \"\\\" | \"|\" | \"=\" | \"+\" | \"`\" | \"~\"\n<any_regex_character> ::= <letter> | <digit> | <symbol>\n<whitespace> ::= \" \" | \"\t\" | \"\n\" | \"\r\"\n\n# Iteration statement\n<iteration_statement> ::= <loop_header> <loop_body>\n<loop_header> ::= \"FOR\" \"EACH\" <iterator> \"IN\" <collection>\n<loop_body> ::= \":\" <directive>+ <optional_accumulation> <optional_recursion_limit>\n<accumulation_statement> ::= \"APPEND\" <value> \"TO\" <accumulator>\n| \"CREATE\" <structure> \"FROM\" <iterator>\n| \"EXTRACT\" <components> \"INTO\" <structure>\n| \"WRITE\" <data> \"INTO\" <storage>\n| \"COLLECT\" <items> \"INTO\" <collection>\n| \"SET\" <state_var> \"=\" <state_expr>\n<recursion_limit> ::= \"recursion_limit\" \":\" <number>\n<optional_accumulation> ::= <accumulation_statement> | ε\n<optional_recursion_limit> ::= <recursion_limit> | ε\n<iterator> ::= <variable_name>\n<collection> ::= <variable_name> | <expression>\n<value> ::= <expression>\n<accumulator> ::= <variable_name>\n<structure> ::= <variable_name>\n<components> ::= <expression>\n<data> ::= <expression>\n<items> ::= <expression>\n<storage> ::= <variable_name>\n<state_var> ::= <variable_name>\n<state_expr> ::= <expression>\n\n# Function declaration\n<function_declaration> ::= \"FUNCTION\" <function_name> \"(\" <optional_param_list> \")\" \":\" <directive>+\n<optional_param_list> ::= <param_list> | ε\n<param_list> ::= <parameter> (\",\" <parameter>)*\n<parameter> ::= <variable_name>\n\n# Announcement statement\n<announcement_statement> ::= \"REPORT\" <message>\n<message> ::= <string> | <expression>",
                "kind": "code",
                "language": "bnf",
                "title": "BNF grammar"
              }
            ],
            "content": "These rules cover expressions, operators, literals and lexical elements.",
            "title": "Expression rules"
          },
          {
            "blocks": [
              {
                "code": "# Await\n<await_statement> ::= \"AWAIT\" <awaitable_expression> <optional_result_binding>\n<awaitable_expression> ::= <identifier> | <string> | <tool_invocation>\n<optional_result_binding> ::= \"INTO\" <identifier> | ε\n\n# Parallel\n<parallel_block> ::= \"PARALLEL\" \":\" <directive>+ \"END\"\n\n# Surface\n<surface_declaration> ::= \"SURFACE\" <surface_key> \":\" <record_declaration>+\n<record_declaration> ::= \"RECORD\" <record_id> \"subject\" \":\" <subject_key> <edge_clause>* <item>*\n<item> ::= \"ITEM\" <item_id> \"TO\" <reader> \":\" <text>\n<edge_clause> ::= <edge_kind> <target_id>\n<edge_kind> ::= \"PARENT\" | \"SATISFIED_BY\" | \"BLOCKS\" | \"ANSWERS\" | \"REFUTES\" | \"SUPERSEDES\"\n<derived_state> ::= \"OPEN\" | \"BLOCKED\" | \"ABSORBED\"\n<wait_statement> ::= \"WAIT\" \"ON\" <surface_key> \"AS\" <reader> \"INTO\" <diff_binding>\n<barrier_statement> ::= \"BARRIER\" \"ON\" <surface_key>\n<swap_statement> ::= \"SWAP\" ** \"AGAINST\" ****<read>****\n****<reader>**** ::= \"participant\" | \"bounded\" | ****<identifier>****\n****<surface_key>**** ::= ****<identifier>****\n****<record_id>**** ::= ****<surface_key>**** \"-\" ****<number>****\n****<item_id>**** ::= ****<record_id>**** \"-\" ****<number>****\n****<subject_key>**** ::= ****<identifier>****\n****<target_id>**** ::= ****<record_id>**** | ****<path>****\n****<diff_binding>**** ::= ****<variable_name>****\n**** ::= ****<text>****\n****<read>**** ::= ****<variable_name>****\n\n# State machine\n****<state_machine_declaration>**** ::= \"STATE_MACHINE\" ****<machine_name>**** \":\" ****<state_definition>****+ ****<transition_definition>****+\n****<state_definition>**** ::= \"STATE\" ****<state_name>**** ****<optional_state_type>****\n****<optional_entry_actions>****\n****<optional_exit_actions>****\n****<transition_definition>**** ::= \"TRANSITION\" \"FROM\" ****<state_name>**** \"TO\" ****<state_name>****\n\"ON\" ****<event_name>****\n****<optional_guard>****\n****<optional_transition_actions>****\n****<optional_state_type>**** ::= \":\" ****<state_type>**** | ε\n****<optional_entry_actions>**** ::= \"ENTRY\" \":\" ****<directive>****+ | ε\n****<optional_exit_actions>**** ::= \"EXIT\" \":\" ****<directive>****+ | ε\n****<optional_guard>**** ::= \"GUARD\" \":\" ****<condition>**** | ε\n****<optional_transition_actions>**** ::= \":\" ****<directive>****+ | ε\n****<machine_name>**** ::= ****<variable_name>****\n****<state_name>**** ::= ****<variable_name>****\n****<state_type>**** ::= ****<identifier>****\n****<event_name>**** ::= ****<variable_name>****\n\n# DAG\n****<dag_declaration>**** ::= \"DAG\" ****<dag_name>**** \":\" ****<dag_item>****+\n****<dag_item>**** ::= ****<node_definition>**** | ****<parallel_group>****\n****<node_definition>**** ::= \"NODE\" ****<node_name>**** ****<optional_node_type>****\n****<optional_depends_on>****\n****<optional_after>****\n****<optional_before>****\n\":\" ****<directive>****+\n****<parallel_group>**** ::= \"PARALLEL_GROUP\" \":\" ****<node_name_list>****\n****<dependency_list>**** ::= ****<node_name>**** (\",\" ****<node_name>****)*\n****<dependent_list>**** ::= ****<node_name>**** (\",\" ****<node_name>****)*\n****<node_name_list>**** ::= ****<node_name>**** (\",\" ****<node_name>****)*\n****<optional_node_type>**** ::= \":\" ****<node_type>**** | ε\n****<optional_depends_on>**** ::= \"DEPENDS_ON\" \"[\" ****<dependency_list>**** \"]\" | ε\n****<optional_after>**** ::= \"AFTER\" ****<dependency_list>**** | ε\n****<optional_before>**** ::= \"BEFORE\" ****<dependent_list>**** | ε\n****<dag_name>**** ::= ****<variable_name>****\n****<node_type>**** ::= ****<identifier>****\n\n# Priority queue\n****<priority_queue_declaration>**** ::= \"PRIORITY_QUEUE\" ****<queue_name>****\n****<optional_comparison>****\n\":\"\n****<priority_queue_operation>**** ::= ****<enqueue_statement>****\n| ****<dequeue_statement>****\n| ****<peek_statement>****\n| ****<heapify_statement>****\n****<enqueue_statement>**** ::= \"ENQUEUE\" ****<value>**** \"TO\" ****<queue_name>****\n****<optional_priority>****\n****<dequeue_statement>**** ::= \"DEQUEUE\" \"FROM\" ****<queue_name>****\n****<optional_target>****\n****<peek_statement>**** ::= \"PEEK\" ****<queue_name>****\n****<optional_target>****\n****<heapify_statement>**** ::= \"HEAPIFY\" ****<queue_name>****\n****<comparison_function>**** ::= ****<function_name>****\n| \"(\" ****<optional_param_list>**** \")\" \"→\" ****<expression>****\n****<optional_comparison>**** ::= \"COMPARE_BY\" ****<comparison_function>**** | ε\n****<optional_priority>**** ::= \"PRIORITY\" \"=\" ****<priority_value>**** | ε\n****<optional_target>**** ::= \"TO\" ****<target_variable>**** | ε\n****<queue_name>**** ::= ****<variable_name>****\n****<priority_value>**** ::= ****<number>**** | ****<expression>****\n****<target_variable>**** ::= ****<variable_name>****\n\n# Cross reference\n****<cross_reference_statement>**** ::= ****<collect_from_statement>****\n| ****<find_in_statement>****\n| ****<reference_statement>****\n| ****<link_statement>****\n****<collect_from_statement>**** ::= \"FROM\" ****<file_path_pattern>**** \"COLLECT\" ****<selector>**** \"TO\" ****<target_variable>****\n****<find_in_statement>**** ::= \"FROM\" ****<file_path_pattern>**** \"FIND\" ****<search_term>**** \"TO\" ****<target_variable>****\n****<reference_statement>**** ::= \"REFERENCE\" ****<file_path_pattern>**** ****<optional_alias>****\n****<link_statement>**** ::= \"LINK\" ****<source_expression>**** \"TO\" ****<file_reference>****\n****<file_path_pattern>**** ::= ****<string>**** | ****<glob_pattern>****\n****<glob_pattern>**** ::= ****<string>****\n****<file_reference>**** ::= ****<string>**** ****<optional_anchor>****\n****<optional_anchor>**** ::= \"#\" ****<identifier>**** | ε\n****<selector>**** ::= ****<expression>**** | \"*\"\n****<search_term>**** ::= ****<string>**** | ****<regex_literal>****\n****<target_variable>**** ::= ****<variable_name>****\n****<source_expression>**** ::= ****<expression>****\n****<alias>**** ::= ****<identifier>****\n****<optional_alias>**** ::= \"AS\" ****<alias>**** | ε\n\n# Semantic operation\n****<tool_invocation>**** ::= ****<semantic_operation>**** ****<tool_target>**** ****<optional_tool_param_clause>**** ****<optional_tool_result_clause>****\n****<tool_target>**** ::= ****<string>**** | ****<identifier>**** | ****<file_path>**** | ****<expression>****\n****<optional_tool_param_clause>**** ::= ****<tool_param_clause>**** | ε\n****<tool_param_clause>**** ::= \"WITH\" ****<tool_param_list>****\n| \"USING\" ****<tool_param_list>****\n****<tool_param_list>**** ::= ****<tool_param_pair>**** (\",\" ****<tool_param_pair>****)*\n****<tool_param_pair>**** ::= ****<tool_param_name>**** \":\" ****<tool_param_value>****\n| ****<tool_param_name>**** \"=\" ****<tool_param_value>****\n| ****<tool_param_name>****\n****<tool_param_name>**** ::= ****<identifier>****\n****<tool_param_value>**** ::= ****<string>****\n| ****<number>****\n| ****<boolean>****\n| ****<identifier>****\n| ****<array_literal>****\n| ****<object_literal>****\n****<optional_tool_result_clause>**** ::= ****<tool_result_clause>**** | ε\n****<tool_result_clause>**** ::= \"->\" ****<tool_result_binding>****\n| \"INTO\" ****<tool_result_binding>****\n| \"AS\" ****<tool_result_binding>****\n****<tool_result_binding>**** ::= ****<identifier>**",
                "kind": "code",
                "language": "bnf",
                "title": "BNF grammar"
              }
            ],
            "content": "These rules cover the structure declarations, the [shared surface](/pag/orchestration#shared-surfaces) and the [semantic operations](/pag/guide#tool-invocation).",
            "title": "Coordination rules"
          },
          {
            "blocks": [
              {
                "code": "# Flowchart\n<flowchart_declaration> ::= \"FLOWCHART\" <flowchart_name> <optional_flowchart_state> <optional_flowchart_layout> \":\" <flowchart_body>\n<optional_flowchart_layout> ::= \"LAYOUT\" <flowchart_layout> | ε\n<flowchart_body> ::= <flowchart_line>+ <optional_error_handler>\n<optional_error_handler> ::= <error_handler> | ε\n<error_handler> ::= \"ON\" \"ERROR\" \":\" <directive>+\n<flowchart_line> ::= <flowchart_node>\n| <flowchart_edge>\n| <flowchart_branch>\n| <flowchart_merge>\n| <flowchart_loop>\n<flowchart_node> ::= <node_label> <node_shape> <optional_shape_type> <optional_node_content>\n<node_label> ::= <identifier> | <string>\n<node_shape> ::= \"[\" <text> \"]\"\n| \"(\" <text> \")\"\n| \"{\" <text> \"}\"\n| \"<\" <text> \">\"\n| \"((\" <text> \"))\"\n| \"[[\" <text> \"]]\"\n<optional_shape_type> ::= \":\" <flowchart_shape_types> | ε\n<optional_node_content> ::= <node_content> | ε\n<node_content> ::= \":\" <node_block>\n<node_block> ::= <directive>+\n| \"EVALUATE\" <condition>\n| \"EXECUTE\" <function_call>\n| \"TRY\" \":\" <directive>+ \"CATCH\" \":\" <directive>+\n<optional_flowchart_state> ::= \"WITH\" \"STATE\" <state_declaration>+ | ε\n<state_declaration> ::= <variable_name> \":\" <type_annotation> \"=\" <expression>\n<flowchart_edge> ::= <edge_source> <edge_arrow> <edge_target> <optional_edge_label>\n<edge_source> ::= <identifier>\n<edge_target> ::= <identifier>\n<edge_arrow> ::= \"→\" | \"↓\" | \"↑\" | \"←\" | \"↔\"\n| \"-->\" | \"--->\" | \"==>\" | \"-.->>\"\n| \"|\"\n<optional_edge_label> ::= \":\" <string> | ε\n<flowchart_branch> ::= <branch_source> \"/\" <branch_option>+\n<branch_source> ::= <identifier>\n<branch_option> ::= <branch_condition> \"→\" <branch_target>\n<branch_condition> ::= <condition> | <string>\n<branch_target> ::= <identifier>\n<flowchart_merge> ::= <merge_source>+ \"◄\" <merge_target>\n<merge_source> ::= <identifier>\n<merge_target> ::= <identifier>\n<flowchart_loop> ::= \"LOOP\" <loop_source> \"→\" <loop_target> <optional_loop_limit>\n<loop_source> ::= <identifier>\n<loop_target> ::= <identifier>\n<optional_loop_limit> ::= \"MAX\" <number> | ε\n<flowchart_shape_types> ::= \"process\"\n| \"decision\"\n| \"start_end\"\n| \"input_output\"\n| \"subprocess\"\n| \"database\"\n<flowchart_layout> ::= \"vertical\" | \"horizontal\" | \"lr\" | \"rl\" | \"tb\" | \"bt\"\n<flowchart_name> ::= <variable_name>\n\n# ASCII flowchart\n<ascii_flowchart_block> ::= <ascii_flowchart_line>+\n<ascii_flowchart_line> ::= <ascii_node_line>\n| <ascii_connector_line>\n| <ascii_branch_line>\n| <ascii_merge_line>\n<ascii_node_line> ::= <indent> <ascii_node>\n<ascii_node> ::= \"[\" <text> \"]\"\n| \"(\" <text> \")\"\n| \"{\" <text> \"}\"\n| \"<\" <text> \">\"\n<ascii_connector_line> ::= <indent> \"|\"\n| <indent> \"│\"\n| <indent> \"▼\"\n| <indent> \"▲\"\n| <indent> \"►\"\n| <indent> \"◄\"\n<ascii_branch_line> ::= <indent> \"/\" <indent> \"\\\"\n| <indent> \"▼\" <indent> \"▼\"\n<ascii_merge_line> ::= <indent> \"\\\" <indent> \"/\"\n| <indent> \"◄\" \"─\" \"┘\"\n<indent> ::= <whitespace>*\n\n# Mermaid flowchart\n<mermaid_declaration> ::= \"MERMAID\" <mermaid_type> \":\" <mermaid_body>\n<mermaid_type> ::= \"flowchart\" | \"graph\" | \"sequence\" | \"class\" | \"state\" | \"er\"\n<mermaid_body> ::= <mermaid_line>+\n<mermaid_line> ::= <mermaid_node_def>\n| <mermaid_connection>\n| <mermaid_subgraph>\n| <mermaid_style>\n<mermaid_node_def> ::= <node_id> <mermaid_node_shape> <optional_node_text>\n<node_id> ::= <identifier>\n<mermaid_node_shape> ::= \"[\" <text> \"]\"\n| \"(\" <text> \")\"\n| \"{\" <text> \"}\"\n| \"((\" <text> \"))\"\n| \"[[\" <text> \"]]\"\n| \"[/\" <text> \"/]\"\n| \"[\\\" <text> \"\\]\"\n<optional_node_text> ::= <text> | ε\n<mermaid_connection> ::= <node_id> <mermaid_arrow> <node_id> <optional_connection_text>\n<mermaid_arrow> ::= \"-->\" | \"--->\" | \"==>\" | \"-.->\" | \"--\"\n<optional_connection_text> ::= \"|\" <text> \"|\" | ε\n<mermaid_subgraph> ::= \"subgraph\" <subgraph_title> <mermaid_line>+ \"end\"\n<subgraph_title> ::= <string>\n<mermaid_style> ::= \"style\" <node_id> <style_properties>\n<style_properties> ::= <style_property> (\",\" <style_property>)*\n<style_property> ::= <identifier> \":\" <string>",
                "kind": "code",
                "language": "bnf",
                "title": "BNF grammar"
              }
            ],
            "content": "These rules cover flowcharts written in PAG's own form, in ASCII and in Mermaid.",
            "title": "Flowchart rules"
          }
        ],
        "title": "BNF grammar"
      }
    ]
  },
  "description": "PAG is defined by a context-free grammar written in Backus–Naur form (BNF), and its rules fall into five categories.",
  "id": "pag",
  "label": "Grammar",
  "tab": "grammar",
  "title": "Grammar — PAG — Bane's Lab",
  "url": "https://banes-lab.com/pag/grammar"
}
