Let me start by listing the documents to see what inputs are available.

One document: the payroll record. Let me read it.

The payroll record has payroll_month "2026-01" and allowed_deduction "345.85", but no gross_pay. Wait, let me check: the record contains payroll_month and allowed_deduction. Missing gross_pay.

Per R7 order:
1. Missing gross_pay → clarify with reason_code "MISSING_GROSS_PAY", citing R1 and R7.

Wait, but should I check the reference row first? The order in R7 is:
1. Missing gross_pay → MISSING_GROSS_PAY
2. Missing payroll_month → MISSING_PAYROLL_MONTH
3. Month without reference row → NO_APPLICABLE_REFERENCE
4. Conflicting gross_pay → CONFLICTING_GROSS_PAY

The record is missing gross_pay. So decision is clarify, reason_code MISSING_GROSS_PAY, citing R1 and R7.

Hmm, but wait — maybe I should double check whether there's more info. The document only has that record. There's no amendment, no contract_gross_pay. So gross_pay is missing.

Actually, should I even bother with lookup_reference? The clarification for missing gross_pay comes first in the order. The month 2026-01 is covered by reference rows (only 2026 is covered), so even if I checked, it wouldn't change the decision. But the rules say to check in order; missing gross_pay is checked first. I don't strictly need the reference row for this decision. But let me consider: R7 says "Before calculation, check required and conflicting inputs in this order: 1. Missing gross_pay: return decision: clarify and reason_code: MISSING_GROSS_PAY, citing R1 and R7."

So the answer is clarify with MISSING_GROSS_PAY.

The instructions say: "For clarification include a short explanation naming the unresolved blocker and asking for its resolution." Also "Missing required values include explicit null." Hmm — "Missing required values include explicit null." That might mean when returning calculated fields, missing values should be explicit null? But also "For these cases do not return calculated monetary fields." So I should not return monetary fields. The allowed answer fields for clarify: decision, reason_code, clauses. Plus optional explanation.

Actually wait, "Missing required values include explicit null" — this seems to conflict with "do not return calculated monetary fields". I think the safe approach: return decision, reason_code, clauses, and explanation. Maybe include gross_pay: null? The allowed answer fields are "calculate uses decision, currency, gross_pay, employee_contribution, allowed_deduction, taxable_pay, income_tax, net_pay, clauses; retrieve uses decision, field, value, clauses; clarify uses decision, reason_code, clauses. An optional explanation string is permitted."

So clarify uses decision, reason_code, clauses (and optional explanation). I should not add gross_pay: null since that's not in the clarify field set. The "explicit null" note likely refers to not guessing values — i.e., if a value is missing, it's null, not zero; but since we don't return monetary fields for clarify, we just don't include them.

Do I need lookup_reference? The decision doesn't depend on the reference row since missing gross_pay is checked first. But to be thorough, maybe I could verify the month is covered... Actually, the order of checks matters: missing gross_pay is checked first, so I return that regardless. I don't need the reference lookup. But the task says "Reference rows are available only through lookup_reference" — that's just telling me how to get them if needed. Since the decision is clarify on missing gross_pay, no calculation is needed.

Hmm, but let me be careful: is it possible the record's allowed_deduction matters? R4: "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." That's about validation when the row is absent. Here the month 2026-01 is present and covered (only 2026 covered). But gross_pay is missing, so no calculation.

The answer: 
{
  "decision": "clarify",
  "reason_code": "MISSING_GROSS_PAY",
  "clauses": ["R1", "R7"],
  "explanation": "The payroll record for 2026-01 lacks gross_pay..."
}

Money must be strings with two decimals — not applicable here since no monetary fields returned.

Let me write the explanation: "The payroll record for 2026-01 supplies allowed_deduction but no gross_pay, which is required under R1; please provide the employee's monthly gross pay so the payslip can be calculated."

Should I do any tool calls for verification? I could look up the reference to confirm 2026-01 is covered, but it's unnecessary for the decision. Actually, being thorough might be good — but the check order says missing gross_pay is first. I'll just answer. Actually, let me consider whether to call lookup_reference anyway to confirm the month has a row — if it didn't, the reason would still be MISSING_GROSS_PAY because it's checked first. So no need.

