{
  "recipes": [
    {
      "id": "checked-record-import",
      "format": "bound-recipe-v1",
      "goal": "Parse CSV, keep ready rows, rename fields, sort, check the result and fingerprint deterministic JSON.",
      "limitations": [
        "CSV values remain strings; no inferred numbers or dates",
        "Every step is a separately authorized and priced call; stop on error or failed require condition",
        "Digest proves byte correspondence, not source authenticity"
      ],
      "exampleInput": {
        "csv": "id,name,status\n2,Lin,ready\n1,Ada,ready\n3,Bo,pending\n"
      },
      "steps": [
        {
          "id": "parse",
          "operation": "csv-parse",
          "purpose": "Read strict supplied CSV",
          "input": {
            "text": ""
          },
          "bindings": [
            {
              "target": "/text",
              "from": {
                "pointer": "/csv"
              }
            }
          ]
        },
        {
          "id": "filter",
          "operation": "records-filter",
          "purpose": "Keep only exact ready status",
          "input": {
            "records": [],
            "predicates": [
              {
                "path": "/status",
                "op": "eq",
                "value": "ready"
              }
            ]
          },
          "bindings": [
            {
              "target": "/records",
              "from": {
                "step": "parse",
                "pointer": "/records"
              }
            }
          ]
        },
        {
          "id": "project",
          "operation": "records-project",
          "purpose": "Keep and rename required fields",
          "input": {
            "records": [],
            "fields": [
              {
                "from": "/id",
                "as": "customerId"
              },
              {
                "from": "/name",
                "as": "name"
              }
            ]
          },
          "bindings": [
            {
              "target": "/records",
              "from": {
                "step": "filter",
                "pointer": "/records"
              }
            }
          ]
        },
        {
          "id": "sort",
          "operation": "records-sort",
          "purpose": "Sort by exact string ID",
          "input": {
            "records": [],
            "keys": [
              {
                "path": "/customerId"
              }
            ]
          },
          "bindings": [
            {
              "target": "/records",
              "from": {
                "step": "project",
                "pointer": "/records"
              }
            }
          ]
        },
        {
          "id": "check",
          "operation": "json-schema-check",
          "purpose": "Check final record shape",
          "input": {
            "value": [],
            "schema": {
              "type": "array",
              "items": {
                "type": "object",
                "required": [
                  "customerId",
                  "name"
                ],
                "properties": {
                  "customerId": {
                    "type": "string"
                  },
                  "name": {
                    "type": "string"
                  }
                },
                "additionalProperties": false
              }
            }
          },
          "bindings": [
            {
              "target": "/value",
              "from": {
                "step": "sort",
                "pointer": "/records"
              }
            }
          ],
          "require": [
            {
              "pointer": "/valid",
              "equals": true
            }
          ]
        },
        {
          "id": "serialize",
          "operation": "json-canonicalize",
          "purpose": "Serialize sorted records reproducibly",
          "input": {
            "value": []
          },
          "bindings": [
            {
              "target": "/value",
              "from": {
                "step": "sort",
                "pointer": "/records"
              }
            }
          ]
        },
        {
          "id": "digest",
          "operation": "content-digest",
          "purpose": "Hash exact serialized output",
          "input": {
            "text": "",
            "algorithm": "SHA-256"
          },
          "bindings": [
            {
              "target": "/text",
              "from": {
                "step": "serialize",
                "pointer": "/canonical"
              }
            }
          ]
        }
      ],
      "outputs": {
        "records": {
          "step": "sort",
          "pointer": "/records"
        },
        "canonical": {
          "step": "serialize",
          "pointer": "/canonical"
        },
        "sha256": {
          "step": "digest",
          "pointer": "/hex"
        }
      }
    },
    {
      "id": "guarded-config-revision",
      "format": "bound-recipe-v1",
      "goal": "Apply an explicitly reviewed JSON Patch with an expected-value guard, validate and compare the result.",
      "limitations": [
        "Patch is supplied explicitly; no intent inference or remote mutation",
        "Canonical strings are not RFC 8785 signing material",
        "Line diff compares serialized text, not semantic compatibility"
      ],
      "exampleInput": {
        "document": {
          "status": "draft",
          "owner": "agent"
        },
        "operations": [
          {
            "op": "test",
            "path": "/status",
            "value": "draft"
          },
          {
            "op": "replace",
            "path": "/status",
            "value": "ready"
          }
        ]
      },
      "steps": [
        {
          "id": "before",
          "operation": "json-canonicalize",
          "purpose": "Capture before text",
          "input": {
            "value": {}
          },
          "bindings": [
            {
              "target": "/value",
              "from": {
                "pointer": "/document"
              }
            }
          ]
        },
        {
          "id": "patch",
          "operation": "json-patch",
          "purpose": "Apply supplied guarded patch atomically",
          "input": {
            "document": {},
            "operations": []
          },
          "bindings": [
            {
              "target": "/document",
              "from": {
                "pointer": "/document"
              }
            },
            {
              "target": "/operations",
              "from": {
                "pointer": "/operations"
              }
            }
          ],
          "require": [
            {
              "pointer": "/documentExists",
              "equals": true
            }
          ]
        },
        {
          "id": "check",
          "operation": "json-schema-check",
          "purpose": "Validate required ready status",
          "input": {
            "value": {},
            "schema": {
              "type": "object",
              "required": [
                "status"
              ],
              "properties": {
                "status": {
                  "const": "ready"
                }
              }
            }
          },
          "bindings": [
            {
              "target": "/value",
              "from": {
                "step": "patch",
                "pointer": "/document"
              }
            }
          ],
          "require": [
            {
              "pointer": "/valid",
              "equals": true
            }
          ]
        },
        {
          "id": "after",
          "operation": "json-canonicalize",
          "purpose": "Capture after text",
          "input": {
            "value": {}
          },
          "bindings": [
            {
              "target": "/value",
              "from": {
                "step": "patch",
                "pointer": "/document"
              }
            }
          ]
        },
        {
          "id": "diff",
          "operation": "lines-diff",
          "purpose": "Produce bounded line review",
          "input": {
            "before": "",
            "after": ""
          },
          "bindings": [
            {
              "target": "/before",
              "from": {
                "step": "before",
                "pointer": "/canonical"
              }
            },
            {
              "target": "/after",
              "from": {
                "step": "after",
                "pointer": "/canonical"
              }
            }
          ]
        }
      ],
      "outputs": {
        "document": {
          "step": "patch",
          "pointer": "/document"
        },
        "diff": {
          "step": "diff",
          "pointer": ""
        }
      }
    },
    {
      "id": "verified-evidence-handoff",
      "format": "bound-recipe-v1",
      "goal": "Locate one unique literal quote, pack its exact source span, audit explicit citation links and verify the excerpt against a caller-supplied manifest.",
      "limitations": [
        "Single unique literal excerpt only; no semantic truth, entailment or credibility verification",
        "Caller supplies claim/evidence links, cost units and expected artifact size/hash",
        "Source offsets are UTF-16; manifest bytes/hash cover UTF-8 text",
        "No fetching, filesystem access or document delivery"
      ],
      "exampleInput": {
        "sourceText": "😀 Release requires two reviewers. The date is tentative.",
        "quoteText": "Release requires two reviewers.",
        "costUnits": 9,
        "budgetUnits": 12,
        "reservedUnits": 3,
        "claimId": "review-rule",
        "expectedBytes": 31,
        "expectedSha256": "f209020f4a4c0fc736ba37f4dbc0b967720a00a6f713e6c66ef6e98d6e454756"
      },
      "steps": [
        {
          "id": "quote",
          "operation": "evidence-quote-check",
          "purpose": "Require one unique literal source match",
          "input": {
            "sources": [
              {
                "id": "memo",
                "text": ""
              }
            ],
            "quotes": [
              {
                "id": "quote",
                "sourceId": "memo",
                "text": ""
              }
            ]
          },
          "bindings": [
            {
              "target": "/sources/0/text",
              "from": {
                "pointer": "/sourceText"
              }
            },
            {
              "target": "/quotes/0/text",
              "from": {
                "pointer": "/quoteText"
              }
            }
          ],
          "require": [
            {
              "pointer": "/allVerified",
              "equals": true
            }
          ]
        },
        {
          "id": "pack",
          "operation": "context-budget-pack",
          "purpose": "Pack the verified source span using caller-supplied costs",
          "input": {
            "sources": [
              {
                "id": "memo",
                "text": ""
              }
            ],
            "candidates": [
              {
                "id": "quote",
                "sourceId": "memo",
                "start": 0,
                "end": 0,
                "costUnits": 0,
                "required": true
              }
            ],
            "budgetUnits": 0,
            "reservedUnits": 0
          },
          "bindings": [
            {
              "target": "/sources/0/text",
              "from": {
                "pointer": "/sourceText"
              }
            },
            {
              "target": "/candidates/0/start",
              "from": {
                "step": "quote",
                "pointer": "/quotes/0/matches/0/start"
              }
            },
            {
              "target": "/candidates/0/end",
              "from": {
                "step": "quote",
                "pointer": "/quotes/0/matches/0/end"
              }
            },
            {
              "target": "/candidates/0/costUnits",
              "from": {
                "pointer": "/costUnits"
              }
            },
            {
              "target": "/budgetUnits",
              "from": {
                "pointer": "/budgetUnits"
              }
            },
            {
              "target": "/reservedUnits",
              "from": {
                "pointer": "/reservedUnits"
              }
            }
          ],
          "require": [
            {
              "pointer": "/requiredSatisfied",
              "equals": true
            },
            {
              "pointer": "/withinBudget",
              "equals": true
            }
          ]
        },
        {
          "id": "coverage",
          "operation": "citation-coverage-audit",
          "purpose": "Check explicit claim-to-evidence links, never semantic proof",
          "input": {
            "sourceIds": [
              "memo"
            ],
            "claims": [
              {
                "id": ""
              }
            ],
            "evidence": [
              {
                "id": "quote",
                "sourceId": "memo"
              }
            ],
            "citations": [
              {
                "claimId": "",
                "evidenceId": "quote"
              }
            ]
          },
          "bindings": [
            {
              "target": "/claims/0/id",
              "from": {
                "pointer": "/claimId"
              }
            },
            {
              "target": "/citations/0/claimId",
              "from": {
                "pointer": "/claimId"
              }
            }
          ],
          "require": [
            {
              "pointer": "/passesChecks",
              "equals": true
            }
          ]
        },
        {
          "id": "artifact",
          "operation": "artifact-manifest-check",
          "purpose": "Compare packed UTF-8 text with caller-supplied expected evidence hash/size",
          "input": {
            "manifest": [
              {
                "path": "evidence.txt",
                "sizeBytes": 0,
                "sha256": ""
              }
            ],
            "files": [
              {
                "path": "evidence.txt",
                "text": ""
              }
            ]
          },
          "bindings": [
            {
              "target": "/manifest/0/sizeBytes",
              "from": {
                "pointer": "/expectedBytes"
              }
            },
            {
              "target": "/manifest/0/sha256",
              "from": {
                "pointer": "/expectedSha256"
              }
            },
            {
              "target": "/files/0/text",
              "from": {
                "step": "pack",
                "pointer": "/selected/0/text"
              }
            }
          ],
          "require": [
            {
              "pointer": "/passesChecks",
              "equals": true
            }
          ]
        }
      ],
      "outputs": {
        "excerpt": {
          "step": "pack",
          "pointer": "/selected/0/text"
        },
        "sourceSha256": {
          "step": "quote",
          "pointer": "/sources/0/sha256Utf8"
        },
        "coverage": {
          "step": "coverage",
          "pointer": ""
        },
        "artifact": {
          "step": "artifact",
          "pointer": ""
        }
      }
    },
    {
      "id": "recorded-replay-review",
      "format": "bound-recipe-v1",
      "goal": "Check the supplied causal history, then compare two recorded step traces; produce diagnostic evidence without replaying work.",
      "limitations": [
        "Causal event and replay step identifiers describe different caller-provided records; the service does not prove their correspondence.",
        "The second call is skipped after a causal inconsistency; previously successful calls remain separately consumed.",
        "An equivalent supplied replay trace does not establish task correctness, exactly-once effects or safe live resumption."
      ],
      "exampleInput": {
        "baselineClock": [],
        "events": [
          {
            "id": "event-1",
            "actor": "planner",
            "sequence": 1,
            "parents": [],
            "clock": [
              {
                "actor": "planner",
                "counter": 1
              }
            ]
          },
          {
            "id": "event-2",
            "actor": "worker",
            "sequence": 1,
            "parents": [
              "event-1"
            ],
            "clock": [
              {
                "actor": "planner",
                "counter": 1
              },
              {
                "actor": "worker",
                "counter": 1
              }
            ]
          }
        ],
        "baselineTrace": [
          {
            "id": "step-1",
            "operation": "summarize",
            "request": {
              "text": "hello"
            },
            "outcome": "success",
            "result": {
              "summary": "hello"
            }
          }
        ],
        "candidateTrace": [
          {
            "id": "step-1",
            "operation": "summarize",
            "request": {
              "text": "hello"
            },
            "outcome": "success",
            "result": {
              "summary": "hello"
            }
          }
        ]
      },
      "steps": [
        {
          "id": "causal",
          "operation": "causal-log-check",
          "purpose": "Reject an internally inconsistent supplied event history",
          "input": {
            "baseline": [],
            "events": []
          },
          "bindings": [
            {
              "target": "/baseline",
              "from": {
                "pointer": "/baselineClock"
              }
            },
            {
              "target": "/events",
              "from": {
                "pointer": "/events"
              }
            }
          ],
          "require": [
            {
              "pointer": "/consistent",
              "equals": true
            }
          ]
        },
        {
          "id": "replay",
          "operation": "replay-divergence-check",
          "purpose": "Require an exactly equivalent pair of supplied traces for this review fixture",
          "input": {
            "baseline": [],
            "candidate": []
          },
          "bindings": [
            {
              "target": "/baseline",
              "from": {
                "pointer": "/baselineTrace"
              }
            },
            {
              "target": "/candidate",
              "from": {
                "pointer": "/candidateTrace"
              }
            }
          ],
          "require": [
            {
              "pointer": "/equivalent",
              "equals": true
            }
          ]
        }
      ],
      "outputs": {
        "causalReport": {
          "step": "causal",
          "pointer": ""
        },
        "replayReport": {
          "step": "replay",
          "pointer": ""
        }
      }
    },
    {
      "id": "checkpoint-scope-review",
      "format": "bound-recipe-v1",
      "goal": "Check a supplied checkpoint packet and compare the exact proposed resume payload to a caller-supplied scope receipt; emit reports for separate authoritative review.",
      "limitations": [
        "No agent is resumed and no scope receipt or side-effect receipt is authenticated.",
        "The caller must establish actual authority, current revocation/use state, effect outcomes and safe recovery independently.",
        "Checkpoint effect reconciliation or a scope mismatch stops the review; neither a matching report nor this recipe grants permission."
      ],
      "exampleInput": {
        "checkpoint": {
          "id": "checkpoint-1",
          "workflowId": "workflow-1",
          "revision": 3,
          "consumer": "agent-b",
          "createdAtMs": 0,
          "expiresAtMs": 1000,
          "stateSha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a",
          "artifacts": [
            {
              "id": "plan",
              "sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a",
              "required": true
            }
          ],
          "cursors": [
            {
              "stream": "events",
              "nextSequence": 4
            }
          ],
          "effects": [
            {
              "id": "send-1",
              "requestSha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a",
              "phase": "acknowledged",
              "receiptId": "receipt-1"
            }
          ]
        },
        "resume": {
          "workflowId": "workflow-1",
          "expectedRevision": 3,
          "consumer": "agent-b",
          "asOfMs": 100,
          "state": {},
          "artifacts": [
            {
              "id": "plan",
              "sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a"
            }
          ],
          "cursors": [
            {
              "stream": "events",
              "nextSequence": 4
            }
          ],
          "receipts": [
            {
              "effectId": "send-1",
              "requestSha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a",
              "receiptId": "receipt-1",
              "outcome": "success"
            }
          ]
        },
        "approval": {
          "id": "approval-1",
          "actor": "agent-b",
          "scope": {
            "operation": "resume-workflow",
            "recipient": "local-runner",
            "resource": "workflow-1",
            "purpose": "review-recovery",
            "dataClasses": [
              "workflow-state"
            ]
          },
          "payloadSha256": "9dcc8a7811484d544bfd7ade00a7e69c1517b1c92e7fea94b4bb48044e228840",
          "issuedAtMs": 0,
          "expiresAtMs": 1000,
          "revoked": false,
          "maxUses": 1,
          "priorUses": 0
        },
        "proposalScope": {
          "operation": "resume-workflow",
          "recipient": "local-runner",
          "resource": "workflow-1",
          "purpose": "review-recovery",
          "dataClasses": [
            "workflow-state"
          ]
        }
      },
      "steps": [
        {
          "id": "checkpoint",
          "operation": "checkpoint-handoff-check",
          "purpose": "Check supplied state, artifacts, cursors and effect receipts before scope comparison",
          "input": {
            "checkpoint": {},
            "resume": {}
          },
          "bindings": [
            {
              "target": "/checkpoint",
              "from": {
                "pointer": "/checkpoint"
              }
            },
            {
              "target": "/resume",
              "from": {
                "pointer": "/resume"
              }
            }
          ],
          "require": [
            {
              "pointer": "/matchesCheckpoint",
              "equals": true
            },
            {
              "pointer": "/requiresEffectReconciliation",
              "equals": false
            },
            {
              "pointer": "/authorizationGranted",
              "equals": false
            }
          ]
        },
        {
          "id": "scope",
          "operation": "approval-scope-check",
          "purpose": "Compare the same resume packet to the supplied scope receipt without granting authority",
          "input": {
            "asOfMs": 0,
            "approval": {},
            "proposal": {
              "actor": "",
              "scope": {},
              "payload": {}
            }
          },
          "bindings": [
            {
              "target": "/asOfMs",
              "from": {
                "pointer": "/resume/asOfMs"
              }
            },
            {
              "target": "/approval",
              "from": {
                "pointer": "/approval"
              }
            },
            {
              "target": "/proposal/actor",
              "from": {
                "pointer": "/resume/consumer"
              }
            },
            {
              "target": "/proposal/scope",
              "from": {
                "pointer": "/proposalScope"
              }
            },
            {
              "target": "/proposal/payload",
              "from": {
                "pointer": "/resume"
              }
            }
          ],
          "require": [
            {
              "pointer": "/matchesSuppliedApproval",
              "equals": true
            },
            {
              "pointer": "/authorizationGranted",
              "equals": false
            },
            {
              "pointer": "/identityVerified",
              "equals": false
            }
          ]
        }
      ],
      "outputs": {
        "checkpointReport": {
          "step": "checkpoint",
          "pointer": ""
        },
        "scopeReport": {
          "step": "scope",
          "pointer": ""
        },
        "authorizationGranted": {
          "step": "scope",
          "pointer": "/authorizationGranted"
        }
      }
    },
    {
      "id": "declared-contract-adaptation-review",
      "format": "bound-recipe-v1",
      "goal": "Find common declared target versions, then propose a bounded caller-declared migration path to one of them without contacting agents or running adapters.",
      "limitations": [
        "Every step is a separately authorized and priced call; a later stop does not refund an earlier successful call",
        "Exact opaque identifiers and supplied declarations only; schema compatibility and actual migration behavior are not verified",
        "Common versions are candidates, not a newest-version ranking or agreement by another party",
        "The route is a diagnostic proposal; authorization remains false and no adapter executes"
      ],
      "exampleInput": {
        "offers": [
          {
            "party": "producer",
            "protocol": "task-envelope",
            "versions": [
              "v2",
              "v3"
            ],
            "mediaTypes": [
              "application/json"
            ],
            "capabilities": [
              "digest",
              "cursor"
            ],
            "requiredCapabilities": [
              "digest"
            ],
            "minimumMessageBytes": 1,
            "maximumMessageBytes": 65536,
            "minimumBatchItems": 1,
            "maximumBatchItems": 32
          },
          {
            "party": "consumer",
            "protocol": "task-envelope",
            "versions": [
              "v3"
            ],
            "mediaTypes": [
              "application/json"
            ],
            "capabilities": [
              "digest",
              "cursor"
            ],
            "requiredCapabilities": [
              "digest"
            ],
            "minimumMessageBytes": 1,
            "maximumMessageBytes": 32768,
            "minimumBatchItems": 1,
            "maximumBatchItems": 16
          }
        ],
        "contract": "task-record",
        "sourceVersion": "v1",
        "migrations": [
          {
            "id": "one-two",
            "from": "v1",
            "to": "v2",
            "costUnits": 2,
            "lossy": false
          },
          {
            "id": "two-three",
            "from": "v2",
            "to": "v3",
            "costUnits": 3,
            "lossy": false
          }
        ],
        "maximumCostUnits": 10,
        "maximumSteps": 4
      },
      "steps": [
        {
          "id": "intersection",
          "operation": "contract-capability-negotiate",
          "purpose": "Intersect exact supplied capability declarations",
          "input": {
            "offers": []
          },
          "bindings": [
            {
              "target": "/offers",
              "from": {
                "pointer": "/offers"
              }
            }
          ],
          "require": [
            {
              "pointer": "/compatibleDeclarations",
              "equals": true
            },
            {
              "pointer": "/authorizationGranted",
              "equals": false
            }
          ]
        },
        {
          "id": "route",
          "operation": "contract-version-route",
          "purpose": "Plan a lossless-by-declaration path to a common supplied target version",
          "input": {
            "contract": "",
            "sourceVersion": "",
            "targetVersions": [],
            "migrations": [],
            "allowLossy": false,
            "maximumCostUnits": 0,
            "maximumSteps": 0
          },
          "bindings": [
            {
              "target": "/contract",
              "from": {
                "pointer": "/contract"
              }
            },
            {
              "target": "/sourceVersion",
              "from": {
                "pointer": "/sourceVersion"
              }
            },
            {
              "target": "/targetVersions",
              "from": {
                "step": "intersection",
                "pointer": "/commonVersions"
              }
            },
            {
              "target": "/migrations",
              "from": {
                "pointer": "/migrations"
              }
            },
            {
              "target": "/maximumCostUnits",
              "from": {
                "pointer": "/maximumCostUnits"
              }
            },
            {
              "target": "/maximumSteps",
              "from": {
                "pointer": "/maximumSteps"
              }
            }
          ],
          "require": [
            {
              "pointer": "/manifestValid",
              "equals": true
            },
            {
              "pointer": "/routeFound",
              "equals": true
            },
            {
              "pointer": "/authorizationGranted",
              "equals": false
            }
          ]
        }
      ],
      "outputs": {
        "intersection": {
          "step": "intersection",
          "pointer": ""
        },
        "route": {
          "step": "route",
          "pointer": "/route"
        },
        "authorizationGranted": {
          "step": "route",
          "pointer": "/authorizationGranted"
        }
      }
    },
    {
      "id": "rounded-metric-regression-review",
      "format": "bound-recipe-v1",
      "goal": "Check one explicitly rounded decimal claim, then compare that exact rounded value to a caller-supplied baseline and tolerance.",
      "limitations": [
        "Every step is a separately authorized and priced call; a later stop does not refund an earlier successful call",
        "This compares the rounded report value, not the original unrounded measurement; rounding can hide smaller changes",
        "Baseline, units, direction and tolerance are caller assertions; no experiment, significance test, grading or model promotion occurs",
        "A passed threshold is advisory supplied-number arithmetic and never authorizes deployment or other actions"
      ],
      "exampleInput": {
        "claims": [
          {
            "id": "reported-latency",
            "source": "104.95",
            "claimed": "105.0",
            "decimalPlaces": 1,
            "mode": "half-even"
          }
        ],
        "baseline": "100",
        "maxAbsoluteRegression": "5"
      },
      "steps": [
        {
          "id": "rounding",
          "operation": "numeric-rounding-check",
          "purpose": "Check the supplied reported decimal against its explicit rounding rule",
          "input": {
            "claims": []
          },
          "bindings": [
            {
              "target": "/claims",
              "from": {
                "pointer": "/claims"
              }
            }
          ],
          "require": [
            {
              "pointer": "/consistent",
              "equals": true
            },
            {
              "pointer": "/checkedCount",
              "equals": 1
            },
            {
              "pointer": "/advisoryOnly",
              "equals": true
            }
          ]
        },
        {
          "id": "comparison",
          "operation": "metric-regression-check",
          "purpose": "Compare the exact rounded text, preserving the declared metric direction and tolerance",
          "input": {
            "metrics": [
              {
                "id": "reported-latency",
                "unit": "ms",
                "direction": "lower_is_better",
                "baseline": null,
                "candidate": null,
                "maxAbsoluteRegression": "0"
              }
            ]
          },
          "bindings": [
            {
              "target": "/metrics/0/baseline",
              "from": {
                "pointer": "/baseline"
              }
            },
            {
              "target": "/metrics/0/candidate",
              "from": {
                "step": "rounding",
                "pointer": "/claims/0/expected"
              }
            },
            {
              "target": "/metrics/0/maxAbsoluteRegression",
              "from": {
                "pointer": "/maxAbsoluteRegression"
              }
            }
          ],
          "require": [
            {
              "pointer": "/status",
              "equals": "passed"
            },
            {
              "pointer": "/advisoryOnly",
              "equals": true
            }
          ]
        }
      ],
      "outputs": {
        "rounding": {
          "step": "rounding",
          "pointer": ""
        },
        "comparison": {
          "step": "comparison",
          "pointer": ""
        },
        "advisoryOnly": {
          "step": "comparison",
          "pointer": "/advisoryOnly"
        }
      }
    },
    {
      "id": "joined-record-payloads",
      "format": "bound-recipe-v1",
      "goal": "Join supplied rows against an explicit lookup and encode the resulting provenance-indexed pairs as exact byte-limited JSON bodies.",
      "limitations": [
        "Every step is a separately authorized and priced call; a later stop does not refund an earlier successful call",
        "Exact typed keys and declared cardinality only; no fuzzy matching, source authentication or column merging",
        "The body size applies to the returned body unchanged, excluding headers, compression and actual server limits",
        "This plan creates artifacts only; it sends no request and reserves no queue or quota",
        "The downstream encoder accepts at most 500 rows, below the join operation maximum; all byte/node limits still apply"
      ],
      "exampleInput": {
        "left": [
          {
            "sku": "A",
            "qty": 2
          },
          {
            "sku": "B",
            "qty": 1
          }
        ],
        "right": [
          {
            "code": "A",
            "label": "Adapters"
          }
        ],
        "maxOutputRows": 10,
        "maxUtf8Bytes": 300
      },
      "steps": [
        {
          "id": "join",
          "operation": "records-join",
          "purpose": "Produce typed many-to-one left-join pairs under an explicit output-row cap",
          "input": {
            "left": [],
            "right": [],
            "keys": [
              {
                "left": "/sku",
                "right": "/code"
              }
            ],
            "kind": "left",
            "cardinality": "many-to-one",
            "nullKeys": "never-match",
            "maxOutputRows": 10
          },
          "bindings": [
            {
              "target": "/left",
              "from": {
                "pointer": "/left"
              }
            },
            {
              "target": "/right",
              "from": {
                "pointer": "/right"
              }
            },
            {
              "target": "/maxOutputRows",
              "from": {
                "pointer": "/maxOutputRows"
              }
            }
          ],
          "require": [
            {
              "pointer": "/profile",
              "equals": "typed-records-join-v1"
            }
          ]
        },
        {
          "id": "encode",
          "operation": "json-batch-encode",
          "purpose": "Encode actual joined pairs without flattening, splitting or losing their source indexes",
          "input": {
            "records": [],
            "framing": "json-array",
            "maxUtf8Bytes": 300,
            "maxItemsPerBatch": 500,
            "includeSha256": true
          },
          "bindings": [
            {
              "target": "/records",
              "from": {
                "step": "join",
                "pointer": "/rows"
              }
            },
            {
              "target": "/maxUtf8Bytes",
              "from": {
                "pointer": "/maxUtf8Bytes"
              }
            }
          ],
          "require": [
            {
              "pointer": "/profile",
              "equals": "sorted-json-utf8-batches-v1"
            }
          ]
        }
      ],
      "outputs": {
        "pairs": {
          "step": "join",
          "pointer": "/rows"
        },
        "batches": {
          "step": "encode",
          "pointer": "/batches"
        }
      }
    },
    {
      "id": "checked-localization-payloads",
      "format": "bound-recipe-v1",
      "goal": "Withhold a malformed or incomplete supplied localization bundle, then encode successful entries as exact LF-terminated NDJSON bodies.",
      "limitations": [
        "Every step is a separately authorized and priced call; a later stop does not refund an earlier successful call",
        "The fixed policy requires every target translation, exact placeholder names and repeat counts; fallback is not enabled",
        "A ready bundle is structurally accepted under double-brace-literal-v1, not a linguistic, semantic or security verdict",
        "Texts are not rendered, escaped for HTML or sent to any remote endpoint",
        "The downstream encoder accepts at most 500 entries, below the bundle operation maximum; all byte/node limits still apply"
      ],
      "exampleInput": {
        "source": [
          {
            "id": "welcome",
            "text": "Hello, {{name}}!"
          },
          {
            "id": "save",
            "text": "Save"
          }
        ],
        "target": [
          {
            "id": "welcome",
            "text": "Hola, {{name}}!"
          },
          {
            "id": "save",
            "text": "Guardar"
          }
        ],
        "maxUtf8Bytes": 300
      },
      "steps": [
        {
          "id": "bundle",
          "operation": "localization-bundle-build",
          "purpose": "Require complete source key coverage and exact literal placeholder inventories",
          "input": {
            "format": "double-brace-literal-v1",
            "missing": "error",
            "source": [],
            "target": []
          },
          "bindings": [
            {
              "target": "/source",
              "from": {
                "pointer": "/source"
              }
            },
            {
              "target": "/target",
              "from": {
                "pointer": "/target"
              }
            }
          ],
          "require": [
            {
              "pointer": "/status",
              "equals": "ready"
            },
            {
              "pointer": "/translationVerified",
              "equals": false
            }
          ]
        },
        {
          "id": "encode",
          "operation": "json-batch-encode",
          "purpose": "Retain source order, original text and origin evidence in byte-bounded NDJSON",
          "input": {
            "records": [],
            "framing": "ndjson-lf",
            "maxUtf8Bytes": 300,
            "maxItemsPerBatch": 500,
            "includeSha256": true
          },
          "bindings": [
            {
              "target": "/records",
              "from": {
                "step": "bundle",
                "pointer": "/bundle"
              }
            },
            {
              "target": "/maxUtf8Bytes",
              "from": {
                "pointer": "/maxUtf8Bytes"
              }
            }
          ],
          "require": [
            {
              "pointer": "/profile",
              "equals": "sorted-json-utf8-batches-v1"
            }
          ]
        }
      ],
      "outputs": {
        "bundle": {
          "step": "bundle",
          "pointer": "/bundle"
        },
        "batches": {
          "step": "encode",
          "pointer": "/batches"
        }
      }
    },
    {
      "id": "release-review-packet",
      "format": "bound-recipe-v1",
      "goal": "Propose a declared version and escaped notes, guard the supplied JSONC version scalar, and compose both review artifacts into an inline OCI manifest.",
      "limitations": [
        "Every step is separately priced and authorized; a later failure does not refund an earlier successful call",
        "Commits and their range are caller-selected claims; no code-level impact or release suitability is inferred",
        "A no-bump plan retains the version and produces an empty notes artifact; this packet is for review only",
        "The fixed config pointer is /version; edits preserve all other source text and scalar types",
        "Cross-step byte and syntax limits still apply; a valid first result may exceed the next operation's narrower limits",
        "No filesystem write, commit, tag, upload, registry access, publishing or test execution occurs",
        "The OCI manifest embeds exact file bytes but has no enclosing serialized-manifest digest"
      ],
      "exampleInput": {
        "currentVersion": "1.2.3",
        "preOneBreaking": "major",
        "commits": [
          {
            "id": "c1",
            "message": "feat(api): add CSV export"
          },
          {
            "id": "c2",
            "message": "fix: reset retry counter"
          }
        ],
        "configText": "{\n  // reviewed version\n  \"version\": \"1.2.3\",\n}\n"
      },
      "steps": [
        {
          "id": "plan",
          "operation": "conventional-release-plan",
          "purpose": "Read only the supplied commit messages and explicit 0.x breaking policy",
          "input": {
            "currentVersion": "1.2.3",
            "preOneBreaking": "major",
            "commits": []
          },
          "bindings": [
            {
              "target": "/currentVersion",
              "from": {
                "pointer": "/currentVersion"
              }
            },
            {
              "target": "/preOneBreaking",
              "from": {
                "pointer": "/preOneBreaking"
              }
            },
            {
              "target": "/commits",
              "from": {
                "pointer": "/commits"
              }
            }
          ],
          "require": [
            {
              "pointer": "/revertCancellationInferred",
              "equals": false
            }
          ]
        },
        {
          "id": "rewrite",
          "operation": "jsonc-values-rewrite",
          "purpose": "Require the original version scalar before replacing only its source token",
          "input": {
            "text": "",
            "allowTrailingComma": true,
            "rewrites": [
              {
                "path": "/version",
                "expected": "1.2.3",
                "value": "1.3.0"
              }
            ]
          },
          "bindings": [
            {
              "target": "/text",
              "from": {
                "pointer": "/configText"
              }
            },
            {
              "target": "/rewrites/0/expected",
              "from": {
                "pointer": "/currentVersion"
              }
            },
            {
              "target": "/rewrites/0/value",
              "from": {
                "step": "plan",
                "pointer": "/nextVersion"
              }
            }
          ]
        },
        {
          "id": "compose",
          "operation": "oci-artifact-compose",
          "purpose": "Embed and fingerprint the exact revised configuration and escaped release notes",
          "input": {
            "artifactType": "application/vnd.example.release-review.v1",
            "files": [
              {
                "name": "package.jsonc",
                "mediaType": "application/jsonc",
                "encoding": "utf8",
                "data": ""
              },
              {
                "name": "RELEASE_NOTES.md",
                "mediaType": "text/markdown",
                "encoding": "utf8",
                "data": ""
              }
            ]
          },
          "bindings": [
            {
              "target": "/files/0/data",
              "from": {
                "step": "rewrite",
                "pointer": "/text"
              }
            },
            {
              "target": "/files/1/data",
              "from": {
                "step": "plan",
                "pointer": "/markdown"
              }
            }
          ]
        }
      ],
      "outputs": {
        "nextVersion": {
          "step": "plan",
          "pointer": "/nextVersion"
        },
        "markdown": {
          "step": "plan",
          "pointer": "/markdown"
        },
        "configText": {
          "step": "rewrite",
          "pointer": "/text"
        },
        "manifest": {
          "step": "compose",
          "pointer": "/manifest"
        },
        "sourceMap": {
          "step": "compose",
          "pointer": "/sourceMap"
        }
      }
    },
    {
      "id": "tool-contract-assurance",
      "goal": "Validate and repair a proposed tool result without executing supplied code",
      "steps": [
        {
          "operation": "yaml-to-json",
          "optional": true,
          "purpose": "Convert supplied YAML configuration"
        },
        {
          "operation": "json-schema-check",
          "purpose": "Validate supported schema constraints and get JSON Pointer error paths"
        },
        {
          "operation": "json-patch",
          "purpose": "Apply an explicit reviewed repair patch atomically"
        },
        {
          "operation": "json-schema-check",
          "purpose": "Revalidate after repair"
        },
        {
          "operation": "content-digest",
          "purpose": "Fingerprint the final evidence payload"
        }
      ]
    },
    {
      "id": "rag-evidence-preparation",
      "goal": "Prepare provided HTML/Markdown as traceable, character-bounded retrieval chunks",
      "steps": [
        {
          "operation": "html-to-text",
          "optional": true,
          "purpose": "Extract visible text from supplied HTML without fetching or scripts"
        },
        {
          "operation": "markdown-outline",
          "optional": true,
          "purpose": "Find headings and source sections"
        },
        {
          "operation": "markdown-links",
          "optional": true,
          "purpose": "Collect supported inline/reference links"
        },
        {
          "operation": "pii-redact",
          "optional": true,
          "purpose": "Heuristically remove common patterns; manually review sensitive material"
        },
        {
          "operation": "text-chunk",
          "purpose": "Produce chunks with source offsets; not model-token guarantees"
        },
        {
          "operation": "content-digest",
          "purpose": "Fingerprint original supplied material"
        }
      ]
    },
    {
      "id": "import-cleanup-and-evidence",
      "goal": "Convert incoming records into a checked deterministic import payload",
      "steps": [
        {
          "operation": "csv-parse",
          "purpose": "Parse quoted records"
        },
        {
          "operation": "records-project",
          "purpose": "Select the supported target fields"
        },
        {
          "operation": "records-filter",
          "purpose": "Select explicitly matching records"
        },
        {
          "operation": "records-sort",
          "purpose": "Create a stable review order"
        },
        {
          "operation": "records-aggregate",
          "purpose": "Produce group counts/totals"
        },
        {
          "operation": "json-schema-check",
          "purpose": "Check the final contract"
        },
        {
          "operation": "csv-serialize",
          "optional": true,
          "purpose": "Export spreadsheet-safe CSV"
        }
      ]
    },
    {
      "id": "config-change-review",
      "goal": "Compare supplied configuration/text and apply only explicit updates",
      "steps": [
        {
          "operation": "yaml-to-json",
          "optional": true,
          "purpose": "Normalize configuration syntax"
        },
        {
          "operation": "json-flatten",
          "purpose": "Create JSON Pointer-addressed leaf map"
        },
        {
          "operation": "json-pointer",
          "purpose": "Resolve exact values before changes"
        },
        {
          "operation": "json-patch",
          "purpose": "Apply atomic expected-value tests and changes"
        },
        {
          "operation": "json-canonicalize",
          "purpose": "Produce deterministic review text"
        },
        {
          "operation": "lines-diff",
          "purpose": "Generate bounded line additions/deletions"
        }
      ]
    }
  ],
  "execution": "Client-side separately authorized calls; no static-host or generic recipe execution",
  "releaseSnapshot": {
    "format": "static-release-reference-v1",
    "sourceVersion": "0.29.0",
    "sourceRegistrySha256": "a2b5ec09bf6c38b9d2879d746a4fded374f5928b445377b0270ef6aa8e6cac65",
    "generatedAt": "2026-10-06T15:38:00Z",
    "releaseAcceptance": "not-verified-by-generator",
    "runtimeReadiness": "not-evaluated",
    "livePaymentsVerified": false,
    "indexingVerified": false,
    "apiOrigin": null,
    "notice": "Build-time release reference. Runtime readiness, deployment, payment settlement and external indexing are not evaluated here. Prices are proposed; this file cannot authorize execution or payment."
  }
}
