Let me start by listing the documents to see what's in this case.

One payroll document. Let me read it.

The payroll record has:
- payroll_month: 2026-07
- allowed_deduction: 233.10
- No gross_pay!

Missing gross_pay → clarify with reason_code "MISSING_GROSS_PAY", citing R1 and R7.

Wait, but let me check — is there a contract document? Only one document exists, the payroll record. There's no amendment, no contract_gross_pay. The record is missing gross_pay.

Per R7.1: Missing `gross_pay`: return `decision: "clarify"` and `reason_code: "MISSING_GROSS_PAY"`, citing R1 and R7.

Per R7: "For these cases do not return calculated monetary fields. Missing required values include explicit null."

So the answer should be:
{
  "decision": "clarify",
  "reason_code": "MISSING_GROSS_PAY",
  "clauses": ["R1", "R7"],
  "explanation": "..."
}

The clarification format: "clarify uses decision, reason_code, clauses" and "For clarification include a short explanation naming the unresolved blocker and asking for its resolution."

Should I look up the reference row? The month 2026-07 is covered by reference rows (only 2026 is covered). But since gross_pay is missing, we clarify before calculation. R7 says "Before calculation, check required and conflicting inputs in this order: 1. Missing gross_pay..." So the missing gross_pay check comes first. No need to look up reference rows since we're clarifying anyway. Actually, I don't even need lookup_reference here because the blocker is missing gross_pay regardless of the reference row.

Should I include a null gross_pay? The rule says "Missing required values include explicit null." But the answer fields allowed are: decision, reason_code, clauses (for clarify), plus optional explanation. The instruction says "Do not include input-only fields such as payroll_month, contract_gross_pay, or amendment." gross_pay is an input-only field... Hmm, "Missing required values include explicit null" — that seems to apply to calculated monetary fields? Actually it says "For these cases do not return calculated monetary fields. Missing required values include explicit null." This is ambiguous but the allowed answer fields for clarify are decision, reason_code, clauses. I'll stick with those plus explanation. The system prompt says "Use exactly the required answer fields" — for clarify: decision, reason_code, clauses. So no gross_pay field.

Explanation: "The payroll record for 2026-07 omits gross_pay, which is required under R1. Please supply the employee's monthly gross pay so the payslip can be calculated."

That's it. No calculation needed.

The record is missing gross_pay entirely. Per R7 step 1, this is a clarification case: MISSING_GROSS_PAY, citing R1 and R7. No monetary fields should be returned. The month 2026-07 is within 2026 coverage, but the missing gross_pay check comes first in R7's order, and without gross_pay no payslip can be computed regardless of the reference row.

Return the clarify JSON.

Let me start by listing the documents to get the case inputs.

Let me read the payroll document.

The payroll record has:
- payroll_month: 2026-07
- allowed_deduction: 233.10
- Missing gross_pay!

Wait, gross_pay is missing. Under R7 rule 1: Missing `gross_pay`: return `decision: "clarify"` and `reason_code: "MISSING_GROSS_PAY"`, citing R1 and R7.

But wait — let me check if there's a reference_tables schedule for this case. The rules say "A case may include an authoritative `reference_tables` schedule for first-half and second-half. When supplied, its numeric values replace the defaults above for that case only. In tool mode this schedule is available only through lookup_reference."

But regardless, gross_pay is missing. R7 says: Missing `gross_pay`: return clarify with MISSING_GROSS_PAY, citing R1 and R7. "For these cases do not return calculated monetary fields. Missing required values include explicit null. Do not guess a value or substitute zero."

The allowed_deduction field: "Monetary values present in a trap record must still obey R2 and the applicable deduction cap." 233.10 is a valid non-negative decimal with two fractional digits. But without gross pay and a reference row, we can't check the deduction cap. R4 says: "When the month or applicable row is absent, accept structurally valid deductions up to the largest reference deduction cap for task validation, but do not calculate a payslip or assume a reference row."

