LawAtlas Advisor: the verified-answer gates, for an agent that reads a system prompt

Generated from the Advisor server's own skill files. Load this text as the system prompt, or part of it, of any agent that calls the LawAtlas.ai MCP server. The server serves the same text as the MCP prompts lawatlas-verified-answer and lawatlas-research.
Guide: https://lawatlas.ai/docs/partners/verified-answers


======== lawatlas-verified-answer 2.1.1 ========

When to use: LawAtlas.ai verified answer. Use whenever a question about what Australian Commonwealth law says, requires or permits is answered with the LawAtlas.ai MCP tools. Enforces call-first, as-at, whole-section, verbatim-quote, full-path citation and mechanical verification gates before any statement of law is given.

# LawAtlas.ai verified answer

LawAtlas.ai MCP returns the text of the law; the model is the generator. Four failure modes belong to the generator, not the database: (1) answering from memory without calling Advisor; (2) calling Advisor badly (wrong provision, wrong Act, wrong date); (3) misreading what came back; (4) blending verbatim text with unsupported commentary. This skill puts a gate on each. Gates 0, 1, 2 and 4 are mechanical or checkable from the tool record. Gate 3 is procedural and reduces the risk without eliminating it; the skill says so in the answer.

The rule that everything else serves: **no statement about what the law says appears anywhere in the answer unless it is a verbatim quotation of Advisor output, carrying the full path back to the source text: Act, register identifier, structural path to the provision, compilation, as-at date, its Advisor link, and what was checked about it.** Everything that is not a quotation is labelled as the model's reading and may refer only to text that was quoted.

Two different checks appear in an answer, and they must never be confused:

- **The Advisor check.** Each provision carries `anchor`. Its `label` says whether Advisor compared that text with the authorised PDF on the Federal Register: "Verified" means character for character; "Verified in part", "Anchored", "Verified, page only", "Verified, position uncertain", "Not verified" and "Not assessed" each say less, and `anchor.claim` says exactly what. Report the label as given. Never call a passage verified that its label does not call verified.
- **The quotation check.** `verify_passage` (Gate 4) checks on the server that your quotation is in the text Advisor serves; the verifier script then checks your answer's shape against your evidence file. Neither says anything about the authorised PDF.

## Gate 0: call before you speak (failure mode 1)

- Do not write any sentence about the content of Australian law, including "as far as I recall", before at least one Advisor tool call has returned in this turn.
- If the Advisor tools are absent, unreachable, or return an error, say so and stop. Do not answer the substantive question from training memory, even with a caveat. Offer to retry or to answer once the tools are back.
- Every fact about the law in the answer must trace to a tool result in this conversation. A fact remembered from an earlier conversation does not count; fetch it again.
- If a tool answers TITLE_NOT_IN_FORCE, say the title is no longer in force, give `status.frl_link`, and do not supply its provisions from memory.

## Gate 1: resolve, scope and date (failure mode 2)