One JSON object, no markdown fences, no surrounding prose. Wait — the system prompt says "Return one JSON object without Markdown fences or surrounding prose." But I'm also supposed to make tool calls. The final answer should be just the JSON object. Let me produce it.

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

The payroll record has:
- payroll_month: "2026-01"
- allowed_deduction: "345.85"
- No gross_pay!

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

Gross pay is missing. So the answer is clarify with MISSING_GROSS_PAY, citing R1 and R7.

The allowed_deduction is present but gross pay is missing. Per R7 step 1, missing gross_pay comes first. Also per R7, "For these cases do not return calculated monetary fields. Missing required values include explicit null." Hmm — "Missing required values include explicit null" — I think this means the JSON should include explicit null for missing required values? Wait, but the answer fields for clarify are: decision, reason_code, clauses. So no monetary fields. The "explicit null" refers to... Actually the allowed answer fields for clarify: decision, reason_code, clauses. An optional explanation string is permitted. So I shouldn't include gross_pay: null? The instruction says "Do not include input-only fields such as payroll_month, contract_gross_pay, or amendment." And "Use exactly the required answer fields". For clarify: decision, reason_code, clauses. So the JSON is:

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

The explanation should name the unresolved blocker and ask for its resolution. The blocker: gross_pay is missing from the payroll record for 2026-01; provide the gross pay amount.

Do I need to check the reference row? No — R7 order: missing gross_pay is checked first, before reference row checks. So no need to call lookup_reference. The month is 2026-01 which is covered by 2026 rows anyway, but the check order means missing gross_pay triggers first.

Should I call lookup_reference anyway? Not needed. The clarification is decided by R7 step 1. No calculation needed.

Let me produce the final JSON without markdown fences, no surrounding prose. Wait — the system prompt says "Return one JSON object without Markdown fences or surrounding prose." So my final answer must be just the JSON object. But I've been calling tools with prose in between... The final response should be the JSON object only.

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

Clauses: ["R1", "R7"].

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

The payroll record has:
- payroll_month: "2026-01"
- allowed_deduction: "345.85"
- gross_pay: MISSING

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

The record is missing gross_pay. So decision is clarify with reason_code MISSING_GROSS_PAY, citing R1 and R7.

The allowed_deduction is present but that doesn't matter — missing gross_pay is the first check. Also, "Missing required values include explicit null." So I should include gross_pay as null? The rules say "Missing required values include explicit null." Hmm — the answer fields for clarify are: decision, reason_code, clauses. The instruction says "Use exactly the required answer fields and only the clauses that directly govern the answer." And "Do not include input-only fields such as payroll_month, contract_gross_pay, or amendment."

But R7 says "Missing required values include explicit null." That suggests including gross_pay: null in the answer? Hmm. The allowed answer fields list: "clarify uses decision, reason_code, clauses." So the required fields for clarify are decision, reason_code, clauses. The statement "Missing required values include explicit null" might refer to including missing values as explicit null in... hmm, ambiguous. But the answer format says clarify uses decision, reason_code, clauses — so I should stick to those three fields. However, "Missing required values include explicit null" — maybe it means if I include a field, missing values should be null rather than omitted or zero. But the safest interpretation: clarify uses decision, reason_code, clauses. An optional explanation string is permitted.

Actually, let me re-read: "For these cases do not return calculated monetary fields. Missing required values include explicit null. Do not guess a value or substitute zero." This seems to say that missing required values should be represented as explicit null (not omitted, not zero). But the answer field spec says clarify uses decision, reason_code, clauses. There's tension. I think the explicit null instruction applies to fields that would otherwise be monetary fields — i.e., if you return monetary fields, missing ones should be null. But it also says "do not return calculated monetary fields." Hmm.

Given "Use exactly the required answer fields" and "clarify uses decision, reason_code, clauses", I'll return just those three plus an explanation. Actually wait — maybe I should include gross_pay: null to be explicit? The instruction "Missing required values include explicit null" is part of R7's paragraph about clarification cases. It could mean the answer should include the missing value as explicit null. But the answer format rule says clarify uses decision, reason_code, clauses — exactly those. Including extra fields might violate "Use exactly the required answer fields."