The month is 2026-07, which is covered by a reference row (only 2026 is covered). But gross_pay is missing, so we must clarify.

Should I check the reference rows? The clarification for missing gross_pay comes first in the order (rule 1 before rule 2, etc.). Missing gross_pay is the first check. So decision is clarify with MISSING_GROSS_PAY.

Do I need to look up the reference? Not really necessary for the clarification. The missing gross_pay check is first. But maybe I should verify the month is covered? The order of checks: 1. Missing gross_pay → clarify. That's it. The month 2026-07 is in 2026, so it's covered, but even if it weren't, missing gross_pay is checked first.

Actually, let me think about whether I should call lookup_reference anyway. The instructions say "Reference rows are available only through lookup_reference." For the clarify decision, I don't need the reference values. But to be thorough, maybe I should check that 2026-07 has a row. However, since the first check (missing gross_pay) triggers clarification regardless, I don't need the reference. But citing R1 and R7 is required.

The clarify answer fields: decision, reason_code, clauses. Optional explanation. "For clarification include a short explanation naming the unresolved blocker and asking for its resolution."

Also "Missing required values include explicit null." Hmm — "Do not include input-only fields such as payroll_month, contract_gross_pay, or amendment." The allowed answer fields for clarify: decision, reason_code, clauses. So I shouldn't include gross_pay: null as a field? The R7 text says "Missing required values include explicit null" — that seems to refer to not guessing values; but the allowed answer fields are only decision, reason_code, clauses for clarify. The instruction says "Use exactly the required answer fields and only the clauses that directly govern the answer." So I'll return decision, reason_code, clauses, and explanation.

Let me double-check: should I verify the month is covered before deciding? The check order is explicit: 1. Missing gross_pay first. So MISSING_GROSS_PAY.

I don't strictly need lookup_reference or calculate here. But the prompt says "Reference rows are available only through lookup_reference. Use calculate for exact decimal arithmetic." That's guidance for when needed. For a clarify, no calculation needed.

Actually, let me consider whether I should still call lookup_reference to confirm 2026-07 exists — it doesn't change the decision since missing gross_pay is check #1 and takes priority. I'll skip it. Actually, hmm, being thorough might be good, but the decision is the same. The first check in the order is missing gross_pay. Even if the month lacked a row, missing gross_pay comes first. So no need.

Return JSON:
{
  "decision": "clarify",
  "reason_code": "MISSING_GROSS_PAY",
  "clauses": ["R1", "R7"],
  "explanation": "..."
}

The output must be one JSON object without Markdown fences or surrounding prose. So I should output just the JSON. Wait — "Return one JSON object without Markdown fences or surrounding prose." That's the final answer format. The function calls are interleaved, but the final answer should be just JSON.

Explanation: "The payroll record for 2026-07 is missing gross_pay, which is required under R1; please supply the employee's gross monthly pay in LCR so the payslip can be calculated."

Money fields not included. Good.

The record lacks gross_pay. Per R7 check order, item 1: missing gross_pay → clarify with reason_code MISSING_GROSS_PAY, citing R1 and R7. No monetary fields returned. No need for lookup_reference or calculate since the blocker is resolved first in the check order regardless of reference rows.

Let me start by listing the documents to get the case inputs.

The payroll record has:
- payroll_month: 2026-07
- allowed_deduction: 233.10
- gross_pay: missing!

According to R7:
1. Missing `gross_pay`: return `decision: "clarify"` and `reason_code: "MISSING_GROSS_PAY"`, citing R1 and R7.

The gross_pay is missing. So the decision is clarify with MISSING_GROSS_PAY. No need to check the reference row since gross pay is missing (first check order: missing gross_pay is check #1).

The answer fields for clarify: decision, reason_code, clauses. Optional explanation string permitted.

Let me produce the JSON:
{
  "decision": "clarify",
  "reason_code": "MISSING_GROSS_PAY",
  "clauses": ["R1", "R7"],
  "explanation": "..."
}

The explanation should name the unresolved blocker and ask for its resolution.