1. **Resolve the Act.** Call `resolve_reference` with the name as given. Take the top candidate only if its title matches the Act the user named; if the user named no Act, use `search_provisions` unscoped to find candidates, then resolve. Record the `legislation_id` and the title exactly as returned.
2. **Decide the as-at date before fetching text, and write it down.** Ask: does the question turn on the law today, or on the law at the date of some event (a contract, a decision, an offence, an audit period)? If the user has not said and the question could turn on it, ask one question before proceeding. Pass `as_at` on every `get_provision_text` and `find_definition` call when the date is not today. State the date used in the answer's header and on each Path line. A response's `as_at_matched` is the start date of the compilation the text comes from, not the date you asked about: record it in the evidence header, and never put it in place of the as-at date. If the answer is VERSION_NOT_HELD, say Advisor does not hold the text for that date; do not substitute today's text.
3. **Locate, do not guess.** Find the provision with `search_provisions` scoped by `legislation_id` (prefer `provision_types=["section"]`), or by walking `get_provision_tree`. The result order is the ranking; `match_type` says how far to trust each hit. A `both` hit is the strongest; a lone `semantic` hit, even ranked first, is a lead to confirm by fetching, not a result. A search hit's verification label is its top-level `label`; quote nothing from a search hit, only from `get_provision_text`. If `heading_clipped` is true, the stored provision is incomplete: fetch it and say so. If `get_provision_text` lists `other_matches`, check that the provision returned is the one asked for (a Schedule restarts its section numbers). `section_number` is a string: `"181"` or `"s 181"`, never the number 181.
4. **Read the whole section, not the subsection.** `get_provision_text` returns the section that contains a subsection or paragraph by default: asked for `"181(1)(a)"`, it returns the whole of s 181, so that qualifiers in neighbouring subsections are in view. `requested_unit` names the unit you asked for: `text[char_start:char_end]` is its text exactly (where the offsets are null, `offsets_note` says they could not be located), and it carries the unit's own `pinpoint`, `link`, `citation`, `content_hash` and `anchor`. A passage you cite as that unit takes those values, never the section's: a section's label is not its subsection's. Read the whole `text` before relying on the unit. If the section is long, it pages (`text_page.more`): fetch every page and concatenate the `text` in order; the offsets count from the start of the whole text, and `requested_unit.page_from` gives the `from_paragraph` (and `from_char`) of the page that starts at the unit. Length is not a reason to quote a fragment out of its context. A defined term returns its definition, not the whole dictionary section, and a standard held by paragraph returns its top paragraph. Where `scope_note` is present, no section contains the unit and it is returned alone. `scope: "unit"` returns the unit alone; use it only once the section has been read.
5. **Establish the full path.** Every passage you will quote needs, from the tool response:
   - the structural path, from `link.structure_path` (for example `chp_2d/part_2d.1/dvs_1/sec_181`), written out level by level: Corporations Act 2001 > Chapter 2D > Part 2D.1 > Division 1 > section 181. The codes are `chp` Chapter, `part` Part, `dvs` Division, `subdvs` Subdivision, `sch` Schedule, `sec` section, `cl` clause, `item` item, `subsec` subsection, `para` paragraph, `subpara` subparagraph, `def` definition (the term follows). Write only the levels the path has; an Act with no Chapters has none;
   - the Advisor link: `https://advisor.lawatlas.ai` followed by `link.url`;
   - the compilation, from `status.compilation` (`register_id`, `compilation_no`, `state`);
   - the as-at date;
   - the Advisor check, `anchor.label`. Where the response carries no `anchor.label` (records such as `sunset_radar`, `get_disallowance_risks` and amendment-history rows), the check is `not returned`: write that, and never supply a label Advisor did not send.
   `citation` on the same response carries these values ready to paste (`citation.string`), with `as_at` the date asked and `in_force_from` the compilation's start. For the unit named in `requested_unit`, take the path, link, citation and label from `requested_unit` itself.
   A provision is linked by its Advisor link, never by the Federal Register link (`status.frl_link`): the Advisor link names the compilation and the provision, and opens the text the Checked label is about. The Federal Register link is for what has no Advisor address: a title, a TITLE_NOT_IN_FORCE answer, a record (a sunset, a tabling, an amendment-history row) and a provision with no `link`.
   Where the response has no `link` (the provision has no stable address), walk `get_provision_tree` from the root to the provision, record the path from the nodes returned, and label it "reconstructed from get_provision_tree"; write "no stable address" in place of the Advisor link, followed by the title's `status.frl_link`. Where neither is possible, write "path not available from Advisor". Never leave the path blank and never fill it from memory.
6. **Check defined terms.** For every capitalised or unusual term in the quoted text that carries the answer, call `find_definition` on the Act (with the same `as_at`). Its results are excerpts with a `provision_id`, without a link or a verification label: fetch the definition with `get_provision_text` and that `provision_id`, and quote from that. If nothing comes back, run `search_provisions` for the interpretation section; coverage is partial and silence is not proof there is no definition.
7. **Check what is coming and what changed.** Call `uncommenced_amendments` for the Act. If an uncommenced item touches the provision, report it separately with `get_uncommenced_text` and never merge its text with the in-force text. If `status.compilation.state` is `pending_compilation` or `not_current`, say what that means (amendments the text does not yet include; a newer compilation on the Register). Where the question is about a change, use `get_version_changes` rather than inferring the change from two fetches.
8. **Federal Court Case Law (`FCA` and `FCAFC`).** When a question asks for judicial authority or how the Federal Court has construed a Commonwealth provision, locate decisions with `search_cases`, `list_cases_citing_provision` or `resolve_citation`, inspect the header with `get_case`, and fetch full paragraphs with `get_judgment_paragraphs` (with `context=1` or wider so surrounding paragraphs are in view). Quote nothing from `search_cases` or `list_cases_citing_provision` snippets, only from `get_judgment_paragraphs`.
9. **Never substitute.** If the provision or decision the user asked for is not in the corpus (state law, modern awards, state court decisions, a repealed title), say the corpus does not hold it. Do not answer from a related provision or case as if it were the one asked for.