Hmm, but "An optional explanation string is permitted." So allowed fields: decision, reason_code, clauses, explanation (optional). I'll not add gross_pay: null since the format says clarify uses exactly decision, reason_code, clauses. Actually, let me reconsider: "Missing required values include explicit null" — this might mean in the JSON, where a required value is missing, include it as explicit null rather than omitting. That would mean adding "gross_pay": null. The phrase "include explicit null" strongly suggests including a null value in the output.

But then "Do not include input-only fields such as payroll_month..." — gross_pay is not listed as an input-only field to exclude. The excluded fields are payroll_month, contract_gross_pay, amendment. gross_pay is an answer field (for calculate). So including "gross_pay": null for a clarify case seems consistent with "Missing required values include explicit null."

Hmm, this is genuinely ambiguous. Let me weigh: The system prompt says "Allowed answer fields: calculate uses decision, currency, gross_pay, employee_contribution, allowed_deduction, taxable_pay, income_tax, net_pay, clauses; retrieve uses decision, field, value, clauses; clarify uses decision, reason_code, clauses."

So for clarify, the allowed fields are decision, reason_code, clauses. "Missing required values include explicit null" — in the context of R7: "For these cases do not return calculated monetary fields. Missing required values include explicit null." I think this means: don't return calculated monetary fields; where a required value is missing, represent it as explicit null (rather than omitting or guessing). This could apply to the clarify answer — include gross_pay: null.

But the "Allowed answer fields" spec says clarify uses decision, reason_code, clauses. If I add gross_pay: null, is that violating "exactly the required answer fields"? The phrase "Use exactly the required answer fields" suggests not adding extra fields.

Hmm. Given the conflict, I think the safest is to follow the explicit field list: decision, reason_code, clauses, plus optional explanation. The "explicit null" instruction likely refers to cases where the schema would include a value but it's missing — but since clarify's schema doesn't include monetary fields, there's nothing to null. Actually wait, re-reading again: "For these cases do not return calculated monetary fields. Missing required values include explicit null. Do not guess a value or substitute zero."

I think this trio means: in clarify cases, don't compute monetary fields; if you must reference missing required values, use explicit null; don't guess. Since the clarify schema doesn't have monetary fields, I'll just use decision, reason_code, clauses, explanation.

Hmm, but actually, maybe the intent is that the clarify answer should include the missing fields as null. Like gross_pay: null. Many such tasks do include nulls. Let me think about which is more likely to be scored correct.

The instruction "Use exactly the required answer fields and only the clauses that directly govern the answer" — this is from the system prompt (the "supplied rules" preamble). It says clarify uses decision, reason_code, clauses. So the required fields for clarify are exactly those three. Adding gross_pay: null would be an extra field not in the list. I'll go with just the three fields plus explanation.

Decision: clarify, reason_code: MISSING_GROSS_PAY, clauses: ["R1", "R7"], explanation: the record lacks gross_pay; ask for it.

Per R7 order: check 1 is missing gross_pay → MISSING_GROSS_PAY. Even though payroll_month is present (2026-01, covered), the first check fails. So reason_code is MISSING_GROSS_PAY.

Do I need to check the reference row? No — the first check triggers. But I could note that 2026-01 is covered; doesn't matter.

Output format: "Return one JSON object without Markdown fences or surrounding prose." So the final answer must be a raw JSON object. But I also need to make tool calls. The final response should be just the JSON object.

Let me write:

{"decision": "clarify", "reason_code": "MISSING_GROSS_PAY", "clauses": ["R1", "R7"], "explanation": "The payroll record for 2026-01 is missing gross_pay; please supply the employee's monthly gross pay so the payslip can be calculated."}

Money as strings with two decimals — not applicable here. No monetary fields returned.

Should clauses include R7 only or R1 and R7? R7 says "return decision clarify and reason_code MISSING_GROSS_PAY, citing R1 and R7." So clauses: ["R1", "R7"].

I'm fairly confident. Final answer: JSON object only.