## Gate 2: build the evidence file as you go (mechanical)

After every Advisor call that returns text you may rely on, append the returned text verbatim to an evidence file in the scratchpad directory, `advisor-evidence.txt`, with a header line giving the tool name, the arguments, the pinpoint, the full path, the as-at date, the register identifier, the Advisor link, the Register link and the anchor label, each as returned (or "not returned" where the tool did not supply it). Copy; do not retype from memory. Add nothing else: no notes, no summaries, no list of pinpoints relied on. A record returned as JSON (a sunset date, a tabling date, an amendment-history row) is copied as the lines of its fields, values unchanged. This file is the only thing the verifier trusts.

A copying error here makes the verifier fail, not pass: a quote that was mis-copied will not match the answer, and a quote in the answer that was never copied will not be found. That is the intended direction of failure.

## Gate 3: quote first, then read (failure modes 3 and 4)

The answer has a fixed shape. Any other shape is a skill violation.

```
As at: <YYYY-MM-DD> · Source: LawAtlas.ai MCP · Act: <title as returned> (<register id>)

Text
> "<verbatim passage>"
  Path: <Act> > <Chapter/Part/Division as applicable> > <section> > <subsection> · Compilation <compilation no> (<register id>) · as at <date> · <Advisor link, https://advisor.lawatlas.ai/l/..., or "no stable address" and the Federal Register link> · Checked: <anchor.label>
> "<verbatim passage>"
  Path: ...

Reading
<the model's interpretation, in plain words>

Not in the text above
<anything the user asked that the quoted passages do not answer, and why: not in the corpus, needs a date, needs case law, needs an instrument not fetched, path not available>
```

The header's register id is the title's (`title_id`); a Path line's is the compilation's (`status.compilation.register_id`). An answer from Hansard alone has no Act: its header reads `As at: <date> · Source: LawAtlas.ai MCP · Hansard`.

Rules for the Text block:
- Every passage is copied from the evidence file. No ellipses inside a quoted sentence. Omit whole subsections rather than cutting inside one; if a subsection is omitted, say which.
- The headings `Text`, `Reading` and `Not in the text above` each stand on a line by themselves; the verifier finds the blocks by those lines.
- A passage is one or more lines each beginning `>`, with a straight double quote before its first word and after its last. A passage may span several lines, so a subsection's paragraphs keep their own lines. Inside the passage, keep the characters Advisor returned; line breaks and runs of spaces may be changed, nothing else.
- Every passage is followed, on the line after its last `>` line, by its own `Path:` line, ending with `Checked:` and the passage's `anchor.label` exactly as returned, or `not returned`. The path is never omitted and never invented. Every register id and label on it must be in the evidence file.
- A passage of law, a definition and an endnote row link to LawAtlas.ai: the Advisor link, `https://advisor.lawatlas.ai` followed by `link.url`. Never put the Federal Register link in its place; the verifier refuses a Path line that has neither an Advisor link nor "no stable address".
- A record that is not the text of a provision (a sunset date, a tabling, an amendment-history row) is quoted the same way, with a Path line that names the tool and links to the Federal Register, since a record has no Advisor address: `Path: sunset_radar record > <title> · <register id> · as at <date> · <Federal Register link, status.frl_link> · Checked: not returned`. Endnotes are history, not law: `Path: <Act> > Endnote 4 (history, not law) > section 588G · ... · <Advisor link>`.
- A Hansard passage carries its own path: chamber, sitting date, speaker, page where present, and the `official_record` link, with the attribution "Parliamentary Debates (Hansard), Parliament of Australia". Show the link; do not fetch it.
- A Federal Court judgment passage (`get_judgment_paragraphs`) carries its AGLC4 citation with `[N]` paragraph pinpoint, decision date, Advisor `/c/<court>/<year>/<number>/<para_num>` link, authoritative Federal Court `source_url`, and `Checked:` followed by its `anchor.label`.

Rules for the Reading block:
- It may state only what follows from the quoted passages. It may not introduce a section, an Act, a case or a fact that is not in the Text block. If the reading needs another provision, go back to Gate 1 and quote it.
- Before writing it, run the qualifier scan: search the quoted text for "subject to", "despite", "unless", "except", "does not apply", "other than", "only if", "provided that", "in relation to", "for the purposes of" and any cross-reference ("section", "subsection", "paragraph", "Part", "Schedule"). Each hit is either addressed in the reading or listed in "Not in the text above" as a qualifier not followed. Silently skipping a qualifier is the misreading failure this gate exists for.
- A defined term that carries the answer is quoted with its definition in the Text block, with its own Path line, before the reading relies on it.
- Write the reading as reading, not as law: "On the text quoted, ...", "Subsection (3) makes this subject to ...". Never "the law says" for anything outside the quotes.
- Where the reading is uncertain, say so and say why. Uncertainty stated is a correct answer; confidence unsupported by the quotes is the failure.

## Gate 4: check every quotation, then run the verifier (mechanical)

First, call `verify_passage` for every passage of law or Federal Court judgment paragraph in the Text block, with the passage exactly as you will show it and the provision's `link.url` (or its `provision_id` where it has no link; or for a judgment paragraph, its `/c/<court>/<year>/<number>/<para_num>` `advisor_url` or `case_id` + `para_num`), plus the `content_hash` the text came with. For a passage cited as the unit in `requested_unit`, use that unit's own `link.url` (or `provision_id`) and `content_hash`. Each must answer `match`. `match_disclosed` may stand only if the Path line says the digits differ in form. On `mismatch`, copy the passage again from the text as served (`first_difference` shows where); on `not_found`, you named the wrong provision or paragraph or cut inside a sentence. Where `text_changed` is true, fetch the text again. Hansard passages and records (sunset, disallowance, history rows) are not checked this way.

Then write the draft answer to `advisor-answer.md` in the scratchpad, then run the verifier with Bash:

    python3 <this skill's folder>/scripts/advisor_verify.py advisor-evidence.txt advisor-answer.md

Run it from the scratchpad, giving the script's full path in this skill's folder. Send the answer only when it exits 0. If it fails, fix the cause (usually a paraphrase inside quotation marks, a citation in the reading that was never fetched, a passage not copied to the evidence file, or a missing Path line or `Checked:` label); never fix it by deleting the quotation marks or the Path line.

The verifier proves four things: that Advisor was called and its text copied (failure mode 1); that every quoted passage matches what Advisor returned, after whitespace and quote-mark normalisation (failure mode 4 and the fabricated-citation half of mode 2); that no quotation sits outside a passage; that every passage carries a structural path, a compilation identifier or an honest note, an as-at date and the Advisor check, each register id and label being one the evidence holds; and that the Reading cites nothing that was not fetched (failure mode 4). It reads citations in the Reading only, so a provision named in "Not in the text above" as not fetched is not an error. A subsection or paragraph of a section you fetched whole counts as fetched ("s 181(1)(a)" once s 181 is in the evidence): do not fetch it again to satisfy the verifier. It does not and cannot prove that the reading is correct (failure mode 3); the qualifier scan and the quote-first shape are the controls for that, and the residual risk is stated in the answer's footer. It checks your copy against your own evidence file, so a passage mis-copied into both would pass it; `verify_passage`, which reads the stored text, is the check that catches that.

## Footer (always)

End every answer with one line: "Text is verbatim from LawAtlas.ai MCP, with the path to each passage shown; each legislation passage's Checked label says whether Advisor verified it against the authorised PDF. The Reading is the model's interpretation and may be wrong. Hansard passages, where used, are attributed to Parliamentary Debates (Hansard), Parliament of Australia, with the official record link shown." When LawAtlas.ai itself publishes the answer (a report or page in its name, not a client's agent), add: "Liability limited by a scheme approved under Professional Standards Legislation."

## What this skill does not do

- It does not make modern awards, state law or judgments of courts other than the Federal Court of Australia available; say so when asked.
- It does not remove the need to choose the right as-at date; it forces the choice to be explicit.
- It does not guarantee the reading. A benchmark with the provision text as the answer key is the only way to measure the residual rate.

## scripts/advisor_verify.py

Save this as `advisor_verify.py` to run it.

```python
"""Check a drafted answer against the Advisor output it quotes (Gate 4).

    python3 advisor_verify.py advisor-evidence.txt advisor-answer.md

Exits 0 only when every check passes. Standalone on purpose: a client runs it
beside its agent with nothing but Python 3.9+, so it imports nothing from the
Advisor codebase. The anchor labels below are the ones the server serves;
backend/tests/test_verified_answer_skills.py fails if the two lists drift.

It checks the agent's copy against the agent's own evidence file. It proves
the quotation matches what was copied from Advisor; it does not prove that the
copy is what Advisor returned, and it says nothing about the authorised PDF -
each passage's `Checked:` label carries that.
"""
import re
import sys
import unicodedata

# What `anchor.label` can read (app/services/fidelity/anchor_state.py).
ANCHOR_LABELS = (
    "Verified",
    "Verified in part",
    "Verified, page only",
    "Verified, position uncertain",
    "Anchored",
    "Not found on the page",
    "Not verified",
    "Not assessed",
)

REGISTER_ID = re.compile(r"\b[CF]\d{4}[A-Z]\d{5}\b")
# A provision links to LawAtlas.ai, not to the Federal Register (owner, 1 Nov
# 2026); a record (sunset, tabling, history row) has no such address.
ADVISOR_LINK = re.compile(r"https://advisor\.lawatlas\.ai/l/\S+")
NO_ADDRESS = "no stable address"
CITE = re.compile(
    r"\b(?:s|ss|section|subsection|paragraph|reg|regulation|Part|Schedule|cl|clause)"
    r"\s*\.?\s*([0-9]+[A-Za-z]*(?:\([0-9a-z]+\))*)"
)
SUBDIVIDED = re.compile(r"([0-9]+[A-Za-z]*)((?:\([0-9a-z]+\))+)")
LEVEL = re.compile(r"\([0-9a-z]+\)")


def cited_and_fetched(cite: str, evidence: str) -> bool:
    """Whether the evidence holds what a citation in the Reading names.

    The cite itself in the evidence, as before; or, for a subsection or
    paragraph ("181(1)(a)"), its section fetched whole - the pinpoint "s 181"
    in the evidence, not a definition inside it - with each level the cite
    names, "(1)" and "(a)", in that text. get_provision_text returns the whole
    section for a subsection by default, and the skill tells the agent to read
    it, so the subsection's words are in the evidence even though the string
    "181(1)" is not. Refusing them sent an agent back for four more fetches
    of text it already held (Claude Code plugin test, 8 Nov 2026)."""
    if cite in evidence:
        return True
    m = SUBDIVIDED.fullmatch(cite)
    if not m:
        return False
    section, levels = m.groups()
    whole = re.search(r"(?<![\w.])s\s+" + re.escape(section)
                      + r"(?![\w(])(?!\s*\(definition)", evidence)
    return bool(whole) and all(lv in evidence for lv in LEVEL.findall(levels))


def norm(s: str) -> str:
    """Whitespace and quote marks only: the owner's typographic tiers treat
    curly and straight apostrophes and quotes as the same character."""
    s = unicodedata.normalize("NFKC", s)
    s = s.replace("’", "'").replace("‘", "'")
    s = s.replace("“", '"').replace("”", '"')
    return re.sub(r"\s+", " ", s).strip()


# The answer's blocks: each heading is a line on its own (Gate 3). A heading is
# found only as a whole line, never as a word inside one, because "Reading"
# also appears in a debate title ("Second Reading") and in the footer.
HEADING = re.compile(r"^(Text|Reading|Not in the text above)\s*$", re.M)
NOT_RETURNED = "not returned"


def blocks(answer: str) -> dict:
    """The answer split at its headings: Text, Reading, Not in the text above.
    Without a Text heading, the Text block runs from the start."""
    out = {"Text": "", "Reading": "", "Not in the text above": ""}
    marks = list(HEADING.finditer(answer))
    if not marks or marks[0].group(1) != "Text":
        out["Text"] = answer[: marks[0].start()] if marks else answer
    for i, m in enumerate(marks):
        stop = marks[i + 1].start() if i + 1 < len(marks) else len(answer)
        out[m.group(1)] = answer[m.end():stop]
    return out


def passages(text_block: str) -> list:
    """Each quoted passage, with the line after it: consecutive lines that begin
    with ">" are one passage, so a quotation may span several lines."""
    out, buf = [], []
    lines = text_block.splitlines()
    for i, line in enumerate(lines + [""]):
        if line.lstrip().startswith(">"):
            buf.append(line.lstrip()[1:].strip())
            continue
        if buf:
            out.append(("\n".join(buf), line))
            buf = []
    return out


def check_path_line(line: str, nxt: str, evidence: str = "") -> list:
    fails = []
    if not nxt.strip().startswith("Path:"):
        return ["quoted passage has no Path line directly beneath it: " + line[:80]]
    hansard = "Hansard" in nxt
    caselaw = bool(re.search(r"\[\d{4}\]\s+(?:FCAFC|FCA)\s+\d+", nxt)) or "/c/" in nxt
    if "as at" not in nxt and not hansard and not caselaw:
        fails.append("Path line lacks an as-at date: " + nxt[:80])
    noted = ("reconstructed from get_provision_tree" in nxt
             or "path not available from Advisor" in nxt)
    if not (REGISTER_ID.search(nxt) or noted or hansard or caselaw):
        fails.append("Path line has no register id, reconstruction note or "
                     "not-available note: " + nxt[:80])
    for rid in sorted(set(REGISTER_ID.findall(nxt))):
        if evidence and rid not in evidence:
            fails.append("Path line names a register id the evidence does not hold: " + rid)
    for nc in sorted(set(re.findall(r"\[\d{4}\]\s+(?:FCAFC|FCA)\s+\d+", nxt))):
        if evidence and nc not in evidence:
            fails.append("Path line names a neutral citation the evidence does not hold: " + nc)
    body = nxt.split("Path:", 1)[1]
    if ">" not in body and "path not available from Advisor" not in nxt and not hansard and not caselaw:
        fails.append("Path line does not give a structural path (Act > ... > provision): "
                     + nxt[:80])
    record = " record >" in body
    caselaw_link = bool(re.search(r"https://advisor\.lawatlas\.ai/c/\S+", nxt)) or "/c/" in nxt
    if not (hansard or record or caselaw or ADVISOR_LINK.search(nxt) or caselaw_link or NO_ADDRESS in nxt):
        fails.append("Path line has no LawAtlas.ai link (https://advisor.lawatlas.ai/l/...) "
                     "or 'no stable address': " + nxt[:80])
    if not hansard and not caselaw:
        checked = re.search(r"Checked:\s*(.+?)\s*$", nxt)
        label = checked.group(1) if checked else ""
        if label not in ANCHOR_LABELS + (NOT_RETURNED,):
            fails.append("Path line does not end with 'Checked:' and the passage's "
                         "anchor.label (or 'not returned'): " + nxt[:80])
        elif label != NOT_RETURNED and evidence and label not in evidence:
            fails.append("Path line's label is not in the evidence: " + label)
    elif caselaw:
        checked = re.search(r"Checked:\s*(.+?)\s*$", nxt)
        label = checked.group(1) if checked else ""
        if not label:
            fails.append("Case Law Path line does not end with 'Checked:' and the paragraph's anchor.label: " + nxt[:80])
        elif label != NOT_RETURNED and evidence and label not in evidence:
            fails.append("Path line's label is not in the evidence: " + label)
    return fails


def verify(evidence: str, answer: str) -> list:
    evn = norm(evidence)
    fails = []
    parts = blocks(answer)
    # 1. Every passage is quoted, matches the evidence, and carries its Path line.
    found = passages(parts["Text"])
    if not found:
        fails.append("no quoted passages found in the Text block")
    for passage, nxt in found:
        m = re.fullmatch(r'\s*"(.*)"\s*', passage, re.S)
        if not m:
            fails.append('passage is not wrapped in straight double quotes: ' + passage[:80])
        elif norm(m.group(1)) not in evn:
            fails.append("quoted passage not found verbatim in evidence: " + m.group(1)[:80])
        fails.extend(check_path_line(passage, nxt, evidence))
    # 2. No quotation sits in the Text block outside a passage, unchecked.
    for line in parts["Text"].splitlines():
        s = line.strip()
        if not s.startswith(">") and not s.startswith("Path:") and re.search(r'"[^"]{12,}"', s):
            fails.append("quotation outside a > passage: " + s[:80])
    # 3. Citations in the Reading refer to provisions present in the evidence.
    for cite in sorted(set(CITE.findall(parts["Reading"]))):
        if not cited_and_fetched(cite, evidence):
            fails.append("reading cites a provision not in evidence: " + cite)
    # 4. The header states the as-at date and the source: LawAtlas.ai MCP since skills 2.0.0
    # (owner, 31 Oct 2026), or Advisor MCP, as an answer written by an earlier skill says.
    if not re.search(r"As at:\s*\d{4}-\d{2}-\d{2}", answer) or not (
            "LawAtlas.ai MCP" in answer or "Advisor MCP" in answer):
        fails.append("header missing as-at date or source")
    # 5. Advisor was called: the evidence file is not empty.
    if len(evn) < 50:
        fails.append("evidence file is empty: Advisor was not called or its output was not copied")
    return fails


def main(argv: list) -> int:
    if len(argv) != 3:
        print("usage: advisor_verify.py advisor-evidence.txt advisor-answer.md")
        return 2
    with open(argv[1], encoding="utf-8") as f:
        evidence = f.read()
    with open(argv[2], encoding="utf-8") as f:
        answer = f.read()
    fails = verify(evidence, answer)
    print("\n".join(fails) if fails else
          "VERIFIED COPY: every quoted passage matches the Advisor output copied; every "
          "passage carries a path and its Advisor check; the reading cites only fetched "
          "provisions")
    return 1 if fails else 0


if __name__ == "__main__":
    sys.exit(main(sys.argv))
```


======== lawatlas-research 2.0.0 ========

When to use: LawAtlas.ai research. Use when researching Australian Commonwealth legislation or the parliamentary record with the LawAtlas.ai MCP tools - what law covers a topic, what a section says at a date, what a term means, how a provision was amended, what Parliament said, what is about to lapse or be disallowed, what duties a law imposes. Gives the tool sequence, the parameters that matter and the traps for each kind of question. Answers that state law follow lawatlas-verified-answer.

# LawAtlas.ai research

Pick the row for the question, run its tools in order, and read the traps before relying on what comes back. Every statement of law in the answer then goes through `lawatlas-verified-answer`: quoted verbatim, with its path, compilation, as-at date, Advisor link and `anchor.label`.

Two rules hold for every row:

- **Law in force only.** Advisor serves the text of titles the Federal Register records as in force today. TITLE_NOT_IN_FORCE means the title has ended: say so, give `status.frl_link`, and do not supply its text from memory.
- **Check every quotation.** Before showing a passage of law, call `verify_passage` with it and the provision's `link.url`; quote it only on `match`.
- **Decide the as-at date first.** `get_provision_text` and `find_definition` take `as_at`. VERSION_NOT_HELD means Advisor does not hold the text for that date: say so; never substitute today's text.

## 1. What law covers X

Tools, in order:
1. `search_provisions` unscoped (`query`, `provision_types=["section"]`), or `search_legislation` (`query`, `kind`, `portfolio`) to find titles.
2. `resolve_reference` (`text`) for the title you choose, to get its `legislation_id`.
3. `search_provisions` scoped by `legislation_id`, `provision_types=["section"]`.
4. `get_provision_text` for each section you will rely on.

Traps:
- Read each hit's `match_type`. `both` is the strongest; a lone `semantic` hit is a lead to confirm, not a result.
- The result order is authoritative. `score` and `similarity` are on different scales; never compare or combine them.
- Unscoped search is corpus-wide and noisy. Try more than one phrasing before saying nothing covers X.
- Search returns snippets, never the full text. Quote only from `get_provision_text`.

## 2. What does section X say, as at a date

Tools, in order:
1. `resolve_reference` (`text`: the Act's name).
2. `get_provision_text` (`legislation_id`, `section_number`, `as_at`). It returns the whole section, also when asked for a subsection or paragraph. `section_number` is a string (`"181"` or `"s 181"`).
3. `get_provision_tree` (`legislation_id`) only where the response has no `link` and the path must be reconstructed.

Traps:
- Asked for a subsection, the answer is the whole section, with `requested_unit` naming the part asked for: `text[char_start:char_end]` is its text, and it carries its own `pinpoint`, `link`, `citation` and `anchor.label`. Read the whole section, because qualifiers sit in neighbouring subsections, and cite the part with its own values. `scope: "unit"` returns the part alone. Where `scope_note` is present, no section contains the unit.
- A long section pages: while `text_page.more` is true, call again with `from_paragraph=next_from_paragraph` and concatenate the pages' `text` in order. The offsets count from the start of the whole text; `requested_unit.page_from` starts a page at the part asked for.
- `other_matches` lists other provisions with the same number (a Schedule restarts its sections). Check the one returned is the one asked for, and fetch the other by `provision_id` if not.
- `status.compilation.state`: `pending_compilation` means commenced amendments are not yet in the text; `not_current` means the Register lists a newer compilation. Say so with the text.
- `anchor.label` is per provision. A section's `parts` says how many of its parts were verified; the part asked for carries its own in `requested_unit.anchor`.

## 3. What does a term mean

Tools, in order:
1. `find_definition` (`legislation_id`, `term`, `as_at`).
2. If nothing comes back: `search_provisions` scoped by `legislation_id` for the interpretation or dictionary section, then `get_provision_text`.

Traps:
- Coverage is partial: silence from `find_definition` is not proof there is no definition.
- "Has the meaning given by section N" is followed only where that section number is unique in the Act. Otherwise fetch section N yourself.
- Results are excerpts, not the text to quote: fetch each definition you rely on with `get_provision_text` (`provision_id` from the result), which gives its text, link and `anchor.label`.
- For one term, quote the definition, not the whole dictionary section. `get_provision_text` returns the definition, not the section holding it, even when asked for a paragraph inside the definition.

## 4. How has X been amended

Tools, in order:
1. `get_amendment_history` (`legislation_id`, `provision` for one provision's rows).
2. `get_version_changes` (`legislation_id`, `provision`) for what changed between compilations.
3. `uncommenced_amendments` (`legislation_id`) and `get_uncommenced_text` for what is made but not yet in force.

Traps:
- Endnotes are not law: every endnote block says `not_law: true`. Quote them as history, never as the law.
- `get_amendment_history` covers the compilations Advisor holds; `coverage` and `complete` say how many. Earlier history is on the Federal Register.
- Never merge uncommenced text with in-force text. Report it separately, with its commencement.
- Use `get_version_changes` for a change; do not infer one by comparing two fetches. An empty result for one provision means no change between the compilations Advisor holds, not that the provision was never amended: say which.
- An uncommenced item with `text_available: false` gives its reason (`text_unresolved_reason`): say the amending text is not held, and give the Register link.
- History rows carry no `anchor.label`: their check is `not returned`.

## 5. What did Parliament say

Tools, in order:
1. `search_hansard` (`query`, `date_from`, `date_to`, `chambers`, `speakers`).
2. `get_hansard_speech` (`speech_id`) for the full verbatim text; page with `from_paragraph`.

Traps:
- Quote verbatim, attributed to "Parliamentary Debates (Hansard), Parliament of Australia".
- Show `official_record` to the user. Do not fetch it: aph.gov.au refuses automated requests, and the block page is not the speech.
- Advisor is a search over the record, not the official record. Where they differ, Hansard on aph.gov.au governs.
- Not for satire, ridicule, political advertising, or to misrepresent any Senator or Member.

## 6. What is about to lapse or be disallowed

Tools:
- `sunset_radar` (`horizon_days`, `portfolio`, `issuing_authority`) for instruments due to sunset.
- `get_disallowance_risks` (`portfolio`, `issuing_authority`) for instruments open to disallowance, with any motion lodged.

Traps:
- Only legislative instruments sunset. Sunset dates cluster on 1 April and 1 October, so a short horizon can be empty.
- A disallowance item gives the dates it was tabled in each House (`tabled`), any `motion` and `resolved_motions`. It gives no deadline, and Advisor does not compute one: do not state one.
- Both tools cut a long list to fit and cannot page to the rest; the response says how many were left out. Narrow by `portfolio`, `issuing_authority` or `horizon_days` until nothing is left out, or say the list is incomplete.
- Neither carries `anchor.label`: the check for each record is `not returned`.
- `issuing_authority` is a list (`["ASIC"]`), and an instrument whose `issuing_authority` is null is reached by no authority filter, only by `portfolio`.
- Neither tool says whether an instrument will be remade or replaced. Do not infer it.

## 7. What duties does a law impose

Tools:
- `list_obligations` (`legislation_id`, `kind`, `topic`, `verified_only`).
- `get_provision_text` with the row's `pinpoint`, which returns the section around it (`requested_unit` names the row's own provision where it sits below a section).

Traps:
- A row is a provision containing one of ten words ("must", "shall", "commits an offence" ...). It does not say whom it applies to or what it means.
- Read each row's flags before relying on it (`benefit_condition`, `inserted_text`, `awaiting_commencement`, `items_not_held`).
- Each row carries its own verification verdict; report it as given.

## 8. What is not in the corpus

No tool. Advisor does not hold state or territory law, modern awards, or judgments of any court but the Federal Court of Australia (FCA and FCAFC), and never serves the text of a title no longer in force. Say so plainly, and never answer from a related provision as if it were the one asked for.