Law-firm knowledge retrieval across matter boundaries

Learn in your browser · Chapter 01 of 08

Build the admission register before asking an assistant to organise knowledge. Reusable structure and matter-specific information follow different routes.

A knowledge collection is a set of deliberately reusable records, with limits attached to each record. A client matter is a context in which particular people received information for particular work. Moving a document between folders does not change that relationship. The first Folio task is therefore to decide what kind of object has been proposed for use before asking what it says. A register template can teach the shape of an administrative record without bringing the facts of a source matter into another matter. A matter note can be useful in its own context while remaining unsuitable for shared knowledge. These are different routes through the collection.

Folio is an original fictional knowledge-administration desk for adult learners. Its two matter labels, MATTER-EMBER and MATTER-TIDAL, denote no real clients or legal dispute. Its records contain no genuine authorities or client instructions. K01 to K08 are shared collection records; D01 and D02 are Ember records; D03 and D04 are Tidal records. The eight K labels do not describe eight eligible precedents. Some identify retired, pending or expired material. Four records deliberately have no body key: K03, K07, D02 and D04. Missing text is part of the supplied challenge. You must preserve that absence rather than manufacture convincing matter content.

Consider a fictional request from an Ember knowledge analyst: find a current source-register template and clarify which records can support this administrative task. K01 is an approved fictional REGISTER-family version2 with supplied body. D01 is an approved fictional Ember matter note recording draft index entry EM-4, without a legal outcome. K03 is a shared curation candidate pending review, with unresolved rights and no body. D02 belongs to Ember but has unresolved privilege review and no body. A useful answer separates these four states. It does not combine them into a narrative simply because the request mentions the same desk or the same matter.

The common failure is a request to upload everything useful and remove names afterwards. That sequence places admission after disclosure. A temporary copy, search index or provider log may already contain the material before a later filter acts. Removing a name can leave a recognisable transaction, relationship, title or chronology. Here there are no actual people to identify, so the exercise cannot demonstrate anonymisation. Its point is to design the decision before the proposed copying. For a real proposal, the responsible knowledge owner must identify what may be used, for which audience and purpose, and where information would travel. The model cannot supply those decisions through polished wording.

Confidentiality, privilege, data protection and source-use rights are separate questions. SRA confidentiality guidance distinguishes confidentiality from privilege and addresses scoped disclosure consent; its reviewed scope does not give specific data-protection basis or retention advice. The current individual Code covers current and former client affairs with stated disclosure exceptions. A fixture permission does not select an exception. Nor does a confidential label decide privilege. Keep the professional questions in separate fields so that an approval for one purpose is not silently treated as an approval for another. These bounded source points come from sra-confidentiality and sra-code-individuals; the exercise performs none of those professional determinations.

The admission register should describe the object, its proposed use and its gaps. Record source ID, kind, matter, family, version, lifecycle, rights status, body presence and dependency. Do not put guessed body text into the gap column. For K03 the useful administrative statement is that review and rights remain unresolved, not that the candidate probably resembles K01. For D02 it is that the supplied privilege review is unresolved, not that it is privileged or safe to disclose. A separate column can name the proposed responsible route: knowledge owner for curation, confidentiality specialist for professional scope, or rights reviewer for source reuse. Naming a route records work to do, not its completion.

Adequacy matters as well as exclusion. An analyst who withholds every field may prevent a permitted administrative task from being understood. For the K01 template, the supplied owner/review/release-note wording is sufficient to explain the template's structure. There is no need to add a client's transaction, legal position or background. ICO minimisation guidance concerns adequate, relevant and necessary personal data for a specified purpose; the reviewed page displays a DUAA review notice. Applying a purpose-led admission register is our design proposal, not a finding that the synthetic collection is anonymous or that every corporate record is personal data. Source: ico-minimisation.

Collection status must remain visible through the answer. The phrase approved fictional describes a code-owned teaching assumption. It does not mean a partner approved an actual firm's document. An output should say which supplied record supports which narrow statement, which proposed material was excluded and which question needs separate review. An internal administrative draft can be useful while realUseStatus remains HOLD. Treat that status as a boundary around the exercise's claim. Do not translate it into an assertion that real use is unlawful everywhere, and do not remove it because the wording appears harmless. Neither conclusion follows from this corpus.

K01's supplied body says the template lists a source owner, review date and internal release note. The bounded paper output can therefore describe those three fields, identify K01 version2 and preserve the fictional limitation. It cannot say that a real owner has approved all future matter reuse. D01's EM-4 entry remains a matter-specific administrative fact. If that note is requested later for a different context, its earlier availability is irrelevant to the new request. The register allows the learner to see precisely where reuse ends: the template structure may be shared under the teaching rule, but the matter-specific entry needs its own permitted context.

A hold should be useful to the responsible team without disclosing protected details to an unentitled caller. The educational worksheet deliberately gives learners synthetic record metadata so they can diagnose a rule. A future system's denial response has a different audience. Folio's proposed caller response is generic, with empty results and citations rather than a named restricted title or rejection explanation. Do not copy the worksheet's detailed internal rationale into that response. This separation matters because even saying that a certain client document exists may disclose information. The worksheet is an authorised teaching view, not a design instruction to expose the inventory to every user.

The ordinary prompt asks a model to summarise all useful firm knowledge and make it safe. It supplies neither a permitted set nor an admission decision, and its demand for completeness encourages invented missing content. The stronger paper prompt supplies K01 and the already authorised D01 context, records the K03/D02 exclusions, and requests a field-level administrative output. It tells the assistant to stop if a requested statement lacks an admitted source. That prompt improves how a proposed task is specified; it does not enforce authority. A separate control must decide what reaches a model, and the learner can complete the same register with a librarian and printed cards.

Verification begins with the claim, not the fluent sentence. Ask whether each statement is supported by a supplied allowed body, whether its context is visible, and whether any absent material was reconstructed. Check that source identifiers have not been mistaken for real client IDs and that the output contains no legal conclusion. Then inspect the proposed return surfaces: excerpt, title, locator, notes and any downloadable copy. A concise body that is acceptable on its own may still be paired with an inappropriate reference. Later chapters deepen that dependency check. At this stage the learner should already understand why administrative traceability and permitted disclosure must be checked together.

An error also creates follow-up work. If an author accidentally drafts a plausible D02 paragraph, remove it from the proposed packet and preserve a safe record of the correction. Do not label that action a privilege decision or claim that deleting the displayed paragraph recalls every earlier copy. In this paper exercise no provider, index or actual client record exists. In a real proposal, the responsible team would need to identify the affected storage and recipients using its approved process. The learning outcome is to name the evidence gap and the appropriate owner without turning a classroom correction into a claim of incident handling or professional acceptance.

Your completed register should be readable by another adult reviewer without an accompanying conversation. It needs an explicit receiving task, source states, a minimum proposed output, a reason for every excluded item and a list of qualified decisions still missing. This is more useful than a blanket safe/unsafe label. It gives a knowledge owner something concrete to challenge and revise. Keep the paper date and scope attached, including that lab execution has not yet been supplied. The first successful result in this chapter is an honest, bounded administrative artefact. It is not a shared corpus release, a consent record, a real matter assessment or permission to provide legal advice.

1. Name the receiving administrative question, audience and fictional scope before selecting records.
2. Classify each proposed record using kind, matter, lifecycle, rights, body presence and dependencies.
3. Separate collection reuse from confidentiality, privilege, personal-data basis and source-rights decisions.
4. Admit only the minimum supplied material permitted for the assumed request; preserve every missing body.
5. Write the narrow source-linked administrative output and a separately scoped gap/owner docket.
6. Check every return surface, label paper predictions and keep actual-use claims unresolved.

Scroll sideways to see every column.

AVERAGE PAPER PROMPT
Summarise all useful firm knowledge from these four records, remove names and make the result safe for reuse.

ELITE PAPER PROMPT
ROLE: Administrative knowledge-register editor for the fictional Folio desk.
CONSTRAINTS: Supplied synthetic K01/K03/D01/D02 metadata only; assumed Ember task. No client, case authority, advice, actual anonymity or permission claim. K03 and D02 bodies are absent.
PROCESS: State the receiving question; classify each record; separate shared structure from matter-specific content; preserve unresolved review/rights/privilege fields.
VERIFICATION: Every proposed statement needs a supplied admitted body. Compare its exact meaning and scope; inspect title, locator and notes as return surfaces.
OUTPUT SCHEMA: recordId | kind | matter | bodyPresence | paperAdmission | supportedMeaning | gap | proposedOwner. Add a two-sentence minimum administrative output and actualUse NOT_APPROVED.
FAILURE MODES: Do not invent absent text, sanitisation, consent, privilege clearance or a legal outcome. If required admission evidence is missing, hold that proposed use and retain an internal scoped gap rather than plausible content.
This specifies a paper task; it neither runs a model nor supplies enforcement.

Text equivalent: receiving task leads to record classification, then body/admission checks. Supplied eligible material leads to a bounded register. Absent or unresolved material leads to a hold and a separately scoped owner docket. The diagram does not grant actual rights or professional permission.

Scroll sideways to see every column.

Scroll sideways to see every column.

Learn in your browser · Chapter 02 of 08

Check the relationship between actor, explicit matter and requested source on every return route. A correct-looking search screen cannot supply that relationship.

Matter authority is a relationship among the actor, the explicitly requested context, the proposed action and the particular source. None of those fields can substitute for the others. An analyst's membership of Ember does not allow Tidal records, while a shared template does not permit a request made in an unauthorised Tidal context. Folio turns these distinctions into fixed paper checks so that learners can reason about a request before any excerpt is returned. The method is useful for preparing requirements and test cases. It is not a substitute for authenticated identity, professional conflict checking or the firm's decisions about instructions and confidentiality.

The approved contract supplies three assumed actor labels. ANALYST_EMBER has MATTER-EMBER membership, ANALYST_TIDAL has MATTER-TIDAL membership, and KNOWLEDGE_CURATOR has no matter membership. Curator responsibilities exist in the teaching controls, but they do not confer unrestricted reading. Each request also names a matter ID. The source-related methods require a current exact permission version and renewed authority for the current day and version. The initial paper state is active, day2, version1, with no renewal. A request cannot rely on a membership label alone. It must satisfy the other conditions and the lifecycle and dependency checks for its particular source.

Q03 requests the Ember register entry D01. Q04 requests the Tidal register entry D03. Q05 proposes combining D01 and D03. For an Ember actor in Ember context, Q03 is a predicted reference draft, Q04 is held, and Q05 is held entirely. For a Tidal actor in Tidal context, Q04 is a predicted draft, Q03 is held, and Q05 is still held entirely. Q05 is important because returning the first permitted excerpt would be a partial aggregate leak. A correct design decides whether the complete requested source closure is available before constructing the first body, title or citation. It must not discover the boundary while writing the answer.

A tempting workaround changes the context to match the desired source. An Ember actor could request Q04 with MATTER-TIDAL, or request the shared Q01 template under Tidal to test whether shared content bypasses membership. Both are paper holds because the actor lacks that requested matter relationship. The alternative is not to relabel the request as shared or ask a model to ignore matter names. It is to record the unmet authority requirement through the approved administrative route. Real permission, if appropriate, would come from accountable policy and professional decisions. The fixed Folio exercise supplies no event that grants new membership and no self-service interpretation of client consent.

The per-request distinction matters even when the screen looks correct. A search interface can hide Tidal records while a direct retrieval, citation or export path continues to return them. OWASP authorisation guidance supports checking the requested object and action on every relevant route, beyond user-interface visibility; it is voluntary technical guidance, not an SRA rule. The Folio proposal therefore gives retrieve, verify_result, review_packet and export_packet their own authority conditions. A method name such as verify does not confer permission to reread a source. The same actor/context issue must be addressed before that method performs the proposed source work. Source: owasp-authorisation.

Professional conflict and access decisions must stay separate. The reviewed SRA Codes and conflict guidance distinguish acting conflicts and confidential-information questions; their exceptions have conditions. A retrieval membership does not establish that a firm can accept or continue instructions, and a wall label does not decide a professional exception. Folio's matter labels are invented and imply no real adverse interests. When adapting the method to a real proposal, record who makes the professional decision and which evidence supports it, rather than inviting a language model to infer clearance from an access table. Sources: sra-code-individuals, sra-code-firms and sra-conflicts.

Use a request worksheet with one row for each actor, context and query combination. The row should state the receiving administrative purpose, current day/version, renewal prerequisite, full source closure and paper disposition. A row can explain an internal reason for teaching, but the proposed caller response remains generic. This is a deliberate separation between a reviewer who sees the supplied synthetic policy and a caller who may not be entitled to learn which record was denied. Do not add names, protected titles or source counts to a failure message to make the demonstration easier. Evidence for a control can be collected through an appropriately scoped reviewer route.

Failure handling changes the next request. Under the approved contract a handled validation or authority failure clears renewal, cached results, verifications, review and packet. It preserves the substantive day, version, membership and source lifecycle, and the lifetime counters do not reset. Therefore a sequence that tries a held request must renew before the next otherwise eligible request. More importantly, it cannot carry a prior verification or review across that failure. On paper, mark the boundary where cached success is lost and show the explicit recovery steps. Do not write a matrix that assumes every earlier draft remains reviewable after the final hold.

This is why an all-query challenge and a review-building journey are different exercises. Trying Q01 to Q12 demonstrates eligible and held paths but includes failures that clear cached successes. To build an initial Ember packet later, the contract calls for explicit renewal followed by only Q01, Q02 and Q03, each retrieved and verified without an intervening handled failure, then a scoped review. The initial Tidal eligible set is Q01, Q02, Q04 and Q08. Those sets are paper expectations at day2/version1, not observed execution or permanent entitlements. The next chapters explain the source conditions that make the two sets different.

Exact parameter types are part of the teaching boundary. A positive integer permission version is not the boolean True, despite a language implementation treating booleans as numeric in some operations. Unknown query IDs and a caller-provided policy mapping are not authority. A polite natural-language request cannot change fixed role or matter membership. These restrictions make the small fixture's cases reproducible. They do not secure a Python object against a hostile user with access to its attributes or files. Any future service would need authenticated identity and controlled execution around the requirements rather than trusting a caller's role string.

Python calls also have two different failure locations. A malformed request that enters the method body can follow the contract's handled invalidation policy. A missing or unknown argument can cause Python to raise TypeError before that body runs, leaving pre-call state unchanged. The course must not describe both as clearing earlier approval. In a paper test plan, name the call shape and the stage at which it is rejected. A future service wrapper would need its own policy for translating transport and argument-binding failures. That wrapper is not supplied by a worksheet or by the proposed standard-library lab.

The ordinary worked request says to combine both registers because the analyst works for the same firm. It treats employment as access to every object and leaves the receiving matter unstated. The stronger prompt names ANALYST_EMBER, MATTER-EMBER, INTERNAL_KNOWLEDGE_CHECK, day2/version1 and the source-closure checks before projection. Its expected output allows only the supplied D01 administrative excerpt for Q03 and gives no content for Q04 or Q05. A prompt remains a task specification for an already bounded input route. It cannot be the authority decision itself, nor can it turn an assumed reviewer token into verified independence.

An effective review of the worksheet asks whether the designer challenged the easiest bypasses. Would a different context string permit a shared record? Would the curator label bypass membership? Would requesting one excerpt from a mixed aggregate disclose a permitted prefix before a denied dependency is checked? Would a verification or export route rely on an old retrieval without current authority? Each question has a concrete paper counterexample in Folio. Keep those checks distinct instead of declaring a single generic hold to be proof of every control. The implementation author and separate reviewer must later demonstrate the actual causes with versioned snapshots and observed outputs.

The resulting artefact is an actor/context/query matrix and a deliberately limited recovery trace. It is valuable because a colleague can identify the proposed scope and the exact missing step. It is insufficient for operational approval: membership labels are not identity, model prompts are not enforcement, and source windows are fictional rather than legal retention periods. Provide a non-AI route in which a knowledge owner checks the same requested record and purpose before returning an authorised extract. That route preserves the same boundary instead of bypassing it through a phone call or printed unrestricted corpus. The rule follows the information, whichever interface delivers it.

1. Name the assumed actor, explicit matter and INTERNAL_KNOWLEDGE_CHECK purpose.
2. Check active state, current exact version/day and current renewed authority.
3. Expand the fixed query into its complete source and citation-dependency closure.
4. Check every closure member before any body, title, locator or count is returned.
5. Separate internal teaching rationale from the generic empty caller hold.
6. After a handled failure, renew and rebuild only the complete eligible set before fresh review.

Scroll sideways to see every column.

AVERAGE PAPER PROMPT
Combine the Ember and Tidal registers. I work at this firm, so use whichever records answer best.

ELITE PAPER PROMPT
ROLE: Folio request-policy worksheet editor, not legal adviser or access administrator.
CONSTRAINTS: Assumed ANALYST_EMBER; requested MATTER-EMBER; INTERNAL_KNOWLEDGE_CHECK; day2/version1; current renewal required. Fixed Q03/Q04/Q05 only. No real identity, retainer, conflict, consent or basis decision.
PROCESS: Resolve each complete source closure; check actor/context/current authority/lifecycle/dependency before any projection. Treat rows independently and record a separate failed-call recovery trace.
VERIFICATION: Q03 uses D01; Q04 uses D03; Q05 uses both. No partial prefix, denied title/locator/count or self-granted context.
OUTPUT SCHEMA: query | assumedActor | requestedMatter | requiredClosure | paperDisposition | internalRationale. Caller-facing failure is only HOLD_REFERENCE_UNAVAILABLE, realUseStatus HOLD, empty results and citations.
FAILURE MODES: A handled hold clears renewal and reusable output. Do not retain an old review after it. Missing/unknown Python arguments fail before the body and must be recorded separately; do not claim their invalidation was executed.
This is a paper method specification; role strings are not authentication.

Text equivalent: both the visible retrieval and direct source methods check assumed actor against explicit requested matter, then active/current renewed authority, then the complete closure. All checks must pass before a draft. Any failed member causes a generic empty hold. A handled failure requires explicit renewal and a newly built eligible set before review.

Scroll sideways to see every column.

Scroll sideways to see every column.

For a fixed request, bind the assumed actor to the explicit matter and check active state, exact current version/day and renewed authority. Check every source’s approved fictional status, rights and usable window, and expand all citation dependencies before projection. Q08 uses shared K06 plus its MATTER-TIDAL D03 dependency. An eligible Tidal actor can receive the complete K06/D03 closure as REFERENCE_DRAFT. An Ember actor receives HOLD_REFERENCE_UNAVAILABLE, results [] and citations [], with no prefix, restricted title, locator, identifier, count or specific cause. Titles, bodies, locators and citations follow the same boundary. A shared source label does not grant another matter. Packet review is a later distinct step after fresh retrieval and verification of every currently eligible query; INTERNAL_REFERENCE_PACKET remains realUseStatus HOLD. This illustration establishes no actual client scope, privilege, rights, identity or security approval.

Learn in your browser · Chapter 03 of 08

Keep family history, source dates, lifecycle and review windows separate. A well-written candidate cannot supply its own release evidence.

A precedent's provenance is the explanation of what it is, where its wording came from, which version is intended for use and who is responsible for keeping it suitable. A readable document without that explanation can be an attractive stale copy. Folio therefore separates family, source version, issue date, curation date, lifecycle, review window, rights and dependencies. These fields answer different questions. The newest file in a folder is not necessarily the current approved family member, and the date of a librarian's review is not the date of the text's issue. Begin with those relationships before inviting any assistant to polish or rank the material.

The REGISTER family contains K01 version2 and retired K02 version1. Their issue date is29September2026 and curation date30September2026 in this fictional corpus. The current paper choice is K01, whose body includes an internal release-note field that K02 omits. A learner can describe that difference because both supplied bodies are visible in the authorised teaching contract. It does not follow that an ordinary caller may retrieve retired K02. The source register retains the retired record as history while the retrieval policy excludes it. Preservation for traceability and admission as current knowledge are separate decisions, not contradictory statuses.

The DATES family provides a second version problem. K04 version2 distinguishes issue and curation dates and is usable through fictional day3. K05 version1 has no curation-date field and remains retired despite a longer day window in its metadata. At initial day2, Q02 is a predicted draft using K04. Day3 is still inside K04's inclusive window; day4 is outside it. K05 does not become eligible on day4 or after the named withdrawal event merely because it remains stored and its own window has not ended. A fallback must itself satisfy lifecycle and scope. Availability cannot repair retirement.

The failure case is a rushed curator who treats the latest edit, a matching hash and a sanitised note as sufficient release evidence. K03 is a curation candidate with PENDING_REVIEW, unresolved rights and no supplied body. A note that someone believes it is sanitised is a claim requiring review, not a transformation of its state. K07 likewise has PENDING_RIGHTS and no body. Neither has an approved contract event that promotes it. A correct paper docket keeps both excluded and lists the responsible evidence questions. It must not invent text to demonstrate what the missing candidate might have contained or return a guessed precedent to avoid an empty result.

Controlled curation starts with a receiving use: for example, a reusable administrative source-register template rather than a summary of a client's matter. The knowledge owner needs to know which parts are intended to survive, which source-matter relationships remain and which users should receive the result. In Folio those decisions are explicitly fictional. For an actual proposal, the curation route would also need confidentiality, privilege, data-protection and source-rights decisions appropriate to the source and intended use. A partner's confidence in drafting quality is not evidence of all those decisions. The learner should name the missing review without asserting that every real precedent requires one universal form.

The proposed docket records a release or retirement decision without silently making it. For K01 it can say retain as the contract's current fictional version, with its stated day window. For K02 it can say retain archive history, do not return as current. For K03 it can say candidate held, obtain a scoped curation and rights decision before any real promotion proposal. An owner field should distinguish a proposed responsible function from a verified person's signature. A completed classroom docket can be a complete explanation of outstanding work while every actual-approval claim remains false. Completeness of the record is not completion of professional review.

SRA firm rules place governance and confidentiality responsibilities on the regulated firm within their scope; the reviewed sections do not prescribe this Folio register as a compliant solution. Confidentiality guidance also separates source disclosure questions from data-protection basis and retention advice. We use those bounded source points to explain why a document's lifecycle needs accountable ownership, while treating the particular register fields as an authored design method. OWASP vector guidance highlights cross-context risks, but Folio contains no vector store or embedding experiment. Sources: sra-code-firms, sra-confidentiality and owasp-vector-2025. The methods here organise evidence for review, not professional acceptance.

Three dates should be kept distinct when explaining a candidate. The issue date records when this version's wording was issued in the fixture. The curation date records the supplied review event date. The current teaching day controls the source's availability window. None is an actual legal deadline, retention period or warranty of continuing correctness. A model that turns all three into a single last-updated field loses the reason a source was admitted. A useful administrative answer can display each field and explain which one controls the current paper decision. That explanation makes a later challenge reproducible rather than forcing a reviewer to infer chronology from a filename.

A digest is another distinct field. The approved contract describes a digest of canonical complete-record JSON, so title, locator and dependency changes matter as well as body changes. A raw file hash is separately a binding to the entire fixture transport. Neither proves that the source owner is genuine, its professional review is valid or the wording is suitable for a legal question. Until the implementation is frozen, this chapter supplies no invented digest value or observed hash result. A paper docket can name the required digest binding as awaiting the later lab snapshot while still recording the exact source version and supplied wording used in its reasoning.

Dependencies belong in curation because a reusable-looking source can carry a non-reusable relationship. K06 is an approved fictional shared note, but its citation dependency is D03 in MATTER-TIDAL. Removing D03 from a display does not automatically make K06 a new independent precedent. Doing that would alter the supplied source relationship and would need a separate authored curation proposal, not a secret filter. For this contract, K06 remains tied to D03; its permitted return depends on context. A release register should therefore include source dependencies and their scopes, not just a table of standalone bodies. The next chapter follows the relationship into answer references.

Retirement needs a clear reason and a preserved relationship. K02's omission explains why it is a historical REGISTER copy, not why it should be deleted. K05's missing curation-date field explains why it cannot be a replacement for K04. The paper retirement docket can retain family and version links and direct learners to the current eligible record where one exists. After K04 withdrawal there is no eligible DATES replacement in this corpus. State that gap plainly. Do not make up a new checklist, adopt the retired version, or describe an old copy's existence as a failure of the withdrawal rule.

The ordinary prompt asks an assistant to turn K03 into an approved reusable precedent and fill missing release fields from K01. That output would counterfeit an evidential step. The stronger prompt asks for a curation docket using only supplied metadata, distinguishes source text from administrative proposals, and holds any request to return absent bodies. Its proposed output identifies K01/K02 family status, K04/K05 availability, K03/K07 unresolved work and K06's dependency. Verification checks that no candidate was promoted and no dates or signatures were invented. The task remains feasible without AI: the same docket can be completed from the printed register and reviewed by a knowledge owner.

Corrections should leave a trace of what changed and why. If a reviewer finds that an issue date was presented as a curation date, correct the administrative derivative and preserve the supplied original relationship. Do not rewrite the source fixture to make the earlier output appear right. The Folio events later model two named state changes, not arbitrary editing or a general document-management system. In an actual service proposal, the team would need to define which sources, indexes, caches and exports depend on the changed record. This chapter prepares the dependency evidence; it does not claim that an existing provider implements that propagation or recalls copies.

The finished docket gives another reviewer a narrow, challengeable account of why each version is proposed for use or held. Its quality comes from the distinctions it preserves: archive versus current, issue versus curation, bytes versus authenticity, candidate versus approval, and dependency versus independent source. Each unresolved item should have a next evidence question rather than a reassuring conclusion. Keep the adult fictional scope attached and label the results as paper predictions from the approved contract. A collection can be carefully documented while real rights and professional applicability remain undecided. That is an honest state from which qualified decisions can be made later.

1. Define the proposed reusable administrative purpose and receiving audience.
2. Link each record to its family/version and distinguish issue from curation dates.
3. Check lifecycle, inclusive source window, rights, body and dependency before proposing current use.
4. Create a proposed release/retirement docket with owner questions and explicit unresolved evidence.
5. Bind source identity/version and later digest separately from authenticity or professional approval.
6. Verify that no candidate was promoted and no retired copy was adopted as fallback.

Scroll sideways to see every column.

AVERAGE PAPER PROMPT
Polish the sanitised K03 candidate into an approved precedent. Fill missing review and rights fields from the closest approved template.

ELITE PAPER PROMPT
ROLE: Folio curation-docket editor preparing evidence questions for a knowledge owner.
CONSTRAINTS: Supplied synthetic K01-K07 rows only; day2/version1. K03/K07 bodies absent. No promotion method, actual signature, real rights, privilege, legal advice or professional release claim.
PROCESS: Link families/versions; keep issue and curation dates distinct; inspect lifecycle/windows/body/rights/dependency; write proposed use or hold plus a specific next evidence question.
VERIFICATION: K02/K05 remain retired. K04 is eligible through day3 only and has no K05 fallback after withdrawal/expiry. K06 retains D03 dependency. Missing body/digest evidence is labelled pending, never invented.
OUTPUT SCHEMA: source | family/version | issueDate | curationDate | lifecycle/window | proposedUse | unresolvedEvidence | proposedOwner | nextCheck. Add a retirement link and realUseStatus HOLD.
FAILURE MODES: A sanitised note is not reviewed evidence. Do not manufacture candidate text, signatures or dates, rename a source to bypass scope, or assert that matching bytes prove professional suitability.
This is a proposed paper docket, not an executed curation workflow.

Text equivalent: family/version links lead to distinct issue/curation dates and lifecycle/window checks. Eligible current members may support a scoped request. Retired members remain archive history. K03/K07 remain pending with no body. Unavailable K04 has no K05 fallback. The proposed owner docket records the remaining evidence questions without approving a real collection.

Scroll sideways to see every column.

Scroll sideways to see every column.

Learn in your browser · Chapter 04 of 08

Check the entire reference closure before returning the first excerpt. Exact source consistency is a narrow administrative claim, not legal truth verification.

A reference can disclose information even when the answer sentence appears harmless. Its title may reveal a matter's existence, its locator may expose an identifier, and its dependency may lead to a restricted document. The unit of permission is therefore not just the generated paragraph. It includes the source and every reference surface needed to explain that paragraph. Folio's fixed excerpt-and-reference projection makes the relationship visible without using a language model. The learner's task is to decide the whole permitted return before displaying any part of it. A citation is an object requiring scope, not a decorative footnote that can be added after a body has passed review.

K06 illustrates the problem precisely. It is a shared approved fictional cross-reference note with a supplied body and a D03 citation dependency. D03 is an approved fictional Tidal register note. Q08 requests K06. The source closure is therefore K06 plus D03, not K06 alone. For an Ember actor in Ember context, the complete return is held because D03 is outside the permitted matter. For a Tidal actor in Tidal context, both supplied records are eligible at initial day2/version1 after current authority renewal. The shared label remains true but incomplete: it does not describe whether every linked object can travel with the requested result.

The faulty paper output gives Ember the K06 body and then adds a footnote naming D03 and its Tidal locator. It might also say that one restricted supporting record was omitted. Each element has a different leak surface: the excerpt, the title, the source identifier, the locator and the existence/count statement. Hiding only the footnote cannot make that original result valid because the contract requires whole-closure preflight. The permitted caller response is generic and empty. In the authorised classroom worksheet you may identify why the proposed result fails, because all labels are synthetic and supplied for learning. Do not mistake that internal analysis for the denial text a future caller should receive.

A reference projection should keep source identity, version, title, locator and digest bound together. Otherwise a correct body can be paired with another source's title or an older version's line. That error can mislead the reviewer about provenance even before considering disclosure. Folio's proposed verifier compares the cached result with current code-owned definitions and fingerprints. It does not determine whether an arbitrary legal proposition is true or whether a reported judgment supports it. Exact consistency with the fictional source is a much narrower claim. Record that scope in the output so that a successful comparison is not presented as verified legal research.

The current SRA AI warning discusses unreliable citations and confidentiality risks, with continuing professional responsibility. It is not evidence that a paid or in-house provider is automatically suitable, and its linked judgments were not independently analysed in this source review. This workbook creates no case citation or holding. Its reference examples point only to original administrative fixture records. OWASP authorisation and vector guidance support considering requested objects and cross-context references beyond a search display, as voluntary technical material. These are bounded reasons for the proposed preflight design, not an audit of an actual model, legal-research system or information barrier. Sources: sra-ai-warning-2026, owasp-authorisation and owasp-vector-2025.

Use an output ledger with two linked parts. The statement part contains the exact supplied excerpt and the administrative claim it supports. The reference part contains its matching source identity and version, permitted title/locator and the digest binding required for that snapshot. Before copying either part, check every citation dependency against the same actor, context, purpose, day, version and lifecycle. If a dependency fails, hold the entire proposed query result. Do not return a permitted prefix, name the failed dependency to an unentitled caller or ask a model to improvise an uncited equivalent. That would change the request's evidential basis and its disclosure path.

For an initial Tidal paper result, Q08's two body strings have different roles. K06 says that a fictional cross-reference points to a matter note and that retrieval must check the referenced matter before exposing the link. D03 says that the Tidal source register records draft index entry TI-9 and no legal outcome. The learner should return those exact administrative meanings with the matching references, not transform TI-9 into a court decision or substantive fact about a client. A field that says no legal outcome is a limitation, not an invitation to infer one from context. Good synthesis preserves that negative boundary in the resulting reference ledger.

Source occurrence counts are easy to overstate. In the initial Tidal paper journey, Q01 returns K01, Q02 returns K04, Q04 returns D03, and Q08 returns K06 and D03. That is five logical returned-source occurrences across four distinct sources. It is not five unique sources, five legal authorities, five verified facts or five physical file reads. The approved contract keeps physical whole-fixture loading separate and says verification, review and export do not add new retrieve occurrences. This chapter makes no executed count claim. The arithmetic is a paper derivation of the declared projection rules and can be checked by listing each return occurrence.

Verification and review must stay current even within one permission version. A fresh retrieval replaces that query's previous verification and clears the aggregate review and packet. A successful re-verification increments the lifetime verificationSequence. Therefore an earlier complete review cannot simply be attached to a new output that happens to use version1 again. The responsible assumed reviewer must review the current complete verified set and its fingerprints. The sequence is a teaching binding inside one process, not a durable audit record or professional signature. A caller-owned copy exported earlier remains outside recall, which is why review state and copy containment are separate topics later in the course.

An all-query challenge is not a packet-ready cache. It deliberately includes holds that clear renewal and reusable output. A Tidal learner preparing a later packet must explicitly renew and retrieve/verify the complete eligible set Q01, Q02, Q04 and Q08 without an intervening handled failure, then obtain the scoped assumed review. A paper answer that says four queries passed earlier and proceeds straight to export misses this recovery boundary. At this point learners need not run the unfinished lab or claim an observed packet. They can produce a precise expected trace that a separate implementation reviewer can later challenge against actual snapshots.

The average prompt asks for citations from anything that supports the answer and requests that restricted footnotes be hidden. It places the reference check after content selection. The stronger prompt defines the permitted Tidal context, the K06/D03 closure and exact source fields before requesting a ledger. It forbids replacement authorities, absent text and legal interpretation, and names a hold route for any unresolved field. Its verification instruction compares each excerpt with the supplied body and each reference with the matching record. This is a bounded output specification, not permission to search an actual firm's files. A human librarian can perform the same task from the authorised paper cards.

Leak analysis should include intermediate surfaces. A proposed search result can reveal a title before the full body opens. A suggested completion can repeat an identifier. A trace log can preserve a denied locator, while a help message can announce a protected record count. Folio's generic failure contract limits caller returns, but the exercise supplies no real search index, support portal or operational logging policy. Record these as design questions for the proposed system rather than pretend the fixed method checks cover them all. The useful artefact is a list of return surfaces, the information each exposes and the authority check that must precede it.

A successful exact-match verification also leaves content limits. The fixture's administrative wording might be faithfully returned while being unsuitable for a different question. For example, TI-9 is an index entry, so it cannot answer whether a matter has a particular legal result. If the receiving question exceeds the supplied meaning, narrow it or refer it to the responsible qualified route. Do not claim that adding a citation fixes an unsupported inference. The ledger should record what a source does not establish as carefully as what it says. This is how a concise answer remains useful without borrowing credibility from a source label or an assumed reviewer status.

Finish with a reference ledger and a leak-correction note that another reviewer can use without guessing. Show the expected permitted Tidal pairs, the complete Ember hold, the omitted surfaces and the need for current authority and fresh complete review. Attach the paper-only label and the digest field awaiting the lab freeze instead of inventing execution evidence. Keep the non-AI knowledge-owner route available if a proposed service cannot establish scope. The result is a teachable evidence boundary across snippets and citations. It does not demonstrate secure retrieval, actual OCR or RAG performance, professional privilege protection, legal advice or durable control of every exported copy.

1. Name the receiving administrative question and assumed actor/context/current authority.
2. Expand the requested source into every citation dependency before projection.
3. Check body, title, identifier, locator, count and other return surfaces under the same boundary.
4. Create exact excerpt/reference pairs only for the complete eligible closure.
5. Compare current source identities/versions and later digest bindings, retaining limits on meaning.
6. After a new retrieval or verification, obtain a fresh complete review rather than reusing an old sequence.

Scroll sideways to see every column.

AVERAGE PAPER PROMPT
Find any useful references for the shared cross-reference. Give Ember the answer first and hide restricted citations afterwards.

ELITE PAPER PROMPT
ROLE: Fictional Folio excerpt/reference-ledger editor, not legal researcher.
CONSTRAINTS: Initial ANALYST_TIDAL / MATTER-TIDAL / INTERNAL_KNOWLEDGE_CHECK / day2/version1 with current renewal. Q08 closure is K06+D03. No model, real source, legal authority or professional approval.
PROCESS: Resolve the complete dependency closure; check each record and return surface before projection; pair only the exact supplied excerpts with matching version/title/locator fields.
VERIFICATION: K06 v1 points to D03 v1. D03 records draft index TI-9 and no legal outcome. Digests are awaiting later lab freeze; do not invent them. Distinguish occurrences from distinct sources and physical reads.
OUTPUT SCHEMA: sourceId | version | exactExcerpt | supportedAdministrativeMeaning | title | locator | digestEvidenceStatus | limitation. Use sourceLocator folio://K06/v1/line/1 for K06 and folio://D03/v1/line/1 for D03. Add a separately scoped Ember leak-correction note and realUseStatus HOLD.
FAILURE MODES: If any closure member or requested meaning fails, do not return a prefix or replacement authority. Caller failure is generic/empty, without restricted titles, counts or locators. New retrieval/verification requires fresh complete review; no actual execution is asserted.

Text equivalent: Q08 expands to K06 plus its D03 dependency before any projection. Every member must pass the current request conditions. Initial Tidal receives both exact administrative excerpt/reference pairs; Ember receives only a generic empty hold. Verification checks current source pairing, then the complete current set needs fresh review. No legal truth or real-use approval follows.

Scroll sideways to see every column.

Scroll sideways to see every column.

Learn in your browser · Chapter 05 of 08

Work through the original Folio paper case. Contract predictions are not observed runtime or professional approval.

Revocation changes who may obtain a new result, not what a person remembers or already holds. In Folio, ANALYST_EMBER initially has an assumed membership in MATTER-EMBER. The REVOKE-EMBER event removes that membership from both analyst and reviewer overlays. It does not erase an exported packet from a caller's possession. A useful revocation account therefore separates new requests, cached internal evidence and copies already distributed. Treating those three places as one search screen conceals the most consequential gaps in a knowledge service.

Consider the fictional knowledge register at day 2. An Ember analyst has obtained K01, K04 and D01 through Q01, Q02 and Q03, verified them, and retained a reference packet. The analyst is then removed from the matter. An ordinary manager hides the search button and calls the change complete. A more precise manager asks whether the same actor could call retrieval directly, repeat verification, reuse a reviewer decision or obtain another export. The interface is only one route into the proposed workflow, not its authority source.

The approved educational contract gives the lifecycle a clear order. First stop work with a valid reason. Then apply the exact unused REVOKE-EMBER event using the assumed curator parameters. The event increments permissionVersion from 1 to 2 and leaves the process stopped. It clears renewal, cached retrievals, verifications, review and packet. The analyst's Ember membership is absent afterwards. The event is not a login, a real firm's employment decision or a qualified determination that a client relationship has ended. Those remain separate real-world decisions.

A stopped-state rejection and a membership rejection have different meanings even when both return the same generic HOLD_REFERENCE_UNAVAILABLE response. While work is stopped, a request is already ineligible. That response alone cannot show that a deeper matter check ran correctly. Review the separate membership overlay and the resume condition when interpreting the paper journey. In a future implementation review, distinguish tests of each gate from demonstrations that happen to encounter several gates at once. Avoid describing a single rejected screen action as proof of every enforcement layer.

The event's version change matters independently of membership. A version-1 request is stale even if it uses an otherwise familiar query and role string. A version-2 request does not acquire authority simply because its number is current. It still needs active state, renewed authority for the present day and surviving membership for the requested matter. This conjunction is a reusable design method: describe each necessary condition separately, then ask which evidence establishes it. Passing one condition must never be reported as passing the entire admission decision.

The revocation worksheet uses three distinct challenges. Twelve current-version retrieval calls cover Q01 through Q12 in MATTER-EMBER. Eight additional direct probes cover retrieve, verify_result, review_packet and export_packet with versions 1 and 2. Two control probes attempt resume_work(2) and renew_authority(2). The contract predicts twelve, eight and two holds respectively after revocation. These are separately named call groups, not a claim that the same twelve calls test everything. They are paper expectations until the separate implementation supplies observed records and an independent challenge.

Counters help explain the boundary only when their units remain explicit. The minimal pre-event packet requires three retrieval-source occurrences and three successful verifications. After revocation, the lifetime logicalSnippetSources counter remains 3 and verificationSequence remains 3. Additional source returns during the post-event challenges are predicted to be 0. Neither counter is erased by a stop or event. Verification, review and export do not constitute new retrieve projections. A table saying simply zero reads would hide the three earlier returns and confuse a logical return counter with physical fixture loading.

The retained version-1 export is an independent Python copy. Removing the internal packet reference cannot reach that object, a printed page or a note someone made from it. For this exercise, label the old packet as a historical copy whose onward use has not been authorised by the current workflow. A proposed real containment plan must ask who received it, what permitted purpose still exists, who controls further sharing and what response is required. Do not invent deletion receipts or claim the exercise remotely recalls material from recipients.

The source read boundary also needs careful language. Folio proposes one local JSON fixture rather than a protected document store. A physical load may contain retained or excluded synthetic metadata and bodies. The permission policy governs what the method projects into a result, including title, excerpt, identifier and citation. The local filesystem and Python object are not a confidentiality defence against someone who can read or edit them directly. This limitation makes the exercise useful for reasoning about ordering, while preventing a misleading claim of production access security.

Record a denial without publishing the material it denied. The proposed failure response has generic status, held real-use status and empty result and citation arrays. It does not echo the protected title, source locator or detailed reason. A paper incident note can record the attempted method, day and version, then route any further evidence to a properly controlled review. Copying the restricted excerpt into a widely shared troubleshooting ticket would create a second disclosure surface while trying to demonstrate that the first surface is blocked.

Source sra-confidentiality is regulator guidance in the primary England and Wales context. Its reviewed sections distinguish professional confidentiality from privilege and discuss organisational arrangements and outsourcing. Those duties are not decided by Folio's membership map. Source ico-security supports risk-appropriate technical and organisational measures and effectiveness checks where UK GDPR applies; its visible DUAA review notice is retained. These sources inform questions for a real service. They do not validate the proposed Python exercise, determine a retainer or settle a legal exception.

An evidence-conscious revocation method has six stages: identify the affected actor and matter; identify the current rule and version; stop the proposed workflow; apply the authorised finite event; challenge every return route; and record unresolved old-copy handling. For a real service, the authority to change membership and investigate copies must itself be checked. A useful output says which routes were examined and under which state. A less useful output says access revoked without stating whether that refers to an interface, server decision, index, citation store or exported copy.

The ordinary prompt asks, Remove Ember access and confirm nobody can see its information. It demands a conclusion the supplied evidence cannot establish. The precise prompt asks for a paper route matrix, preserves the pre-event copy, distinguishes current version from current membership, and lists the independent checks still required. Its output contains request, context, version, predicted disposition and limits. It does not ask a model to infer a legal entitlement or recover denied text. Better prompting narrows the educational task; it does not become the service's enforcing control.

Handled failures and Python argument-binding errors must remain distinct. A correctly bound call that fails validation clears reusable authority and evidence under the contract. A call with an unknown keyword or a missing required argument may raise TypeError before the method body runs, leaving the previous state unchanged. An author should not use such an exception as evidence that a packet was invalidated. A future service needs its own request wrapper and defined error handling. The learner should preserve this limitation rather than adjust the narrative to make every failure look equivalent.

Fresh-process reset is an important adverse result, not a minor convenience. Starting a new Folio process restores original day, version, membership and curation state. REVOKE-EMBER is therefore not durable across processes. If a proposed knowledge service restarts after an incident, it needs a trustworthy current authority store and recovery procedure rather than this fixture's initial state. The exercise invites that architecture question without implementing authentication or storage. A persistent-looking counter printed in a report does not supply a persistent revocation decision behind the next request.

Your chapter evidence should be modest and usable: a filled route matrix, an exact counter ledger and an old-copy containment note. Explain what each supports, how it could be contradicted and who must resolve the remaining professional questions. In a teach-back, ask a colleague to distinguish the twelve-query challenge from eight method probes and two controls. Then ask whether a held response proves membership enforcement or merely stopped state. A learner who preserves those distinctions has practised analysing an access change, not obtained approval to operate a law-firm retrieval system.

1. Record the original Ember packet and its three lifetime occurrences.
2. Stop, apply the exact membership event and record version2 with no resume.
3. Separate12query,8 direct-method and2control probes.
4. Distinguish active-state, stale-version and absent-membership evidence.
5. Record old-copy limits and propose controlled human containment.

Scroll sideways to see every column.

Ordinary: Remove Ember access and confirm nobody can see its information.
Precise paper prompt: Role: educational knowledge-administration reviewer. Constraints: synthetic Folio only, no clients or real service. Process: start from the minimal three-query packet, stop and apply REVOKE-EMBER, keep12current retrievals/8 direct probes/2 controls separate. Verification: check membership/version/active gates and lifetime3 versus additional0; HOLD alone cannot establish the rejecting gate. Output: route matrix, counter ledger, old-copy containment questions. Failure: keep real-use HOLD and flag any missing evidence; do not retrieve denied text or claim erasure.

Text equivalent: Prior packet: Version1,3 sources,sequence3; caller copy retained; then Stop work: Valid bounded reason,activefalse; then Revoke membership: Eventversion2,no Ember membership; then Separate route probes: 12retrieves+8 methods+2 controls;0 new sources; then Old-copy containment: Proposed authorised handling; no erasure. Each arrow represents the next distinct check, not automatic authority. All stated runtime results are paper predictions.

• Success criterion: Separate all three probe groups and exact call counts.
• Success criterion: Preserve lifetime3/additional0 and old-copy survival.
• Success criterion: Name active/version/membership gates without claiming causal proof from generic HOLD.
• Success criterion: Keep containment proposed and professionally unresolved.

• Q1: Does a hidden search button establish revocation across every route?
• A1: No. Analyse direct retrieval, verification, review and export as separate routes and examine current membership.
• Q2: Why does a held call while stopped not prove membership enforcement?
• A2: Stopped state is independently sufficient to deny. Generic output does not identify the rejecting gate.
• Q3: What are the three post-event probe groups?
• A3: Twelve current-version query retrieves, eight old/current direct-method calls and two control calls.
• Q4: What are the minimal packet's counters after revocation?
• A4: Lifetime sources3 and sequence3 remain; additional post-event source returns0.
• Q5: Can the event erase an earlier export?
• A5: No. Caller-owned copies survive and need separately authorised containment decisions.
• Q6: What does a fresh process do to the event?
• A6: Restores the original state. The proposed simulation supplies no durable revocation.

Begin with the minimal fictional Ember packet: Q01/K01, Q02/K04 and Q03/D01 are retrieved and verified; an assumed scoped review permits a copied INTERNAL_REFERENCE_PACKET that remains held for real use. It has three logical returned-source occurrences and verificationSequence3. A valid stop clears reusable authority/evidence. REVOKE-EMBER, applied once while stopped with assumed curator parameters, changes permissionVersion from1 to2 and removes Ember analyst and reviewer membership. It does not resume or renew work. New Ember requests remain held, including shared K01 requests; the current version alone cannot restore missing membership, and removed Ember membership cannot be renewed or resumed. Lifetime logicalSnippetSources3 and verificationSequence3 persist in that instance, while its old exported copy still contains three excerpts. No remote recall or deletion is performed. A fresh Folio process resets the original day2/version1/memberships/lifecycle and zero counters/sequence. The event overlays are not durable. Generic stopped denial alone does not establish causal membership enforcement; the separately reviewed lab distinguishes gates. This conceptual illustration establishes no authenticated actor, actual client authorisation, source rights, professional judgement, secure access control, durable audit or production revocation.

Learn in your browser · Chapter 06 of 08

Work through the original Folio paper case. Contract predictions are not observed runtime or professional approval.

Withdrawal changes a source's suitability for new retrieval, while revocation changes an actor's membership. Confusing them produces the wrong recovery plan. WITHDRAW-K04 marks the approved date checklist unavailable and leaves K05 retired. Ember can still hold membership after that event, but cannot use K04. REVOKE-EMBER removes membership even when K01 remains an approved shared template. Both events increment the finite permission version, yet their effects are different. A maintenance docket should name the affected object and rule rather than describe every change as a general access problem.

Folio's date family makes the distinction concrete. K04 is version 2, approved for the fictional workflow through day 3 inclusive. K05 is version 1 and retired, with a nominal window through day 4. The longer date on K05 does not make it a fallback. Approval status and family/version provenance are separate conditions from expiry. A knowledge worker who searches for something still dated in-window may revive an obsolete checklist. The precise worker keeps the retirement decision visible even when the preferred version cannot be returned.

Dates need names rather than one undifferentiated timestamp. Every supplied record has an issueDate of 29 September 2026 and curationDate of 30 September 2026. The simulation starts on day 2, which represents 1 October 2026. A source's usableThroughDay is a finite teaching window, not evidence of a client's event date or a real firm's retention schedule. Keep those columns separate. Otherwise a recently curated copy may be mistaken for recently created advice, or an exercise expiry may be described as a legal obligation to destroy a record.

The maintenance method begins with a source-family register: current approved version, retired predecessors, rights state, dependencies and usable window. Add the exact proposed change, its assumed owner, version effect and required rechecks. For K04 withdrawal, record that Q02 loses eligibility; do not rewrite its query to K05. The fixed query remains visible as unavailable. A real knowledge owner may eventually commission a replacement, but that would require a new curation decision and reviewed source. The present contract contains no event that approves a candidate or restores a withdrawn source.

The event journey starts from a fresh Ember instance on day 2. Stop work, apply WITHDRAW-K04 using the assumed curator role and token, and obtain permissionVersion 2 while work remains stopped. resume_work(2) only reactivates the finite workflow. It does not renew authority, retrieve a replacement, verify results or approve a packet. Explicit renew_authority(2) and fresh eligible retrievals follow. Write those stages as separate rows so a learner can identify an omitted step. A diagram that jumps from event applied to packet ready would conceal the most useful maintenance lesson.

The twelve-query withdrawal challenge deliberately includes held requests. Its paper outcome is Q01 and Q03 drafted, ten queries held, and two retrieval-source occurrences. A held request clears renewal and reusable evidence, so repeat renewal when proceeding to the next challenge call. The full challenge is not itself a completed review packet. After the challenge, rebuild deliberately: renew, retrieve and verify only Q01 and Q03, then perform a fresh complete scoped review. Distinguish diagnostic coverage from preparation of a current packet rather than combining their results into an apparently continuous successful run.

If the challenge and rebuild occur in the same instance, counters remain cumulative. The challenge contributes two logical source occurrences; a minimal rebuild contributes two more, producing four in that particular paper sequence. A separate fresh process used just for the rebuild would start from zero, but it must reapply the withdrawal event because lifecycle state is not durable. Name the chosen sequence before calculating. Without that description, two honest reports can display different totals and be wrongly treated as contradictory. Counts describe calls and state, not a general performance benchmark.

Day advancement is another maintenance event with a different effect. At day 3, K04 remains in-window if not withdrawn. At day 4 it is excluded even without a withdrawal event, while the actor's authority window remains usable through that day. At day 5, actor renewal is no longer possible under this fixture. advance_day requires a strictly forward exact integer and clears renewal, results, verification records, review and packet. It preserves the active flag and does not grant another usable day. An expiry cannot be cured by simply presenting the current version again.

Explain a current version without implying current content. After a withdrawal the version identifies a changed policy state; it does not assert that all source families now contain usable knowledge. An export request at version 2 must still pass the current source closure and complete-review checks. A date window, current hash and familiar title are also insufficient individually. They answer different questions about timing, byte binding and presentation. The knowledge owner should be able to say unavailable when the only alternatives are retired or pending, rather than let an apparently tidy result hide the absence of approved guidance.

Source sra-code-firms supplies selected governance and accountability context for SRA-authorised firms. It does not prescribe this exercise's days or curator token. Source ico-minimisation concerns purpose-dependent adequacy and limits on personal information where UK GDPR applies; its DUAA review notice remains a currency limitation. Neither source authorises a universal deletion deadline. Our finite expiry and retirement docket are original teaching controls. Real retention, privilege, preservation and rights questions need appropriately qualified decisions about actual records, not a timer copied from the fixture.

A pending item is not a partly approved replacement. K03 has unresolved rights and pending review, K07 has pending rights, D02 has unresolved privilege review, and D04 is quarantined. Their absent bodies are intentional. The maintenance analyst may list the missing decision and route it to an owner, but must not invent a plausible body to fill a register gap. A sanitised label alone does not settle reidentification risk, confidentiality consent or legal reuse. When an authorised process cannot produce a current source, the correct educational output preserves that absence clearly.

The ordinary recovery request says, K04 was withdrawn, so find the closest checklist and carry on. It encourages substitution across status and version boundaries. The precise request asks for the affected fixed query, current eligibility, retired alternatives that must remain excluded, and a separate human curation route. Its answer states Q02 unavailable rather than supplying K05. This is a useful comparison even without model execution: inspect the assumptions each instruction makes. A fluent response to the ordinary request would not become authoritative merely because it sounds like a careful legal-administration checklist.

Failed lifecycle changes must be reviewed as failures, not approximate success. An unknown event, repeated event, wrong type or wrong curator parameter returns a handled hold without changing day, permission version, membership or lifecycle. Reusable authority and evidence are cleared according to the failure rule. A duplicate WITHDRAW-K04 call therefore cannot advance the version a second time. Record the attempted change and compare the substantive state before and after. Otherwise a retry mechanism might accidentally make a report claim a policy revision that never occurred, or reuse a review invalidated by the attempted change.

Continuity should preserve a human route while avoiding unauthorised revival. If a checklist is withdrawn, propose asking the knowledge owner for approved current material or a bounded answer that the reference is unavailable. If a real matter needs urgent work, the fixture does not decide whether or how that work should proceed. The responsible practitioner uses the firm's approved process and applicable duties. A no-AI knowledge route still needs permissions and current sources; it is not permission to consult any colleague's matter folder because the automated route is inconvenient.

A maintenance record should show what was withdrawn, when the finite event applied, which queries and packets were affected, and what rechecks are planned. Keep proposal, execution evidence and professional decision in separate columns. For this chapter the execution column says not observed. A later lab report may supply actual returned statuses and counters, but must bind the exact implementation and fixture. It cannot retroactively convert a paper curator label into genuine source-owner approval. This separation allows useful teaching to remain honest while an implementation and its independent tests are still unfinished.

At the end of the exercise, compare two statements: the checklist is unavailable, and all checklist material has been erased. The first can follow from the finite withdrawal policy; the second cannot, because retired bodies may remain in the JSON and earlier caller copies survive. Then compare the review window has expired with the legal retention period has ended. Only the first is supplied here. Being precise about these negative conclusions protects the maintenance method from overclaiming and gives a real knowledge-management partner specific unresolved questions to assess.

1. Register K04 v2 and K05 v1 as different lifecycle objects.
2. Apply withdrawal only while stopped; keep retired predecessor excluded.
3. Resume then renew, never conflate them.
4. Separate all-query challenge from complete eligible packet rebuild.
5. Check inclusive source and actor windows, with no timer-based legal erasure claim.

Scroll sideways to see every column.

Ordinary: Replace the withdrawn checklist with the closest older copy and carry on.
Precise paper prompt: Role: fictional knowledge curator. Constraints: K04 withdrawal does not approve K05; dates are simulation windows, not legal retention. Process: stop/event/resume/renew/fresh eligible checks, separate challenge from rebuild. Verification: version2, retired predecessor, day3/day4/day5 boundaries, cumulative occurrence units. Output: withdrawal docket and Q02 unavailable with owner questions. Failure: hold missing or expired evidence, no invented replacement or erasure receipt.

Text equivalent: Source register: K04 v2 approved;K05 v1 retired; then Stop and withdraw: K04 withdrawn;v2;still stopped; then Resume separately: Currentversion/reactivation only; then Renew and rebuild: FreshQ01/Q03;complete review; then No retired fallback: K05 excluded despite date. Each arrow represents the next distinct check, not automatic authority. All stated runtime results are paper predictions.

• Success criterion: Keep K04 withdrawn and K05 retired.
• Success criterion: Distinguish resume/renew/fresh complete review.
• Success criterion: Give2draft/10 hold/2occurrences and lifetime4 for named same-instance rebuild.
• Success criterion: Apply inclusive windows without inventing legal retention or restoration.

• Q1: How does withdrawal differ from revocation?
• A1: Withdrawal changes source lifecycle; revocation changes actor/reviewer membership.
• Q2: Can K05 replace withdrawn K04 because its window extends to day4?
• A2: No. K05 is retired. A window does not override lifecycle status.
• Q3: Does resume_work renew authority?
• A3: No. It reactivates only; explicit renewal and fresh evidence/review follow.
• Q4: Why cannot all-query challenge successes form the final packet?
• A4: Intervening holds clear reusable evidence and renewal. Rebuild the full current eligible set separately.
• Q5: What is the source/actor boundary on day4?
• A5: Unwithdrawn K04 is expired; actor authority is still within its day4 window if other gates pass.
• Q6: What is the source-occurrence total for challenge plus minimal rebuild in one withdrawal instance?
• A6: Two challenge returns plus two fresh rebuild returns gives lifetime4 for that stated sequence.

Learn in your browser · Chapter 07 of 08

Work through the original Folio paper case. Contract predictions are not observed runtime or professional approval.

A review packet is a bounded decision about current evidence, not a decorative approval label. Folio requires every currently eligible query for the chosen actor and matter, and at least one such query, to be freshly retrieved and verified. The assumed reviewer must match that matter's current membership and exact fixture token. The packet binds day, permission version, context and verification sequence. These rules prevent a selective successful excerpt from being presented as a complete checked collection. They do not establish genuine independence, professional competence or approval to use the material on a client matter.

For Ember at day 2 before events, the complete eligible set is Q01, Q02 and Q03. For Tidal it is Q01, Q02, Q04 and Q08. Q08 contributes both K06 and its D03 citation dependency. A reviewer who sees three tidy Tidal rows may still be missing the shared note's dependency closure. Compute the eligible set from current policy and records, not from whatever happened to appear in a cache. A successful subset is not completeness evidence, and an empty set cannot make a review pass merely because there is nothing left to inspect.

Verification checks a synthetic binding rather than substantive legal truth. The proposed verify_result operation compares the cached excerpt and reference definitions with current code-owned definitions and fingerprints. A digest can identify a record including its title and locator, but cannot prove a real author wrote it, that a client permitted reuse or that an interpretation is sound. The body itself is fictional knowledge-administration wording. If a learner reports verified advice or checked privilege after this comparison, the output has exceeded the operation's purpose even when all compared strings match exactly.

Each successful verification increases verificationSequence by one, including a repeated successful verification of the same query. A review uses the aggregate current sequence and the complete current verified-result fingerprints; the individual verification records need not share one sequence number. New retrieval replaces that query's verification and clears previous review and packet. A new successful verification also requires a new complete review. This is a practical defence against carrying an approval label forward while the evidence changes underneath it, even when the permission version and day have not changed.

A worked Ember sequence illustrates currentness. Renew at version 1 on day 2; retrieve and verify Q01, Q02 and Q03 once each; review the complete set; then propose export. The lifetime verification sequence is 3. Re-verifying Q01 produces sequence 4 and invalidates the former review. Q02 and Q03 may retain their current verification records, but the aggregate review must be performed again at sequence 4. A version-1 label on the old review is not sufficient. This is a paper sequence, not an observed test of a particular implementation.

The export operation must recheck rather than merely return the stored packet object. Current authority, current source closure and the current review remain prerequisites. Its successful output is an independent internal-reference copy with realUseStatus HOLD and all actual-approval claims false. Such a copy is useful for comparing evidence and unresolved questions. It is not a release to a client, a permission to upload source material to a provider or a certificate of appropriate legal reliance. Keeping that disposition visible on the packet makes the educational boundary harder to lose in later handover.

The provider discussion begins outside the finite lab. No model, vector store or hosted supplier processes Folio's records. A proposed real service nonetheless needs a dataflow map because a source can appear in an upload, extracted text, embedding, query log, support ticket, backup or exported answer. Write each destination as a separate object with a purpose and responsible decision-maker. A supplier's use of the phrase private workspace does not explain every destination. Nor does a local demonstration establish which actual contractual terms, subprocessors or retention settings would apply to a future purchase.

Use a provider question docket rather than a completed approval form. Ask what enters the service, what returns, who can inspect support data, what training use exists, what deletion affects, and which backups or export copies remain. Add the evidence required: relevant terms, current settings, architecture, access controls and a test or assurance record for the actual service. Mark every answer not supplied as unknown. A truthful docket can be advanced by a qualified reviewer; a polished statement that all data stays private cannot be checked if it names no destinations or evidence.

The SRA AI warning, dated 17 August 2026, addresses professional responsibility, unreliable citations and confidentiality safeguards. Paid or in-house tooling does not itself settle those safeguards. Source sra-code-firms supplies governance context, while source ico-lawful-basis-2026 is the ICO guide updated on 2 April 2026 and lists seven bases. No basis is selected here. These reviewed sources support specialist questions; the proposed packet does not determine a firm's privilege position, disclosure consent, lawful basis, processor arrangement or international transfer decision. Linked judgments and unreviewed professional regimes remain outside the course's claims.

Design the incident docket with the same restraint as the result projection. A generic denied request may be recorded without copying a protected title, locator or body into an ordinary helpdesk conversation. Name the channel that can receive fuller evidence under the firm's actual policy and identify who decides escalation. The fixture supplies no breach-reporting deadline or duty analysis. It also supplies no affected-person notification process. Treat those as required real-service work rather than filling gaps with a guessed timetable because the sample workflow needs a neat ending.

Continuity is more than having someone read the same screen aloud. A knowledge owner or librarian route should allow a person to request an authorised current reference, explain an unavailable result and challenge a mistaken scope decision. Offer clear text equivalents for diagrams and a non-AI request method, without requiring a learner to expose a real matter during training. A manual route does not waive permissions or replace practitioner judgment. Its purpose is to preserve usable human assistance when the proposed digital route fails or is unsuitable, within the same source and matter boundaries.

An ordinary review prompt says, Check the available answers and sign off the assistant. It leaves collection completeness, currentness and intended use unspecified. A precise prompt asks for a paper review of the complete eligible set in one matter, matched excerpt/reference bindings, current day/version/sequence and a held real-use disposition. It asks for an unresolved-decision register and stops if any required evidence is missing. That prompt is a teaching tool for structuring a proposed review, not a way to manufacture the reviewer's authority or compel a model to become a confidentiality specialist.

Compare a filled review docket with a summary of success totals. A total of three verified queries does not identify which queries were verified or whether three were required in that context. Four Tidal queries do not mean four source occurrences because one has a dependency. A summary that says reviewed today may omit an intervening re-verification. Preserve the exact set, source closure and sequence alongside the readable conclusion. The information should be enough to examine the decision without pretending that the printed docket implements secure storage or a durable audit history.

Returned-copy isolation also applies to review and export artefacts. Changing a copied disposition to approved, editing a title or removing the limitation text does not amend the stored source, membership or current review. A copied packet that looks cleaner can be less trustworthy if the change is not recorded. Compare it with the approved fictional definitions and mark unsupported additions as caller alterations. A future service needs policies for authorised derivatives and copies. The finite exercise does not stop someone changing their own object or ensure that downstream readers receive the original limitation text.

Professional review should be decomposed into named questions rather than one vague signature. A knowledge-management partner considers curation and retirement. A confidentiality and privilege specialist considers the matter scope and proposed disclosure. An identity and retrieval architect considers enforcement across requests, indexes and exports. Privacy, source-rights, supplier and accessibility decisions also need evidence appropriate to their own scope. These are proposed responsibilities, not appointments already made. An assumed reviewer token in Folio cannot stand in for any of them or imply their approval has been obtained.

The chapter output is a complete fictional review docket, a provider question map and a human continuity route. Keep current review evidence separate from proposed provider answers and from unresolved professional decisions. If a new verification occurs, write why the old docket is no longer current and what must be reviewed again. If no eligible query remains, preserve a hold rather than a ceremonial empty approval. A good teach-back explains why complete current evidence permits only a held internal reference packet, while genuine professional use remains a decision about a different and much larger system.

1. Compute the complete nonempty eligible set for one actor/context.
2. Retrieve and verify current exact excerpt/reference bindings.
3. Bind scoped review to current day/version/aggregate sequence.
4. Invalidate old review after new verification and re-review completeness.
5. Separate provider questions, professional decisions and human continuity.

Scroll sideways to see every column.

Ordinary: Sign off the available answers and approve the provider.
Precise paper prompt: Role: educational evidence reviewer. Constraints: no real provider, professional sign-off or legal truth verification. Process: compute the full Ember eligible set, match exact references, review current day/version/aggregate sequence, then challenge re-verification. Verification: distinguish sequence3 and4; keep realUseStatus HOLD. Output: complete paper docket, provider destination questions and human continuity route. Failure: nonempty completeness required; return unresolved questions instead of assumed legal or supplier approval.

Text equivalent: Eligible query set: EmberQ01/Q02/Q03;nonempty; then Fresh bindings: Exact synthetic excerpts/references; then Current scoped review: Day2/version1/aggregate3; then New verification: SuccessfulQ01reverify makes 4; then Re-review or hold: Fresh complete review;realuseHOLD. Each arrow represents the next distinct check, not automatic authority. All stated runtime results are paper predictions.

• Success criterion: Supply all3Ember queries and exact current review sequence.
• Success criterion: Reverify produces4; prior review invalid and complete new review required.
• Success criterion: Mark provider facts unknown and state required evidence.
• Success criterion: Keep actual professional/supplier/accessibility acceptance unresolved.

• Q1: What makes a review complete for initial Ember?
• A1: Current Q01/Q02/Q03 retrieved and verified, all and at least one eligible query.
• Q2: Does verification decide whether content is legally sound?
• A2: No. It checks the supplied synthetic excerpt/reference binding, not legal truth or rights.
• Q3: What happens after successful Q01 re-verification at sequence3?
• A3: Sequence becomes4 and previous review/packet invalid; fresh complete review is required.
• Q4: Must individual verification records all show the same sequence?
• A4: No. Review binds the current aggregate sequence and all current fingerprints.
• Q5: Does a held internal packet approve provider uploads?
• A5: No. Provider dataflows/terms and qualified legal/privacy decisions remain unresolved.
• Q6: What should an unavailable digital route offer?
• A6: A proposed authorised human knowledge-owner route, with clear unavailable results and accessible information, not waived matter boundaries.

Learn in your browser · Chapter 08 of 08

Work through the original Folio paper case. Contract predictions are not observed runtime or professional approval.

The capstone combines a reference policy, matter authority and a maintenance process without pretending that it is a law firm's deployed assistant. Your dossier describes a fictional two-matter corpus and fixed educational queries. It must preserve every unavailable item, exact source family and citation dependency, then show how a current held packet would be assembled. An attractive answer is not enough. A reader should be able to reconstruct each paper decision from supplied records and identify which professional, privacy, supplier and operational questions remain unanswered before any real use.

Start with a twelve-record admission register rather than the queries alone. K01 and K04 are approved shared references at day 2. K02 and K05 are retired predecessors. K03 and K07 are pending candidates with unresolved rights and no bodies. K06 is approved shared knowledge with a Tidal dependency. K08 has expired. D01 and D03 are approved Ember and Tidal records respectively; D02 has unresolved privilege review and D04 is quarantined, both without bodies. None of those labels describes an actual client, document, retainer or professional judgment.

An admission register needs more than allowed and denied. Include source identifier, kind, family/version, matter, usable window, rights/status, dependency and disposition. The held reason belongs in a controlled paper analysis here, not necessarily the generic caller response. The exercise intentionally exposes metadata in its teaching register while the proposed runtime response avoids protected identifiers and detailed rejection causes. Explain that difference to learners. Educational visibility of a synthetic record does not imply that a real service may publish the existence or title of every restricted client document to anyone who asks.

The two authority matrices use separate contexts. Ember permits the shared references whose closures fit Ember and its own D01. Tidal permits its own D03 and can also use K06 because its dependency matches Tidal. Q05 combines D01 and D03, so neither context admits the entire request. Do not return the locally permitted half as though the fixed query had succeeded. Atomic closure prevents a seemingly harmless aggregate from smuggling a different matter's identifier into an answer. It also prevents a learner from hiding a failed overall query behind one correct excerpt.

Now classify every query before calculating the totals. At day 2 Ember drafts Q01, Q02 and Q03, holding Q04 through Q12. Tidal drafts Q01, Q02, Q04 and Q08, holding Q03, Q05, Q06, Q07, Q09, Q10, Q11 and Q12. The predicted source-occurrence totals are three and five respectively. They count returned source bodies, including D03 returned again within Q08's closure, rather than unique documents. No observed run is claimed. This complete key is supplied so a learner tests their reasoning instead of inventing classifications that happen to match a target count.

Build a packet only after finishing the diagnostic challenge. Handled holds clear renewal and reusable evidence, so a pass through all twelve queries cannot serve as the later complete review. For Ember, renew and freshly retrieve/verify Q01, Q02 and Q03 without an intervening handled failure. For Tidal, use Q01, Q02, Q04 and Q08. Name the appropriate assumed reviewer and token, then request a current review and export. The exported copy remains held for real use. A dossier should state exactly which phase supplies a challenge record and which phase supplies current packet evidence.

The withdrawal case changes one source family, not the firm's entire knowledge purpose. Stop, apply WITHDRAW-K04, retain K05 as retired, and keep work stopped at version 2. Resume and renew explicitly before fresh checks. On day 2 the Ember eligible set becomes Q01 and Q03; Q02 is unavailable rather than redirected. The twelve-query challenge predicts two drafts, ten holds and two source occurrences. A separate current packet requires another deliberate two-query retrieval and verification sequence. Keep counts tied to the chosen instance and phase so the dossier does not silently erase earlier returns.

The revocation case changes membership instead. The minimal Ember packet begins with lifetime logicalSnippetSources 3 and verificationSequence 3. Stop and apply REVOKE-EMBER, then retain the old exported copy as historical. Twelve current-version retrieval challenges, eight old/current direct-method probes and two controls all predict holds. Post-event additional source returns are zero; lifetime source and verification counters remain three. Because the workflow is stopped, a held call alone does not identify the rejecting gate. Your analysis must distinguish active-state, version and membership conditions, not describe generic denial as complete proof of production revocation.

Use the day boundary as an independent capstone branch. On day 3 an unwithdrawn K04 is usable; on day 4 it is not. Actor renewal still fits day 4, but cannot extend into day 5. Day advancement preserves the active flag while clearing reusable authority and evidence. A fresh process resets the original day, version, memberships and lifecycle, including previously applied events. That reset is a deliberate limit. A real continuity plan would need durable current decisions and controlled recovery rather than assume every process can rebuild authority from this initial educational fixture.

The source excerpts are administrative and exact, not substitutes for legal research. K01 says that a fictional template lists a source owner, review date and internal release note. K04 distinguishes issue and curation dates. D01 records a draft index entry EM-4; D03 records TI-9. K06 explains its restricted citation dependency. These strings support a bounded knowledge-administration exercise without fabricating legal authorities or client outcomes. Do not elaborate EM-4 into a dispute, infer that TI-9 establishes a legal result or ask a model to supply the absent privilege candidate's contents.

Your provider map should contain a row for each proposed processing destination: uploads, extracted text, embeddings, queries, result caches, logs, support access, backups and exports. Against each, record purpose, expected content, who decides access, required evidence and an unresolved status where facts are not supplied. Folio actually uses none of those hosted destinations. The map is a proposed investigation method, not a report that a provider has been inspected. Keep requests for current terms and technical evidence separate from professional determinations about what may lawfully or appropriately be submitted.

The reviewed England and Wales sources do not turn this dossier into permission to act. SRA professional rules, regulator guidance and voluntary technical advice have different authority. ICO privacy guidance applies within its own processing scope, with the minimisation/security DUAA notices retained and the lawful-basis guide's 2 April 2026 update distinguished. Other professional jurisdictions and linked judgments remain unreviewed. A real matter needs qualified decisions on confidentiality, privilege, conflicts and rights, while the exercise needs honest classification of fictional objects. Preserve both statements without treating the larger decision as another boolean field the student can set.

An ordinary assistant proposal offers a search box, the phrase ethical wall and a sample successful answer. The precise proposal supplies actor/context/source rules, every projection surface, currentness and revocation tests, a complete review condition and a held-use packet. It also names limits that the local prototype cannot solve. That is a substantive difference in design quality, not a difference in tone. A convincing demo with no denied cases cannot show what happens when a dependency crosses matters, a source is withdrawn or an old reviewer decision is replayed after new evidence.

Include a no-AI continuity plan that a knowledge owner could examine. The learner can ask for a current approved reference through an authorised human route, receive a clear unavailable response and escalate a disputed classification without uploading real matter contents. Provide an accessible register and diagram text equivalents. Do not invent an actual staff member, response-time promise or complaint outcome. If the proposed service fails, the ordinary firm process and responsible practitioner remain in control; the educational model does not acquire extra authority because the human route is inconvenient or slow.

Assessment evidence is also bounded. Forty planned mapped knowledge questions and eight ungraded practices are separate from this capstone's professional outcome. A future twenty-question knowledge assessment uses strictly more than 80 percent, so sixteen correct fails and seventeen passes. No exam or certificate availability is established by these chapter files. A self-check mark, a complete dossier or an assumed reviewer token is not a qualification, identity check or professional licence. An actual graded practical outcome would require a real marking process and suitably qualified review beyond the supplied model answers.

Finish with a release-decision docket whose recommendation is proposed educational review only. Attach the admission register, exact query matrices, source/reference pairs, separate challenge and packet phases, event/day/counter ledgers, provider questions, continuity route and unresolved professional decisions. Mark runtime observations pending until exact lab reports exist. Preserve old copies and process-reset limits instead of describing them as repaired. This produces an original, inspectable assistant proposal and a teach-back artefact while making clear why professional use, implementation acceptance, browser accessibility and publication remain further decisions rather than consequences of finishing the workbook.

1. Fill all 12 record admission rows without inventing absent bodies.
2. Classify all 12queries separately for Ember and Tidal.
3. Calculate occurrence counts and rebuild current evidence in a distinct phase.
4. Supply withdrawal/revocation/day/reset branches and copy limitations.
5. Write provider evidence questions, accessible continuity and held recommendation.

Scroll sideways to see every column.

Ordinary: Build a firm-wide legal assistant from every record and show a successful answer.
Precise paper prompt: Role: adult educational proposal author. Constraints: twelve synthetic Folio records, two contexts, no model/client/provider/privilege decision. Process: fill admission register and all 12 query matrices; separate challenge, packet, withdrawal, revocation and day branches. Verification: dependency closure, exact strings, lifetime counters and source windows. Output: complete held proposal docket with provider questions and no-AI continuity. Failure: preserve absent bodies, denied sources, old copies and new-process reset; professional and publication decisions remain unresolved.

Text equivalent: Admission register: 12 records,4absentbodies; then Matter matrices: Ember3draft/Tidal4draft;closures; then Complete current packet: Separate from hold-containing challenge; then Event and day branches: Withdrawal/revocation/expiry/reset limits; then Provider and continuity: Actual supplier/professional facts unknown; then Held proposal: Education only,realUseStatusHOLD. Each arrow represents the next distinct check, not automatic authority. All stated runtime results are paper predictions.

• Success criterion: Preserve all 12 record and query decisions for each context.
• Success criterion: Count returned source occurrences, not unique sources or disk reads.
• Success criterion: Supply event/day/reset branches and old-copy limits.
• Success criterion: Separate diagnostics, complete packet and held real use.
• Success criterion: Provide original provider/continuity and qualified decision docket.

• Q1: Which initial Tidal queries draft?
• A1: Q01/Q02/Q04/Q08. Q08 includes K06 and D03.
• Q2: Why are Tidal's source occurrences5 rather than4?
• A2: Four queries include a two-source dependency closure; D03 returned again counts as another occurrence.
• Q3: Why is Q05 held in both contexts?
• A3: Its D01/D03 closure spans both restricted matters; no partial success is returned.
• Q4: Which records deliberately lack bodies?
• A4: K03/K07/D02/D04. Candidate labels do not permit invented contents.
• Q5: What is the full revocation counter conclusion?
• A5: Minimal pre-event lifetime3,0 additional returns after the separate12+8+2 probes, lifetime remains 3; old copies survive.
• Q6: What does a complete capstone establish?
• A6: An inspectable fictional proposal and paper reasoning, not runtime/professional approval, publication or a practical qualification.

Scroll sideways to see every column.

# Folio: fictional matter-boundary reference lab

This original four-file Python standard-library exercise supports the planned adult course **Law-firm knowledge retrieval across matter boundaries**. It projects supplied fictional administrative wording from fixed requests. It does not perform OCR, model inference, vector retrieval, legal research, client work or a professional privilege decision. Every successful reference and packet retains `realUseStatus: HOLD`.

Course owner and planned author: **Mickarle Sean Junior Wagstaff-Irons - Micky Irons**, public name **Micky Irons**, stable author identity `https://mickai.co.uk#founder`. This lab is AI-assisted original educational implementation. The root approved finite contract, SHA256 `e3d7df20572aee9a78be75f91faf9df02f40fdb89806f36d75cfaea9f629d3a0`, is the implementation authority. Its historical proposal status is retained outside this portable lab; subsequent approval does not rewrite that history. Passing author tests is separate from independent review, qualified subject review and any publication decision.

Keep these four files together:

1. `README.md`
2. `folio_records.json`
3. `folio_lab.py`
4. `test_folio_lab.py`

Run with Python 3.10 or later, without third-party packages:

```text
python -B -X utf8 folio_lab.py
python -B -X utf8 test_folio_lab.py
```

The first command prints two actual finite demo journeys. The test command writes `author-test-results.json` beside the copied files, including actual snapshots and hashes. Tests create temporary directories only beside these lab files and remove their own temporary copies. They run a fresh Python subprocess and a copied four-file suite. They never edit the original fixture. Put your copy in a writable educational folder. The application itself reads its one code-owned fixture and keeps state in memory; it does not write records or contact a network. Test report and temporary-copy writes are performed by the test harness.

## Twelve records, twelve requests

All records and dates are invented. Eight records have supplied body keys. K03, K07, D02 and D04 intentionally have no body key. Labels such as sanitised, shared or privilege cannot supply a missing body or change a pending review. The JSON contains complete synthetic metadata, some held and retired bodies, and no real client document. Direct Python or filesystem access to it is possible. It is not encrypted, isolated or a security boundary.

| Request | Fixed record closure | Initial Ember | Initial Tidal |
| --- | --- | --- | --- |
| Q01 | K01, approved register v2 | Draft | Draft |
| Q02 | K04, approved date checklist v2 | Draft | Draft |
| Q03 | D01, Ember note | Draft | Hold |
| Q04 | D03, Tidal note | Hold | Draft |
| Q05 | D01 and D03 | Hold | Hold |
| Q06 | K02, retired register v1 | Hold | Hold |
| Q07 | K03, unreviewed candidate | Hold | Hold |
| Q08 | K06 and its D03 citation dependency | Hold | Draft |
| Q09 | K07, unresolved rights | Hold | Hold |
| Q10 | K08, expired day-1 reference | Hold | Hold |
| Q11 | D02, pending privilege classification | Hold | Hold |
| Q12 | D04, quarantined candidate | Hold | Hold |

Q05 cannot return even its first permitted excerpt. Q08 cannot expose its shared title, body, locator or restricted citation until the complete dependency closure is admitted. These rules are fixed illustrative policies, not a legal conclusion that a particular document is shareable. K02 and K05 remain retired. Withdrawing the newer date checklist does not revive K05.

## Exact interface

```text
Folio(actor_role)
state()
renew_authority(permission_version)
retrieve(query_id, matter_id, permission_version)
verify_result(query_id, matter_id, permission_version)
review_packet(matter_id, permission_version, reviewer_role, reviewer_token)
export_packet(matter_id, permission_version)
stop_work(reason)
apply_event(event_id, curator_role, curator_token)
resume_work(permission_version)
advance_day(day)
```

Construction accepts only exact built-in strings `ANALYST_EMBER`, `ANALYST_TIDAL` or `KNOWLEDGE_CURATOR`. Unknown or non-string roles raise `ValueError` before any fixture read. An analyst starts with one fixed matter membership; the curator has no retrieval membership. Constructor rejection is distinct from handled method failure and from Python argument-binding `TypeError`.

The simulated process starts active on day 2, permission version 1, verification sequence 0 and zero counters. Day 1 means fictional 30 September 2026; day 2 means fictional 1 October 2026. These numbers do not model a real retention schedule or elapsed wall-clock time. Actor authority is inclusive through day 4. K04 is usable through day 3. K08 expired with day 1.

An analyst must explicitly renew for the current version and day. Each source-related call checks the explicit matter, membership, active flag, inclusive authority window, exact current version and current renewal before loading the fixture. Neither a role label nor a shared precedent grants access to another matter. The method accepts fixed query IDs, not caller-supplied text, paths, citations, consent flags or rights decisions.

An initial Ember packet sequence is:

```python
from folio_lab import Folio

f = Folio("ANALYST_EMBER")
f.renew_authority(1)
for q in ("Q01", "Q02", "Q03"):
    f.retrieve(q, "MATTER-EMBER", 1)
    f.verify_result(q, "MATTER-EMBER", 1)
f.review_packet("MATTER-EMBER", 1,
                "ASSUMED_REVIEWER_EMBER", "ASSUMED-FOLIO-REVIEWER")
old_copy = f.export_packet("MATTER-EMBER", 1)
```

Check every returned status. This compact example assumes these exact calls succeed. Successful retrieval is `REFERENCE_DRAFT`; verification is `RESULT_VERIFIED`; scoped review is `INTERNAL_REFERENCE_REVIEW`; export is `INTERNAL_REFERENCE_PACKET`. A complete initial Tidal packet instead requires Q01, Q02, Q04 and Q08 plus the Tidal reviewer. Review checks every and at least one currently eligible query. Running all twelve challenges includes holds, so it clears reusable successes and cannot itself build a packet. Rebuild the eligible set afterwards without an intervening handled failure.

## Failure, currentness and source bindings

A handled failure returns the same generic `HOLD_REFERENCE_UNAVAILABLE` object, empty results and citations, and safe explanatory text. It echoes no rejected source identifier, title, body, locator, count or specific rejection cause. It clears renewal, retrievals, verifications, review and packet. It preserves the substantive day, active flag, version, membership overlays, lifecycle overlays and lifetime counters. The caller must renew and rebuild again where still eligible.

All method parameters use exact built-in types. A version must be a positive exact integer equal to the current version. Bool is excluded. A new day must be an exact integer strictly greater than the previous day. `stop_work` accepts an exact string containing 1 through 240 raw Python characters and nonempty stripped content. It neither coerces a value nor trims an overlong value into validity. A valid stop may repeat. Invalid controls leave prior substantive state intact while applying the normal cache-clearing rule.

Wrong signature calls, such as an unknown keyword or missing required argument, raise Python `TypeError` before the method body. They leave the entire existing state unchanged. That is not a handled denial and would need deliberate wrapper treatment in any future real service.

The fixture path is fixed beside the implementation. Every admitted source call rereads the whole file. The loader checks its pinned raw SHA256, exact schema, unique record/query bindings, exact types and canonical complete-record digests. Altering a title or locator also breaks the binding. No fallback file or old cached fixture is used. Missing files are held; malformed or modified files are held after their bytes are read. Local code constants and Python state remain mutable, so this is reproducible byte checking, not secure storage or authenticated source ownership.

`sourceDigest` is SHA256 of complete-record UTF-8 JSON with sorted keys and fixed separators. It includes the supplied metadata and body, when present. It binds to synthetic bytes. It does not prove source authenticity, privilege, permission, truth or identity.

## Counters and reusable reviews

`state()` returns a deep copy of aggregate counts, flags and administrative values. It contains no corpus identifiers, titles, locators, citations or bodies. Its `claims` values are all false. Returned results, state and packets are independent deep copies.

`logicalSnippetSources` starts at zero and increments once for each body returned by a successful `retrieve`, including dependencies and repeat retrievals. Initial all-query journeys, with renewal before each query, produce Ember 3 drafts/9 holds/3 logical source occurrences and Tidal 4 drafts/8 holds/5 occurrences. Each journey performs 12 physical fixture loads, including held source closures. These are finite illustrative targets that the author tests check; consult the actual report rather than treating this README as independent observed approval.

`physicalFixtureLoads` counts completed whole-file byte reads, including bytes subsequently rejected for integrity or parse issues. Missing-file attempts do not increment it. Gate-denied requests do not read it. Physical loading can include held metadata and retained synthetic bodies; zero new logical snippets does not mean zero physical read or secure exclusion from local memory.

Verification, review and export reread the fixture but do not increment the logical retrieval counter. A minimal Ember packet performs eight physical loads: three retrievals, three verifications, one review and one export. Its logical source total is three and verification sequence three.

Every successful verification, including repeat verification, increments the lifetime verification sequence. Retrieval, invalidation, failure, renewal, review, export, stop, event, resume and day advancement do not reset it. Fresh retrieval removes its own verification and any prior review or packet. New successful verification requires a new complete review. Review binds the aggregate current sequence and complete current result fingerprints; individual verification records need not carry identical sequence numbers. This sequence is not a durable audit log.

## Withdrawal, revocation and explicit recovery

Only a stopped instance accepts an exact unused event with `KNOWLEDGE_CURATOR` and `ASSUMED-FOLIO-CURATOR`. The labels and tokens are assumed strings, not credentials. `WITHDRAW-K04` changes K04 to withdrawn, leaves K05 retired and increments permission version once. `REVOKE-EMBER` removes the Ember analyst and reviewer memberships while leaving Tidal membership intact. Events may occur in either order, once each. Unknown, repeated or invalid events do not change lifecycle, membership or version. A valid event never resumes work.

After withdrawal, `resume_work(2)` only reactivates an eligible unexpired actor. It does not renew. Explicit renewal and fresh retrieval, verification and review are still required. On day 2 after withdrawal, Ember Q01 and Q03 remain eligible; Q02 cannot be replaced with a retired record. After advancing to day 4 the same two queries remain eligible because K04 has expired. On day 5 the actor cannot renew even though an instance may remain active. Failed resume preserves the prior active flag; it does not implicitly stop an active instance.

The revocation test first builds a three-source Ember packet and retains its exported copy. Revocation leaves lifetime logical snippets and verification sequence at three. Then twelve current-version retrieval calls, eight separate old/current direct-method probes and two separate resume/renew controls add zero snippets. The previously exported copy still contains its three excerpts. It is not erased. Tests distinguish stopped-state denial from stale-version denial and removed membership, including an explicitly labelled white-box causal probe that removes stopped/renewal causes. That mutable-internal probe is not an authorised public workflow or evidence of production security.

A fresh process starts the original day, version, memberships and lifecycle, with zero counters and sequence. Prior withdrawals and revocations are not durable. In a real architecture authenticated identity, per-request matter policies, durable revocation, index/snippet/citation/cache/export/log coverage, controlled copies, curation and source-owner rights, provider contracts, accessibility, incident controls and qualified jurisdiction review would remain separate work.

No actual client documents, model runs, identity checks, privilege decisions, verified client consent, approved lawful basis, real curation approval, professional review, legal advice approval, secure authorisation, durable audit or source-owner-rights verification are supplied. This lab does not determine conflicts, a retainer, legal entitlement, disclosure duties or professional competence. SRA England-and-Wales rules and scoped UK privacy sources inform the proposed course, but their interpretation and application to an actual matter are not decided here. No real learner, client, account or service is tested.

{
  "schemaVersion": "folio-records-v1",
  "records": [
    {
      "sourceId": "K01",
      "kind": "CURATED_PRECEDENT",
      "matter": "SHARED",
      "family": "REGISTER",
      "version": 2,
      "curationStatus": "APPROVED_FICTIONAL",
      "usableThroughDay": 4,
      "title": "Approved register template v2",
      "sourceLocator": "folio://K01/v2/line/1",
      "citationDependencies": [],
      "rightsStatus": "FICTIONAL_ALLOWED",
      "privilegeReview": "NOT_DECIDED_NOT_REQUIRED_FOR_SYNTHETIC_RECORD",
      "issueDate": "2026-09-29",
      "curationDate": "2026-09-30",
      "fictional": true,
      "actualClientDocument": false,
      "body": "Folio template v2 lists a source owner, review date and internal release note. This is fictional knowledge-administration wording, not legal advice."
    },
    {
      "sourceId": "K02",
      "kind": "CURATED_PRECEDENT",
      "matter": "SHARED",
      "family": "REGISTER",
      "version": 1,
      "curationStatus": "RETIRED",
      "usableThroughDay": 4,
      "title": "Retired register template v1",
      "sourceLocator": "folio://K02/v1/line/1",
      "citationDependencies": [],
      "rightsStatus": "FICTIONAL_ALLOWED",
      "privilegeReview": "NOT_DECIDED_NOT_REQUIRED_FOR_SYNTHETIC_RECORD",
      "issueDate": "2026-09-29",
      "curationDate": "2026-09-30",
      "fictional": true,
      "actualClientDocument": false,
      "body": "Retired v1 omits the release note. It is retained as a fictional archive copy and must not be used as current guidance."
    },
    {
      "sourceId": "K03",
      "kind": "CURATION_CANDIDATE",
      "matter": "SHARED",
      "family": "SANITISATION",
      "version": 1,
      "curationStatus": "PENDING_REVIEW",
      "usableThroughDay": 4,
      "title": "Unreviewed candidate",
      "sourceLocator": "folio://K03/v1/line/1",
      "citationDependencies": [],
      "rightsStatus": "UNRESOLVED",
      "privilegeReview": "NOT_DECIDED_NOT_REQUIRED_FOR_SYNTHETIC_RECORD",
      "issueDate": "2026-09-29",
      "curationDate": "2026-09-30",
      "fictional": true,
      "actualClientDocument": false
    },
    {
      "sourceId": "K04",
      "kind": "CURATED_PRECEDENT",
      "matter": "SHARED",
      "family": "DATES",
      "version": 2,
      "curationStatus": "APPROVED_FICTIONAL",
      "usableThroughDay": 3,
      "title": "Approved date checklist v2",
      "sourceLocator": "folio://K04/v2/line/1",
      "citationDependencies": [],
      "rightsStatus": "FICTIONAL_ALLOWED",
      "privilegeReview": "NOT_DECIDED_NOT_REQUIRED_FOR_SYNTHETIC_RECORD",
      "issueDate": "2026-09-29",
      "curationDate": "2026-09-30",
      "fictional": true,
      "actualClientDocument": false,
      "body": "Folio checklist v2 distinguishes an issue date from a curation date. No client event or legal conclusion is asserted."
    },
    {
      "sourceId": "K05",
      "kind": "CURATED_PRECEDENT",
      "matter": "SHARED",
      "family": "DATES",
      "version": 1,
      "curationStatus": "RETIRED",
      "usableThroughDay": 4,
      "title": "Retired date checklist v1",
      "sourceLocator": "folio://K05/v1/line/1",
      "citationDependencies": [],
      "rightsStatus": "FICTIONAL_ALLOWED",
      "privilegeReview": "NOT_DECIDED_NOT_REQUIRED_FOR_SYNTHETIC_RECORD",
      "issueDate": "2026-09-29",
      "curationDate": "2026-09-30",
      "fictional": true,
      "actualClientDocument": false,
      "body": "Retired checklist v1 has no curation-date field. It is not a replacement after v2 withdrawal."
    },
    {
      "sourceId": "K06",
      "kind": "CURATED_PRECEDENT",
      "matter": "SHARED",
      "family": "CROSS_REFERENCE",
      "version": 1,
      "curationStatus": "APPROVED_FICTIONAL",
      "usableThroughDay": 4,
      "title": "Curated cross-reference note",
      "sourceLocator": "folio://K06/v1/line/1",
      "citationDependencies": [
        "D03"
      ],
      "rightsStatus": "FICTIONAL_ALLOWED",
      "privilegeReview": "NOT_DECIDED_NOT_REQUIRED_FOR_SYNTHETIC_RECORD",
      "issueDate": "2026-09-29",
      "curationDate": "2026-09-30",
      "fictional": true,
      "actualClientDocument": false,
      "body": "This fictional cross-reference points to a matter note. Retrieval must check the referenced matter before exposing the link."
    },
    {
      "sourceId": "K07",
      "kind": "CURATION_CANDIDATE",
      "matter": "SHARED",
      "family": "RIGHTS",
      "version": 1,
      "curationStatus": "PENDING_RIGHTS",
      "usableThroughDay": 4,
      "title": "Rights-unresolved candidate",
      "sourceLocator": "folio://K07/v1/line/1",
      "citationDependencies": [],
      "rightsStatus": "UNRESOLVED",
      "privilegeReview": "NOT_DECIDED_NOT_REQUIRED_FOR_SYNTHETIC_RECORD",
      "issueDate": "2026-09-29",
      "curationDate": "2026-09-30",
      "fictional": true,
      "actualClientDocument": false
    },
    {
      "sourceId": "K08",
      "kind": "CURATED_PRECEDENT",
      "matter": "SHARED",
      "family": "OLD_REVIEW",
      "version": 1,
      "curationStatus": "APPROVED_FICTIONAL",
      "usableThroughDay": 1,
      "title": "Expired reference",
      "sourceLocator": "folio://K08/v1/line/1",
      "citationDependencies": [],
      "rightsStatus": "FICTIONAL_ALLOWED",
      "privilegeReview": "NOT_DECIDED_NOT_REQUIRED_FOR_SYNTHETIC_RECORD",
      "issueDate": "2026-09-29",
      "curationDate": "2026-09-30",
      "fictional": true,
      "actualClientDocument": false,
      "body": "This fictional reference passed a review on day 1 only; its return window ended with that day."
    },
    {
      "sourceId": "D01",
      "kind": "MATTER_RECORD",
      "matter": "MATTER-EMBER",
      "family": "EMBER_INDEX",
      "version": 1,
      "curationStatus": "APPROVED_FICTIONAL",
      "usableThroughDay": 4,
      "title": "Ember register note",
      "sourceLocator": "folio://D01/v1/line/1",
      "citationDependencies": [],
      "rightsStatus": "FICTIONAL_ALLOWED",
      "privilegeReview": "NOT_DECIDED_NOT_REQUIRED_FOR_SYNTHETIC_RECORD",
      "issueDate": "2026-09-29",
      "curationDate": "2026-09-30",
      "fictional": true,
      "actualClientDocument": false,
      "body": "The Ember source register records a draft index entry EM-4. It does not record a legal outcome."
    },
    {
      "sourceId": "D02",
      "kind": "MATTER_RECORD",
      "matter": "MATTER-EMBER",
      "family": "EMBER_PRIVILEGE",
      "version": 1,
      "curationStatus": "PENDING_PRIVILEGE_REVIEW",
      "usableThroughDay": 4,
      "title": "Restricted classification candidate",
      "sourceLocator": "folio://D02/v1/line/1",
      "citationDependencies": [],
      "rightsStatus": "FICTIONAL_ALLOWED",
      "privilegeReview": "UNRESOLVED",
      "issueDate": "2026-09-29",
      "curationDate": "2026-09-30",
      "fictional": true,
      "actualClientDocument": false
    },
    {
      "sourceId": "D03",
      "kind": "MATTER_RECORD",
      "matter": "MATTER-TIDAL",
      "family": "TIDAL_INDEX",
      "version": 1,
      "curationStatus": "APPROVED_FICTIONAL",
      "usableThroughDay": 4,
      "title": "Tidal register note",
      "sourceLocator": "folio://D03/v1/line/1",
      "citationDependencies": [],
      "rightsStatus": "FICTIONAL_ALLOWED",
      "privilegeReview": "NOT_DECIDED_NOT_REQUIRED_FOR_SYNTHETIC_RECORD",
      "issueDate": "2026-09-29",
      "curationDate": "2026-09-30",
      "fictional": true,
      "actualClientDocument": false,
      "body": "The Tidal source register records a draft index entry TI-9. It does not record a legal outcome."
    },
    {
      "sourceId": "D04",
      "kind": "MATTER_RECORD",
      "matter": "MATTER-TIDAL",
      "family": "TIDAL_QUARANTINE",
      "version": 1,
      "curationStatus": "QUARANTINED",
      "usableThroughDay": 4,
      "title": "Quarantined matter candidate",
      "sourceLocator": "folio://D04/v1/line/1",
      "citationDependencies": [],
      "rightsStatus": "FICTIONAL_ALLOWED",
      "privilegeReview": "NOT_DECIDED_NOT_REQUIRED_FOR_SYNTHETIC_RECORD",
      "issueDate": "2026-09-29",
      "curationDate": "2026-09-30",
      "fictional": true,
      "actualClientDocument": false
    }
  ],
  "queries": [
    {
      "queryId": "Q01",
      "task": "Locate the current register template",
      "sourceIds": [
        "K01"
      ],
      "purpose": "INTERNAL_KNOWLEDGE_CHECK"
    },
    {
      "queryId": "Q02",
      "task": "Locate the date checklist",
      "sourceIds": [
        "K04"
      ],
      "purpose": "INTERNAL_KNOWLEDGE_CHECK"
    },
    {
      "queryId": "Q03",
      "task": "Inspect the Ember register entry",
      "sourceIds": [
        "D01"
      ],
      "purpose": "INTERNAL_KNOWLEDGE_CHECK"
    },
    {
      "queryId": "Q04",
      "task": "Inspect the Tidal register entry",
      "sourceIds": [
        "D03"
      ],
      "purpose": "INTERNAL_KNOWLEDGE_CHECK"
    },
    {
      "queryId": "Q05",
      "task": "Combine both matter register entries",
      "sourceIds": [
        "D01",
        "D03"
      ],
      "purpose": "INTERNAL_KNOWLEDGE_CHECK"
    },
    {
      "queryId": "Q06",
      "task": "Use a retired register template",
      "sourceIds": [
        "K02"
      ],
      "purpose": "INTERNAL_KNOWLEDGE_CHECK"
    },
    {
      "queryId": "Q07",
      "task": "Use a candidate labelled sanitised before review",
      "sourceIds": [
        "K03"
      ],
      "purpose": "INTERNAL_KNOWLEDGE_CHECK"
    },
    {
      "queryId": "Q08",
      "task": "Expose a shared note with a Tidal citation",
      "sourceIds": [
        "K06"
      ],
      "purpose": "INTERNAL_KNOWLEDGE_CHECK"
    },
    {
      "queryId": "Q09",
      "task": "Use a rights-unresolved candidate",
      "sourceIds": [
        "K07"
      ],
      "purpose": "INTERNAL_KNOWLEDGE_CHECK"
    },
    {
      "queryId": "Q10",
      "task": "Use an expired reference",
      "sourceIds": [
        "K08"
      ],
      "purpose": "INTERNAL_KNOWLEDGE_CHECK"
    },
    {
      "queryId": "Q11",
      "task": "Infer privilege clearance from a matter label",
      "sourceIds": [
        "D02"
      ],
      "purpose": "INTERNAL_KNOWLEDGE_CHECK"
    },
    {
      "queryId": "Q12",
      "task": "Read a quarantined record",
      "sourceIds": [
        "D04"
      ],
      "purpose": "INTERNAL_KNOWLEDGE_CHECK"
    }
  ]
}

"""Folio: fictional, finite administrative references, not a secure legal service.

No network, OCR, model, vector store or persistent state. All public real-use
outputs remain held. Labels and tokens are assumptions, not identity checks.
"""
from copy import deepcopy
import hashlib
import json
from pathlib import Path

FIXTURE_SHA256 = "97409cf6b09f63c7abea6208987eb40d5eeb2bd0ca067d020bea85598bbd2bdf"
RECORD_DIGESTS = {'D01': 'c9f4ed97bef954cae3cabd95eb1862c8aef5ce26575d5af4e100088e858894ae',
 'D02': '483a494524585b23b0b4c523cc2c9f25f448c3be8ea9a44d8091d77f23ed037c',
 'D03': 'a506673b0e9fac7961586a40427569d2c650346479c3d9707fa8d2f5ac177fcc',
 'D04': '6dfbb58fcc24ed94d3cfbdd5e996154b82c6e6a5094d4bb74bba189a4b767699',
 'K01': '6608561e67c97e453ac9e3b7e578c73140ef53963543a2ad9a0778f271494527',
 'K02': '940bc6e1b8c072904488574b7738e198543286481a59e516fdf3e1adc378db37',
 'K03': 'a7c5d6249a712db6d3569150b6823b45b8d613bd92870baa87fd578898a0837f',
 'K04': 'ef97e8d11831cd2d394c189b1ff38a130c94ccb9278b96bd9a354590b60fea88',
 'K05': '2f251f935f80a60d15b84dcb6b37b14658e5d77e1f4e248a569a1cf8c6a94515',
 'K06': '78423bbaba6b133eba2574c1be385cc66b7ece3324841491e7c7f0c16d66f560',
 'K07': 'b907a5a7c475772cf12060c1ae6c3efca161e76aff8c1028ea371a1f83757903',
 'K08': '4ea2be409a3cd12813d4b28e575aeb8072391a0765761877f0df9a3ad7bfbcce'}
QUERY_DEFINITIONS = ({'queryId': 'Q01',
  'task': 'Locate the current register template',
  'sourceIds': ['K01'],
  'purpose': 'INTERNAL_KNOWLEDGE_CHECK'},
 {'queryId': 'Q02',
  'task': 'Locate the date checklist',
  'sourceIds': ['K04'],
  'purpose': 'INTERNAL_KNOWLEDGE_CHECK'},
 {'queryId': 'Q03',
  'task': 'Inspect the Ember register entry',
  'sourceIds': ['D01'],
  'purpose': 'INTERNAL_KNOWLEDGE_CHECK'},
 {'queryId': 'Q04',
  'task': 'Inspect the Tidal register entry',
  'sourceIds': ['D03'],
  'purpose': 'INTERNAL_KNOWLEDGE_CHECK'},
 {'queryId': 'Q05',
  'task': 'Combine both matter register entries',
  'sourceIds': ['D01', 'D03'],
  'purpose': 'INTERNAL_KNOWLEDGE_CHECK'},
 {'queryId': 'Q06',
  'task': 'Use a retired register template',
  'sourceIds': ['K02'],
  'purpose': 'INTERNAL_KNOWLEDGE_CHECK'},
 {'queryId': 'Q07',
  'task': 'Use a candidate labelled sanitised before review',
  'sourceIds': ['K03'],
  'purpose': 'INTERNAL_KNOWLEDGE_CHECK'},
 {'queryId': 'Q08',
  'task': 'Expose a shared note with a Tidal citation',
  'sourceIds': ['K06'],
  'purpose': 'INTERNAL_KNOWLEDGE_CHECK'},
 {'queryId': 'Q09',
  'task': 'Use a rights-unresolved candidate',
  'sourceIds': ['K07'],
  'purpose': 'INTERNAL_KNOWLEDGE_CHECK'},
 {'queryId': 'Q10',
  'task': 'Use an expired reference',
  'sourceIds': ['K08'],
  'purpose': 'INTERNAL_KNOWLEDGE_CHECK'},
 {'queryId': 'Q11',
  'task': 'Infer privilege clearance from a matter label',
  'sourceIds': ['D02'],
  'purpose': 'INTERNAL_KNOWLEDGE_CHECK'},
 {'queryId': 'Q12',
  'task': 'Read a quarantined record',
  'sourceIds': ['D04'],
  'purpose': 'INTERNAL_KNOWLEDGE_CHECK'})
CLAIMS = {name: False for name in (
    "actualClientDocument", "actualModelRun", "actualIdentityVerified",
    "actualPrivilegeDecision", "actualClientConsentVerified",
    "actualLawfulBasisApproved", "actualCurationApproved", "actualProfessionalReview",
    "actualLegalAdviceApproved", "actualSecureAuthorisation", "actualDurableAudit",
    "actualSourceOwnerRightsVerified",
)}
_HOLD = {
    "status": "HOLD_REFERENCE_UNAVAILABLE", "realUseStatus": "HOLD",
    "results": [], "citations": [],
    "details": "No protected identifier/title/content is echoed. Administrative safe failure evidence may record method name, day and version only, not protected text.",
}
_LIMIT = "Fictional administrative reference only. Not legal advice or professional approval."


def _digest(value):
    raw = json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
    return hashlib.sha256(raw).hexdigest()


def _unique_object(pairs):
    result = {}
    for key, value in pairs:
        if key in result:
            raise ValueError("duplicate JSON key")
        result[key] = value
    return result


class Folio:
    """Mutable assumed local state. Caller-owned old copies cannot be erased."""

    def __init__(self, actor_role):
        if type(actor_role) is not str or actor_role not in (
            "ANALYST_EMBER", "ANALYST_TIDAL", "KNOWLEDGE_CURATOR"
        ):
            raise ValueError("Choose an exact fictional actor role.")
        self._actor = actor_role
        self._day = 2
        self._version = 1
        self._active = True
        self._renewal = None
        self._retrievals = {}
        self._verifications = {}
        self._sequence = 0
        self._review = None
        self._packet = None
        self._snippets = 0
        self._loads = 0
        self._events = set()
        self._lifecycle = {}
        self._memberships = {
            "ANALYST_EMBER": {"MATTER-EMBER"},
            "ANALYST_TIDAL": {"MATTER-TIDAL"}, "KNOWLEDGE_CURATOR": set(),
            "ASSUMED_REVIEWER_EMBER": {"MATTER-EMBER"},
            "ASSUMED_REVIEWER_TIDAL": {"MATTER-TIDAL"},
        }

    def state(self):
        """Only aggregate administrative state; no corpus identifiers or text."""
        return deepcopy({
            "day": self._day, "permissionVersion": self._version,
            "active": self._active,
            "renewedAuthority": None if self._renewal is None else {
                "permissionVersion": self._renewal[0], "day": self._renewal[1]},
            "retrievalCount": len(self._retrievals),
            "verificationCount": len(self._verifications),
            "verificationSequence": self._sequence,
            "reviewPresent": self._review is not None,
            "packetPresent": self._packet is not None,
            "logicalSnippetSources": self._snippets,
            "physicalFixtureLoads": self._loads,
            "appliedEventCount": len(self._events),
            "actorMembershipCount": len(self._memberships[self._actor]),
            "realUseStatus": "HOLD", "claims": CLAIMS,
        })

    def _invalidate(self):
        self._renewal = None
        self._retrievals.clear()
        self._verifications.clear()
        self._review = None
        self._packet = None

    def _hold(self):
        self._invalidate()
        return deepcopy(_HOLD)

    def _success(self, status, **fields):
        return deepcopy({"status": status, "realUseStatus": "HOLD",
                         "day": self._day, "permissionVersion": self._version,
                         "claims": CLAIMS, **fields})

    def _current_version(self, value):
        return type(value) is int and value > 0 and value == self._version

    def _gate(self, matter, version):
        return (type(matter) is str and matter in ("MATTER-EMBER", "MATTER-TIDAL")
                and self._current_version(version) and self._active
                and self._day <= 4 and matter in self._memberships[self._actor]
                and self._renewal == (self._version, self._day))

    def _load(self):
        """Physical whole-file read; never count it as a returned logical snippet."""
        try:
            raw = Path(__file__).with_name("folio_records.json").read_bytes()
            self._loads += 1
            if hashlib.sha256(raw).hexdigest() != FIXTURE_SHA256:
                return None
            data = json.loads(raw, object_pairs_hook=_unique_object)
            if type(data) is not dict or set(data) != {"schemaVersion", "records", "queries"}:
                return None
            if data["schemaVersion"] != "folio-records-v1":
                return None
            if type(data["records"]) is not list or len(data["records"]) != 12:
                return None
            if type(data["queries"]) is not list or data["queries"] != list(QUERY_DEFINITIONS):
                return None
            records = {}
            for record in data["records"]:
                if type(record) is not dict:
                    return None
                sid = record.get("sourceId")
                if type(sid) is not str or sid not in RECORD_DIGESTS or sid in records:
                    return None
                if type(record.get("version")) is not int or record["version"] < 1:
                    return None
                if type(record.get("usableThroughDay")) is not int or record["usableThroughDay"] < 1:
                    return None
                if record.get("fictional") is not True or record.get("actualClientDocument") is not False:
                    return None
                if type(record.get("citationDependencies")) is not list:
                    return None
                if _digest(record) != RECORD_DIGESTS[sid]:
                    return None
                records[sid] = record
            if set(records) != set(RECORD_DIGESTS):
                return None
            for record in records.values():
                dependencies = record["citationDependencies"]
                if len(dependencies) != len(set(dependencies)) or any(x not in records for x in dependencies):
                    return None
            return records
        except (OSError, ValueError, TypeError, KeyError, UnicodeError):
            return None

    def _closure(self, query):
        ordered = []
        pending = list(query["sourceIds"])
        # Approved fixture has only K06 -> D03. Bindings prevent new graph edges.
        while pending:
            sid = pending.pop(0)
            if sid not in ordered:
                ordered.append(sid)
                if sid == "K06":
                    pending.append("D03")
        return ordered

    def _admitted(self, record, matter):
        return (self._lifecycle.get(record["sourceId"], record["curationStatus"]) == "APPROVED_FICTIONAL"
                and record["rightsStatus"] == "FICTIONAL_ALLOWED"
                and self._day <= record["usableThroughDay"]
                and record["matter"] in ("SHARED", matter)
                and type(record.get("body")) is str)

    def _query(self, qid):
        if type(qid) is not str:
            return None
        return next((q for q in QUERY_DEFINITIONS if q["queryId"] == qid), None)

    def _allowed(self, query, matter, records):
        return all(self._admitted(records[sid], matter) for sid in self._closure(query))

    def _project(self, query, matter, records):
        ids = self._closure(query)
        return {"status": "REFERENCE_DRAFT", "realUseStatus": "HOLD",
                "queryId": query["queryId"], "matterId": matter,
                "permissionVersion": self._version, "day": self._day,
                "excerpts": [records[sid]["body"] for sid in ids],
                "sources": [{"sourceId": sid, "version": records[sid]["version"],
                             "title": records[sid]["title"],
                             "sourceLocator": records[sid]["sourceLocator"],
                             "sourceDigest": _digest(records[sid])} for sid in ids],
                "limitations": _LIMIT}

    def renew_authority(self, permission_version):
        if (not self._current_version(permission_version) or not self._active
                or self._day > 4 or not self._memberships[self._actor]):
            return self._hold()
        self._renewal = (self._version, self._day)
        return self._success("AUTHORITY_RENEWED")

    def retrieve(self, query_id, matter_id, permission_version):
        query = self._query(query_id)
        if query is None or not self._gate(matter_id, permission_version):
            return self._hold()
        records = self._load()
        if records is None or not self._allowed(query, matter_id, records):
            return self._hold()
        result = self._project(query, matter_id, records)
        self._retrievals[query_id] = deepcopy(result)
        self._verifications.pop(query_id, None)
        self._review = None
        self._packet = None
        self._snippets += len(result["sources"])
        return deepcopy(result)

    def verify_result(self, query_id, matter_id, permission_version):
        query = self._query(query_id)
        if query is None or not self._gate(matter_id, permission_version):
            return self._hold()
        records = self._load()
        if records is None or not self._allowed(query, matter_id, records):
            return self._hold()
        expected = self._project(query, matter_id, records)
        if self._retrievals.get(query_id) != expected:
            return self._hold()
        self._sequence += 1
        self._verifications[query_id] = _digest(expected)
        self._review = None
        self._packet = None
        return self._success("RESULT_VERIFIED", queryId=query_id,
                             matterId=matter_id, verificationSequence=self._sequence)

    def _complete(self, matter, records):
        eligible = [q for q in QUERY_DEFINITIONS if self._allowed(q, matter, records)]
        if not eligible:
            return None
        for q in eligible:
            expected = self._project(q, matter, records)
            if (self._retrievals.get(q["queryId"]) != expected
                    or self._verifications.get(q["queryId"]) != _digest(expected)):
                return None
        return eligible

    def _review_binding(self, matter, eligible):
        return {"matterId": matter, "permissionVersion": self._version,
                "day": self._day, "verificationSequence": self._sequence,
                "fingerprints": {q["queryId"]: self._verifications[q["queryId"]] for q in eligible}}

    def review_packet(self, matter_id, permission_version, reviewer_role, reviewer_token):
        if (not self._gate(matter_id, permission_version)
                or type(reviewer_role) is not str
                or reviewer_role not in ("ASSUMED_REVIEWER_EMBER", "ASSUMED_REVIEWER_TIDAL")
                or matter_id not in self._memberships[reviewer_role]
                or type(reviewer_token) is not str or reviewer_token != "ASSUMED-FOLIO-REVIEWER"):
            return self._hold()
        records = self._load()
        eligible = None if records is None else self._complete(matter_id, records)
        if not eligible:
            return self._hold()
        self._review = {**self._review_binding(matter_id, eligible), "reviewerRole": reviewer_role}
        self._packet = None
        return self._success("INTERNAL_REFERENCE_REVIEW", matterId=matter_id,
                             verificationSequence=self._sequence, verifiedQueryCount=len(eligible))

    def export_packet(self, matter_id, permission_version):
        if not self._gate(matter_id, permission_version):
            return self._hold()
        records = self._load()
        eligible = None if records is None else self._complete(matter_id, records)
        if not eligible or self._review is None:
            return self._hold()
        binding = self._review_binding(matter_id, eligible)
        if any(self._review.get(k) != value for k, value in binding.items()):
            return self._hold()
        reviewer = self._review["reviewerRole"]
        if matter_id not in self._memberships.get(reviewer, set()):
            return self._hold()
        packet = self._success("INTERNAL_REFERENCE_PACKET", matterId=matter_id,
                               verificationSequence=self._sequence,
                               results=[self._retrievals[q["queryId"]] for q in eligible],
                               review={"reviewerRole": reviewer, "assumedOnly": True}, limitations=_LIMIT)
        self._packet = deepcopy(packet)
        return deepcopy(packet)

    def stop_work(self, reason):
        if type(reason) is not str or not 1 <= len(reason) <= 240 or not reason.strip():
            return self._hold()
        self._active = False
        self._invalidate()
        return self._success("WORK_STOPPED")

    def apply_event(self, event_id, curator_role, curator_token):
        if (self._active or type(event_id) is not str
                or event_id not in ("WITHDRAW-K04", "REVOKE-EMBER") or event_id in self._events
                or type(curator_role) is not str or curator_role != "KNOWLEDGE_CURATOR"
                or type(curator_token) is not str or curator_token != "ASSUMED-FOLIO-CURATOR"):
            return self._hold()
        if event_id == "WITHDRAW-K04":
            self._lifecycle["K04"] = "WITHDRAWN"
        else:
            self._memberships["ANALYST_EMBER"].discard("MATTER-EMBER")
            self._memberships["ASSUMED_REVIEWER_EMBER"].discard("MATTER-EMBER")
        self._events.add(event_id)
        self._version += 1
        self._invalidate()
        return self._success("SOURCE_EVENT_APPLIED")

    def resume_work(self, permission_version):
        if (not self._current_version(permission_version) or self._active
                or self._day > 4 or not self._memberships[self._actor]):
            return self._hold()
        self._active = True
        self._invalidate()
        return self._success("WORK_RESUMED")

    def advance_day(self, day):
        if type(day) is not int or day <= self._day:
            return self._hold()
        self._day = day
        self._invalidate()
        return self._success("DAY_ADVANCED")


if __name__ == "__main__":
    snapshots = []
    for actor, matter in (("ANALYST_EMBER", "MATTER-EMBER"), ("ANALYST_TIDAL", "MATTER-TIDAL")):
        folio = Folio(actor)
        rows = []
        for q in QUERY_DEFINITIONS:
            folio.renew_authority(1)
            result = folio.retrieve(q["queryId"], matter, 1)
            rows.append({"queryId": q["queryId"], "status": result["status"]})
        snapshots.append({"actor": actor, "results": rows, "state": folio.state()})
    print(json.dumps({"scope": "Actual finite fictional demo, no model or real authority.", "snapshots": snapshots}, indent=2))

"""Author contract tests. Passing is not independent or professional approval."""
from copy import deepcopy
import hashlib
import inspect
import json
import os
from pathlib import Path
import shutil
import subprocess
import sys
import tempfile
import unittest
from unittest.mock import patch

from folio_lab import Folio, FIXTURE_SHA256, RECORD_DIGESTS

HERE = Path(__file__).resolve().parent
MATTER = "MATTER-EMBER"
CURATOR = ("KNOWLEDGE_CURATOR", "ASSUMED-FOLIO-CURATOR")
REVIEWER = ("ASSUMED_REVIEWER_EMBER", "ASSUMED-FOLIO-REVIEWER")
HOLD = "HOLD_REFERENCE_UNAVAILABLE"
SNAPSHOTS = {}


def packet(f, ids=("Q01", "Q02", "Q03"), matter=MATTER, reviewer=REVIEWER):
    version = f.state()["permissionVersion"]
    assert f.renew_authority(version)["status"] == "AUTHORITY_RENEWED"
    for q in ids:
        assert f.retrieve(q, matter, version)["status"] == "REFERENCE_DRAFT"
        assert f.verify_result(q, matter, version)["status"] == "RESULT_VERIFIED"
    assert f.review_packet(matter, version, *reviewer)["status"] == "INTERNAL_REFERENCE_REVIEW"
    return f.export_packet(matter, version)


class FolioAuthorTests(unittest.TestCase):
    def fresh(self, actor="ANALYST_EMBER"):
        return Folio(actor)

    def ready(self):
        f = self.fresh()
        self.assertEqual(f.renew_authority(1)["status"], "AUTHORITY_RENEWED")
        return f

    def held(self, result):
        self.assertEqual(result["status"], HOLD)
        self.assertEqual(result["results"], [])
        self.assertEqual(result["citations"], [])
        self.assertEqual(result["realUseStatus"], "HOLD")
        text = json.dumps(result)
        for prohibited in ("folio://", "Ember register note", "Tidal register note", "TI-9", "EM-4", "K06", "D03"):
            self.assertNotIn(prohibited, text)

    def clean_caches(self, f):
        s = f.state()
        self.assertIsNone(s["renewedAuthority"])
        self.assertEqual(s["retrievalCount"], 0)
        self.assertEqual(s["verificationCount"], 0)
        self.assertFalse(s["reviewPresent"])
        self.assertFalse(s["packetPresent"])

    def test_01_exact_signatures(self):
        signatures = {
            "__init__": "(self, actor_role)", "state": "(self)",
            "renew_authority": "(self, permission_version)",
            "retrieve": "(self, query_id, matter_id, permission_version)",
            "verify_result": "(self, query_id, matter_id, permission_version)",
            "review_packet": "(self, matter_id, permission_version, reviewer_role, reviewer_token)",
            "export_packet": "(self, matter_id, permission_version)",
            "stop_work": "(self, reason)",
            "apply_event": "(self, event_id, curator_role, curator_token)",
            "resume_work": "(self, permission_version)", "advance_day": "(self, day)",
        }
        self.assertEqual({n for n in Folio.__dict__ if not n.startswith("_")}, set(signatures) - {"__init__"})
        for name, signature in signatures.items():
            self.assertEqual(str(inspect.signature(getattr(Folio, name))), signature)

    def test_02_constructor_never_reads_and_rejects_unknown_roles(self):
        with patch.object(Path, "read_bytes", side_effect=AssertionError("constructor IO")):
            for actor in ("ANALYST_EMBER", "ANALYST_TIDAL", "KNOWLEDGE_CURATOR"):
                f = Folio(actor)
                self.assertEqual(f.state()["physicalFixtureLoads"], 0)
            for value in (True, None, [], "ASSUMED_REVIEWER_EMBER", "analyst_ember", "ANALYST_EMBER "):
                with self.assertRaises(ValueError):
                    Folio(value)

    def test_03_initial_state_is_aggregate_and_independent(self):
        f = self.fresh()
        s = f.state()
        self.assertEqual((s["day"], s["permissionVersion"], s["verificationSequence"]), (2, 1, 0))
        self.assertTrue(s["active"])
        self.assertEqual(s["logicalSnippetSources"], 0)
        self.assertEqual(s["physicalFixtureLoads"], 0)
        self.assertTrue(all(v is False for v in s["claims"].values()))
        for x in ("K01", "D03", "folio://", "body", "title", "sourceLocator"):
            self.assertNotIn(x, json.dumps(s))
        s["claims"]["actualSecureAuthorisation"] = True
        s["active"] = False
        self.assertTrue(f.state()["active"])
        self.assertFalse(f.state()["claims"]["actualSecureAuthorisation"])

    def test_04_fixture_exact_corpus_and_absent_bodies(self):
        raw = (HERE / "folio_records.json").read_bytes()
        self.assertEqual(hashlib.sha256(raw).hexdigest(), FIXTURE_SHA256)
        data = json.loads(raw)
        self.assertEqual(len(data["records"]), 12)
        self.assertEqual(len(data["queries"]), 12)
        self.assertEqual({r["sourceId"] for r in data["records"] if "body" not in r}, {"K03", "K07", "D02", "D04"})
        for r in data["records"]:
            canonical = json.dumps(r, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode()
            self.assertEqual(hashlib.sha256(canonical).hexdigest(), RECORD_DIGESTS[r["sourceId"]])

    def challenge(self, f, matter, drafts):
        rows = []
        version = f.state()["permissionVersion"]
        for n in range(1, 13):
            q = "Q%02d" % n
            self.assertEqual(f.renew_authority(version)["status"], "AUTHORITY_RENEWED")
            before = f.state()
            result = f.retrieve(q, matter, version)
            if q in drafts:
                self.assertEqual(result["status"], "REFERENCE_DRAFT")
                self.assertEqual(result["matterId"], matter)
                self.assertEqual(f.state()["logicalSnippetSources"] - before["logicalSnippetSources"], len(result["sources"]))
            else:
                self.held(result)
                self.assertEqual(f.state()["logicalSnippetSources"], before["logicalSnippetSources"])
            rows.append({"queryId": q, "status": result["status"]})
        return {"rows": rows, "state": f.state()}

    def test_05_all_twelve_ember_queries(self):
        f = self.fresh()
        SNAPSHOTS["initialEmber"] = self.challenge(f, MATTER, {"Q01", "Q02", "Q03"})
        self.assertEqual(f.state()["logicalSnippetSources"], 3)
        self.assertEqual(f.state()["physicalFixtureLoads"], 12)
        self.clean_caches(f)

    def test_06_all_twelve_tidal_queries_and_dependency_count(self):
        f = self.fresh("ANALYST_TIDAL")
        SNAPSHOTS["initialTidal"] = self.challenge(f, "MATTER-TIDAL", {"Q01", "Q02", "Q04", "Q08"})
        self.assertEqual(f.state()["logicalSnippetSources"], 5)
        self.assertEqual(f.state()["physicalFixtureLoads"], 12)

    def test_07_no_partial_mixed_matter_result_or_shared_citation(self):
        for actor, context in (("ANALYST_EMBER", MATTER), ("ANALYST_TIDAL", "MATTER-TIDAL")):
            f = self.fresh(actor)
            f.renew_authority(1)
            self.held(f.retrieve("Q05", context, 1))
            self.assertEqual(f.state()["logicalSnippetSources"], 0)
        f = self.ready()
        self.held(f.retrieve("Q08", MATTER, 1))
        self.assertEqual(f.state()["logicalSnippetSources"], 0)
        g = self.fresh("ANALYST_TIDAL")
        g.renew_authority(1)
        r = g.retrieve("Q08", "MATTER-TIDAL", 1)
        self.assertEqual([x["sourceId"] for x in r["sources"]], ["K06", "D03"])
        self.assertEqual(len(r["excerpts"]), 2)
        self.assertEqual(g.state()["logicalSnippetSources"], 2)

    def test_08_pre_read_authority_gate_and_explicit_context(self):
        f = self.ready()
        with patch.object(f, "_load", side_effect=AssertionError("gate should deny before IO")):
            self.held(f.retrieve("Q04", "MATTER-TIDAL", 1))
            f.renew_authority(1)
            self.held(f.retrieve("Q01", "SHARED", 1))
            f.renew_authority(1)
            self.held(f.retrieve("K01", MATTER, 1))
            f.renew_authority(1)
            self.held(f.retrieve("Q01", MATTER, 2))
        self.assertEqual(f.state()["physicalFixtureLoads"], 0)

    def test_09_no_candidate_or_retired_fallback(self):
        f = self.fresh()
        for q in ("Q06", "Q07", "Q09", "Q10", "Q11", "Q12"):
            f.renew_authority(1)
            self.held(f.retrieve(q, MATTER, 1))
        self.assertEqual(f.state()["logicalSnippetSources"], 0)

    def test_10_complete_packet_and_exact_counter_deltas(self):
        f = self.fresh()
        out = packet(f)
        self.assertEqual(out["status"], "INTERNAL_REFERENCE_PACKET")
        self.assertEqual([r["queryId"] for r in out["results"]], ["Q01", "Q02", "Q03"])
        self.assertEqual((f.state()["logicalSnippetSources"], f.state()["physicalFixtureLoads"], f.state()["verificationSequence"]), (3, 8, 3))
        self.assertEqual(out["realUseStatus"], "HOLD")
        self.assertTrue(all(x is False for x in out["claims"].values()))
        SNAPSHOTS["minimalEmberPacket"] = {"packet": out, "state": f.state()}

    def test_11_tidal_complete_packet_has_five_source_occurrences(self):
        f = self.fresh("ANALYST_TIDAL")
        out = packet(f, ("Q01", "Q02", "Q04", "Q08"), "MATTER-TIDAL",
                     ("ASSUMED_REVIEWER_TIDAL", "ASSUMED-FOLIO-REVIEWER"))
        self.assertEqual(out["status"], "INTERNAL_REFERENCE_PACKET")
        self.assertEqual(f.state()["logicalSnippetSources"], 5)
        self.assertEqual(f.state()["verificationSequence"], 4)
        self.assertEqual(f.state()["physicalFixtureLoads"], 10)

    def test_12_incomplete_and_empty_review_are_held(self):
        f = self.ready()
        f.retrieve("Q01", MATTER, 1)
        f.verify_result("Q01", MATTER, 1)
        self.held(f.review_packet(MATTER, 1, *REVIEWER))
        self.clean_caches(f)
        self.assertEqual(f.state()["verificationSequence"], 1)
        f = self.fresh("KNOWLEDGE_CURATOR")
        self.held(f.renew_authority(1))
        self.held(f.review_packet(MATTER, 1, *REVIEWER))
        self.held(f.export_packet(MATTER, 1))
        self.assertEqual(f.state()["physicalFixtureLoads"], 0)

    def test_13_wrong_reviewer_does_not_read_or_export(self):
        for role, token in (("ASSUMED_REVIEWER_TIDAL", REVIEWER[1]), ("ANALYST_EMBER", REVIEWER[1]), (REVIEWER[0], "forged"), ([], REVIEWER[1]), (REVIEWER[0], True)):
            f = self.fresh()
            packet(f)
            before = f.state()
            self.held(f.review_packet(MATTER, 1, role, token))
            self.assertEqual(f.state()["physicalFixtureLoads"], before["physicalFixtureLoads"])
            self.assertEqual(f.state()["verificationSequence"], 3)
            self.clean_caches(f)

    def test_14_successful_retrieval_invalidates_own_verification_and_review(self):
        f = self.fresh()
        old = packet(f)
        f.retrieve("Q01", MATTER, 1)
        self.assertEqual(f.state()["verificationCount"], 2)
        self.assertFalse(f.state()["reviewPresent"])
        self.assertFalse(f.state()["packetPresent"])
        self.assertEqual(f.state()["verificationSequence"], 3)
        self.assertEqual(f.verify_result("Q01", MATTER, 1)["verificationSequence"], 4)
        f.review_packet(MATTER, 1, *REVIEWER)
        self.assertEqual(f.export_packet(MATTER, 1)["verificationSequence"], 4)
        self.assertEqual(old["verificationSequence"], 3)

    def test_15_reverification_requires_new_review_without_new_snippets(self):
        f = self.fresh()
        packet(f)
        f.verify_result("Q02", MATTER, 1)
        self.assertEqual(f.state()["verificationSequence"], 4)
        self.assertEqual(f.state()["logicalSnippetSources"], 3)
        self.assertFalse(f.state()["reviewPresent"])
        self.held(f.export_packet(MATTER, 1))
        self.assertEqual(f.state()["verificationSequence"], 4)

    def test_16_verify_before_retrieve_and_internal_tamper_fail(self):
        f = self.ready()
        self.held(f.verify_result("Q01", MATTER, 1))
        self.assertEqual(f.state()["verificationSequence"], 0)
        f.renew_authority(1)
        f.retrieve("Q01", MATTER, 1)
        # White-box cache corruption probe, not a public caller capability.
        f._retrievals["Q01"]["sources"][0]["title"] = "invented"
        self.held(f.verify_result("Q01", MATTER, 1))
        self.assertEqual(f.state()["verificationSequence"], 0)

    def test_17_handled_failure_clears_all_caches_not_lifetime_counters(self):
        f = self.fresh()
        packet(f)
        before = f.state()
        self.held(f.retrieve("Q99", MATTER, 1))
        self.clean_caches(f)
        for key in ("day", "permissionVersion", "active", "logicalSnippetSources", "verificationSequence", "physicalFixtureLoads", "actorMembershipCount"):
            self.assertEqual(f.state()[key], before[key])

    def test_18_typeerror_before_body_keeps_exact_state(self):
        f = self.fresh()
        packet(f)
        before = f.state()
        calls = [lambda: f.retrieve("Q01", MATTER, 1, bypass=True),
                 lambda: f.review_packet(MATTER, 1, *REVIEWER, extra=True),
                 lambda: f.stop_work(), lambda: f.advance_day(3, 4),
                 lambda: f.renew_authority(permission=1)]
        for call in calls:
            with self.assertRaises(TypeError):
                call()
            self.assertEqual(f.state(), before)
        self.assertEqual(f.export_packet(MATTER, 1)["status"], "INTERNAL_REFERENCE_PACKET")

    def test_19_deep_copy_result_state_packet_and_claims(self):
        f = self.ready()
        result = f.retrieve("Q01", MATTER, 1)
        result["excerpts"][0] = "caller edit"
        result["sources"][0]["title"] = "caller title"
        self.assertEqual(f.verify_result("Q01", MATTER, 1)["status"], "RESULT_VERIFIED")
        out = packet(f)
        out["results"][0]["sources"].clear()
        out["claims"]["actualPrivilegeDecision"] = True
        second = f.export_packet(MATTER, 1)
        self.assertEqual(len(second["results"][0]["sources"]), 1)
        self.assertFalse(second["claims"]["actualPrivilegeDecision"])

    def test_20_stop_resume_requires_explicit_new_renewal(self):
        f = self.fresh()
        packet(f)
        self.assertEqual(f.stop_work("pause for source owner")["status"], "WORK_STOPPED")
        self.assertFalse(f.state()["active"])
        self.assertEqual(f.state()["actorMembershipCount"], 1)
        self.held(f.retrieve("Q01", MATTER, 1))
        self.assertEqual(f.resume_work(1)["status"], "WORK_RESUMED")
        self.assertIsNone(f.state()["renewedAuthority"])
        self.held(f.retrieve("Q01", MATTER, 1))
        f.renew_authority(1)
        self.assertEqual(f.retrieve("Q01", MATTER, 1)["status"], "REFERENCE_DRAFT")
        self.assertEqual(f.state()["logicalSnippetSources"], 4)
        self.assertEqual(f.state()["verificationSequence"], 3)

    def test_21_withdrawal_all_queries_version_and_no_fallback(self):
        f = self.fresh()
        f.stop_work("withdraw source")
        self.assertEqual(f.apply_event("WITHDRAW-K04", *CURATOR)["status"], "SOURCE_EVENT_APPLIED")
        self.assertFalse(f.state()["active"])
        self.assertEqual(f.state()["permissionVersion"], 2)
        self.held(f.resume_work(1))
        self.assertEqual(f.resume_work(2)["status"], "WORK_RESUMED")
        SNAPSHOTS["withdrawalEmber"] = self.challenge(f, MATTER, {"Q01", "Q03"})
        self.assertEqual(f.state()["logicalSnippetSources"], 2)
        self.assertEqual(f.state()["physicalFixtureLoads"], 12)
        out = packet(f, ("Q01", "Q03"))
        self.assertEqual(len(out["results"]), 2)

    def test_22_revocation_twelve_plus_eight_plus_two_probes(self):
        f = self.fresh()
        old = packet(f)
        self.assertEqual(f.state()["logicalSnippetSources"], 3)
        f.stop_work("matter authority revoked")
        f.apply_event("REVOKE-EMBER", *CURATOR)
        before = f.state()
        query_statuses = []
        for n in range(1, 13):
            result = f.retrieve("Q%02d" % n, MATTER, 2)
            self.held(result)
            query_statuses.append(result["status"])
        direct_statuses = []
        for version in (1, 2):
            for call in (lambda v=version: f.retrieve("Q03", MATTER, v),
                         lambda v=version: f.verify_result("Q03", MATTER, v),
                         lambda v=version: f.review_packet(MATTER, v, *REVIEWER),
                         lambda v=version: f.export_packet(MATTER, v)):
                result = call()
                self.held(result)
                direct_statuses.append(result["status"])
        controls = [f.resume_work(2), f.renew_authority(2)]
        for result in controls:
            self.held(result)
        self.assertEqual((len(query_statuses), len(direct_statuses), len(controls)), (12, 8, 2))
        self.assertEqual(f.state()["logicalSnippetSources"], 3)
        self.assertEqual(f.state()["verificationSequence"], 3)
        self.assertEqual(f.state()["physicalFixtureLoads"], before["physicalFixtureLoads"])
        self.assertEqual(f.state()["actorMembershipCount"], 0)
        self.assertFalse(f.state()["active"])
        self.assertEqual(sum(len(r["sources"]) for r in old["results"]), 3)
        SNAPSHOTS["revocation"] = {"beforeProbes": before, "currentRetrievalProbes": query_statuses,
            "separateDirectProbes": direct_statuses, "separateControlProbes": [x["status"] for x in controls],
            "afterProbes": f.state(), "postEventAdditionalLogicalSnippetSources": 0,
            "oldCallerCopyStillHasThreeExcerpts": True}

    def test_23_causal_gates_stopped_stale_and_revoked_distinguished(self):
        stopped = self.ready()
        stopped.stop_work("control test")
        self.held(stopped.retrieve("Q01", MATTER, 1))
        self.assertEqual(stopped.state()["actorMembershipCount"], 1)
        self.assertEqual(stopped.resume_work(1)["status"], "WORK_RESUMED")
        stopped.renew_authority(1)
        self.assertEqual(stopped.retrieve("Q01", MATTER, 1)["status"], "REFERENCE_DRAFT")
        stale = self.ready()
        self.held(stale.retrieve("Q01", MATTER, 2))
        self.assertTrue(stale.state()["active"])
        self.assertEqual(stale.state()["actorMembershipCount"], 1)
        stale.renew_authority(1)
        self.assertEqual(stale.retrieve("Q01", MATTER, 1)["status"], "REFERENCE_DRAFT")
        revoked = self.fresh()
        revoked.stop_work("revoke")
        revoked.apply_event("REVOKE-EMBER", *CURATOR)
        self.held(revoked.resume_work(2))
        self.assertEqual(revoked.state()["actorMembershipCount"], 0)
        # White-box isolation: remove stopped/renewal causes, keep membership revoked.
        # Mutable Python internals are NOT a production authorisation boundary.
        revoked._active = True
        revoked._renewal = (2, 2)
        with patch.object(revoked, "_load", side_effect=AssertionError("membership gate must precede IO")):
            self.held(revoked.retrieve("Q01", MATTER, 2))
        SNAPSHOTS["causalGates"] = {"stoppedControlRestoredAfterResumeRenew": stopped.state(),
            "staleControlRestoredAfterCurrentRenew": stale.state(),
            "revocationWhiteBoxActiveButNoMembership": revoked.state(),
            "whiteBoxProbeIsNotAnAuthorisedPublicJourney": True}

    def test_24_revocation_preserves_tidal_and_reviewer_scope(self):
        f = self.fresh("ANALYST_TIDAL")
        f.stop_work("event")
        f.apply_event("REVOKE-EMBER", *CURATOR)
        self.assertEqual(f.state()["actorMembershipCount"], 1)
        self.assertEqual(f.resume_work(2)["status"], "WORK_RESUMED")
        out = packet(f, ("Q01", "Q02", "Q04", "Q08"), "MATTER-TIDAL",
                     ("ASSUMED_REVIEWER_TIDAL", "ASSUMED-FOLIO-REVIEWER"))
        self.assertEqual(out["status"], "INTERNAL_REFERENCE_PACKET")
        self.assertEqual(f._memberships["ASSUMED_REVIEWER_EMBER"], set())

    def test_25_events_both_orders_duplicate_invalid_types_and_no_resume(self):
        for order in (("WITHDRAW-K04", "REVOKE-EMBER"), ("REVOKE-EMBER", "WITHDRAW-K04")):
            f = self.fresh()
            f.stop_work("ordered changes")
            for event in order:
                self.assertEqual(f.apply_event(event, *CURATOR)["status"], "SOURCE_EVENT_APPLIED")
                self.assertFalse(f.state()["active"])
            self.assertEqual(f.state()["permissionVersion"], 3)
            before = f.state()
            for event, role, token in ((order[0], *CURATOR), ("unknown", *CURATOR), (True, *CURATOR), ([], *CURATOR), ("WITHDRAW-K04", "ANALYST_EMBER", CURATOR[1]), ("WITHDRAW-K04", CURATOR[0], False)):
                self.held(f.apply_event(event, role, token))
                self.assertEqual(f.state(), before)

    def test_26_event_while_active_is_rejected_without_lifecycle_change(self):
        f = self.ready()
        self.held(f.apply_event("WITHDRAW-K04", *CURATOR))
        self.assertEqual(f.state()["permissionVersion"], 1)
        self.assertTrue(f.state()["active"])
        f.renew_authority(1)
        self.assertEqual(f.retrieve("Q02", MATTER, 1)["status"], "REFERENCE_DRAFT")

    def test_27_day_three_four_five_inclusive_expiry(self):
        f = self.fresh()
        for day in (3, 4):
            self.assertEqual(f.advance_day(day)["status"], "DAY_ADVANCED")
            self.assertTrue(f.state()["active"])
            self.assertEqual(f.renew_authority(1)["status"], "AUTHORITY_RENEWED")
            r = f.retrieve("Q02", MATTER, 1)
            if day == 3:
                self.assertEqual(r["status"], "REFERENCE_DRAFT")
            else:
                self.held(r)
                self.assertEqual(packet(f, ("Q01", "Q03"))["status"], "INTERNAL_REFERENCE_PACKET")
        f.advance_day(5)
        before = f.state()
        self.held(f.renew_authority(1))
        self.assertTrue(f.state()["active"])
        self.held(f.resume_work(1))
        self.assertTrue(f.state()["active"])
        self.assertEqual(f.state()["physicalFixtureLoads"], before["physicalFixtureLoads"])
        f.stop_work("expired")
        self.held(f.resume_work(1))
        self.assertFalse(f.state()["active"])
        SNAPSHOTS["expiryDayFive"] = f.state()

    def test_28_strict_forward_days_and_positive_exact_versions(self):
        for bad in (True, False, 1.0, "1", 0, -1, None, [], {}):
            f = self.ready()
            self.held(f.renew_authority(bad))
            self.assertEqual(f.state()["permissionVersion"], 1)
            self.assertEqual(f.state()["physicalFixtureLoads"], 0)
        for bad in (True, False, 2.0, "3", 2, 1, 0, -1, None, [], {}):
            f = self.ready()
            self.held(f.advance_day(bad))
            self.assertEqual(f.state()["day"], 2)
            self.assertTrue(f.state()["active"])

    def test_29_reason_exact_bounded_string_and_repeat_stop(self):
        for good in ("x", "x" * 240, " x "):
            f = self.fresh()
            self.assertEqual(f.stop_work(good)["status"], "WORK_STOPPED")
            self.assertEqual(f.stop_work(good)["status"], "WORK_STOPPED")
        for bad in ("", "   ", "x" * 241, True, None, [], 123):
            f = self.ready()
            self.held(f.stop_work(bad))
            self.assertTrue(f.state()["active"])
        class StringSubclass(str):
            pass
        self.held(self.ready().stop_work(StringSubclass("valid looking")))

    def test_30_all_public_argument_types_handled_without_echo(self):
        values = (True, None, [], {}, 1, "unknown")
        for value in values:
            for call in (lambda f: f.retrieve(value, MATTER, 1),
                         lambda f: f.retrieve("Q01", value, 1),
                         lambda f: f.verify_result(value, MATTER, 1),
                         lambda f: f.export_packet(value, 1),
                         lambda f: f.review_packet(value, 1, *REVIEWER)):
                f = self.ready()
                self.held(call(f))
                self.assertEqual(f.state()["logicalSnippetSources"], 0)

    def test_31_queries_and_metadata_modified_in_separate_copy(self):
        original = (HERE / "folio_records.json").read_bytes()
        data = json.loads(original)
        changes = []
        for field in ("title", "sourceLocator", "body"):
            d = deepcopy(data)
            d["records"][0][field] = "mutated"
            changes.append(json.dumps(d).encode())
        d = deepcopy(data); d["records"][0]["version"] = True; changes.append(json.dumps(d).encode())
        d = deepcopy(data); d["records"].append(deepcopy(d["records"][0])); changes.append(json.dumps(d).encode())
        d = deepcopy(data); d["queries"][1]["queryId"] = "Q01"; changes.append(json.dumps(d).encode())
        d = deepcopy(data); d["queries"][0]["queryId"] = "Q99"; changes.append(json.dumps(d).encode())
        d = deepcopy(data); d["records"][2]["body"] = "invented body"; changes.append(json.dumps(d).encode())
        changes += [b"{broken", b'{"schemaVersion":"folio-records-v1","records":[],"records":[],"queries":[]}']
        script = "from folio_lab import Folio; import json; f=Folio('ANALYST_EMBER');f.renew_authority(1);print(json.dumps({'result':f.retrieve('Q01','MATTER-EMBER',1),'state':f.state()}))"
        with tempfile.TemporaryDirectory(prefix="folio-fixture-", dir=HERE) as temporary:
            target = Path(temporary)
            shutil.copy2(HERE / "folio_lab.py", target / "folio_lab.py")
            for raw in changes:
                (target / "folio_records.json").write_bytes(raw)
                observed = self.run_child(script, target)
                self.held(observed["result"])
                self.assertEqual(observed["state"]["logicalSnippetSources"], 0)
                self.assertEqual(observed["state"]["physicalFixtureLoads"], 1)
            (target / "folio_records.json").unlink()
            observed = self.run_child(script, target)
            self.held(observed["result"])
            self.assertEqual(observed["state"]["physicalFixtureLoads"], 0)
        self.assertEqual((HERE / "folio_records.json").read_bytes(), original)

    def test_32_existing_cache_does_not_hide_later_fixture_change(self):
        f = self.fresh()
        old = packet(f)
        before = f.state()
        with patch.object(Path, "read_bytes", return_value=b"modified fixture"):
            self.held(f.export_packet(MATTER, 1))
        self.assertEqual(f.state()["physicalFixtureLoads"], before["physicalFixtureLoads"] + 1)
        self.assertEqual(f.state()["logicalSnippetSources"], 3)
        self.clean_caches(f)
        self.assertEqual(len(old["results"]), 3)

    def run_child(self, code, target):
        env = dict(os.environ, PYTHONDONTWRITEBYTECODE="1", PYTHONUTF8="1")
        child = subprocess.run([sys.executable, "-B", "-X", "utf8", "-c", code], cwd=target, env=env,
                               capture_output=True, text=True, timeout=30)
        self.assertEqual(child.returncode, 0, child.stderr)
        return json.loads(child.stdout)

    def test_33_new_process_resets_revocation_and_withdrawal(self):
        f = self.fresh()
        f.stop_work("change")
        f.apply_event("REVOKE-EMBER", *CURATOR)
        f.apply_event("WITHDRAW-K04", *CURATOR)
        self.assertEqual(f.state()["permissionVersion"], 3)
        observed = self.run_child("from folio_lab import Folio;import json;f=Folio('ANALYST_EMBER');initial=f.state();f.renew_authority(1);print(json.dumps({'initial':initial,'result':f.retrieve('Q02','MATTER-EMBER',1),'after':f.state()}))", HERE)
        self.assertEqual(observed["initial"]["permissionVersion"], 1)
        self.assertEqual(observed["initial"]["verificationSequence"], 0)
        self.assertEqual(observed["initial"]["appliedEventCount"], 0)
        self.assertEqual(observed["result"]["status"], "REFERENCE_DRAFT")
        SNAPSHOTS["newProcessReset"] = observed

    def test_34_exact_four_file_copy_runs_without_parent_contract(self):
        with tempfile.TemporaryDirectory(prefix="folio-portable-", dir=HERE) as temporary:
            target = Path(temporary)
            names = ("README.md", "folio_records.json", "folio_lab.py", "test_folio_lab.py")
            for name in names:
                shutil.copy2(HERE / name, target / name)
                self.assertEqual((HERE / name).read_bytes(), (target / name).read_bytes())
            out = self.run_child("from folio_lab import Folio;import json;f=Folio('ANALYST_EMBER');f.renew_authority(1);print(json.dumps(f.retrieve('Q01','MATTER-EMBER',1)))", target)
            self.assertEqual(out["status"], "REFERENCE_DRAFT")
            # Execute the full suite once on copied four-file transport. Prevent
            # this test from recursively launching another full suite.
            if os.environ.get("FOLIO_COPIED_SUITE") != "1":
                env = dict(os.environ, PYTHONDONTWRITEBYTECODE="1", PYTHONUTF8="1", FOLIO_COPIED_SUITE="1")
                child = subprocess.run([sys.executable, "-B", "-X", "utf8", "test_folio_lab.py"],
                                       cwd=target, env=env, capture_output=True, text=True, timeout=60)
                self.assertEqual(child.returncode, 0, child.stdout + child.stderr)
                report = json.loads((target / "author-test-results.json").read_bytes())
                self.assertEqual(report["testsRun"], unittest.defaultTestLoader.loadTestsFromTestCase(FolioAuthorTests).countTestCases())
                self.assertEqual(report["failures"], 0)
                self.assertEqual(report["errors"], 0)
                self.assertEqual(report["skipped"], 0)
                SNAPSHOTS["copiedTransportSuite"] = {"testsRun": report["testsRun"], "sameAuthorSuiteNotDistinctTests": True,
                    "reportSha256": hashlib.sha256((target / "author-test-results.json").read_bytes()).hexdigest(),
                    "files": {name: hashlib.sha256((target / name).read_bytes()).hexdigest() for name in names}}

    def test_35_direct_source_versions_and_subclasses_rejected_before_read(self):
        class IntSubclass(int):
            pass
        for value in (True, 1.0, "1", None, [], {}, 0, -1, 2, IntSubclass(1)):
            calls = (lambda f: f.retrieve("Q01", MATTER, value),
                     lambda f: f.verify_result("Q01", MATTER, value),
                     lambda f: f.review_packet(MATTER, value, *REVIEWER),
                     lambda f: f.export_packet(MATTER, value))
            for call in calls:
                f = self.fresh()
                packet(f)
                before = f.state()
                with patch.object(f, "_load", side_effect=AssertionError("exact version gate precedes IO")):
                    self.held(call(f))
                self.clean_caches(f)
                self.assertEqual(f.state()["logicalSnippetSources"], 3)
                self.assertEqual(f.state()["physicalFixtureLoads"], before["physicalFixtureLoads"])
                self.assertEqual(f.state()["verificationSequence"], 3)

    def test_36_zero_eligible_set_never_makes_empty_packet(self):
        f = self.ready()
        # White-box isolation of the at-least-one rule. This overlay is not a
        # new public event and does not amend the approved finite lifecycle.
        f._lifecycle.update({"K01": "WITHDRAWN", "K04": "WITHDRAWN", "D01": "WITHDRAWN"})
        self.held(f.review_packet(MATTER, 1, *REVIEWER))
        f.renew_authority(1)
        self.held(f.export_packet(MATTER, 1))
        self.assertEqual(f.state()["logicalSnippetSources"], 0)
        self.assertEqual(f.state()["physicalFixtureLoads"], 2)

    def test_37_advance_invalidates_old_day_packet_but_not_old_copy(self):
        f = self.fresh()
        old = packet(f)
        f.advance_day(4)
        self.assertEqual(f.state()["verificationSequence"], 3)
        self.assertEqual(f.state()["logicalSnippetSources"], 3)
        self.clean_caches(f)
        self.held(f.export_packet(MATTER, 1))
        current = packet(f, ("Q01", "Q03"))
        self.assertEqual(current["day"], 4)
        self.assertEqual(current["verificationSequence"], 5)
        self.assertEqual(old["day"], 2)
        self.assertEqual(len(old["results"]), 3)
        self.assertEqual(len(current["results"]), 2)

    def test_38_review_fingerprint_and_sequence_are_rechecked(self):
        for field, value in (("verificationSequence", 99), ("day", 1),
                             ("permissionVersion", 2), ("fingerprints", {}),
                             ("matterId", "MATTER-TIDAL")):
            f = self.fresh()
            packet(f)
            # Deliberate internal corruption, not returned-copy mutation.
            f._review[field] = value
            self.held(f.export_packet(MATTER, 1))
            self.clean_caches(f)
            self.assertEqual(f.state()["logicalSnippetSources"], 3)
            self.assertEqual(f.state()["verificationSequence"], 3)

    def test_39_repeated_retrieval_counts_occurrences_not_unique_sources(self):
        f = self.ready()
        for count in (1, 2, 3):
            result = f.retrieve("Q01", MATTER, 1)
            self.assertEqual(result["status"], "REFERENCE_DRAFT")
            self.assertEqual(f.state()["logicalSnippetSources"], count)
            self.assertEqual(f.state()["physicalFixtureLoads"], count)
        f.verify_result("Q01", MATTER, 1)
        f.verify_result("Q01", MATTER, 1)
        self.assertEqual(f.state()["logicalSnippetSources"], 3)
        self.assertEqual(f.state()["verificationSequence"], 2)
        self.assertEqual(f.state()["physicalFixtureLoads"], 5)

    def test_40_missing_fixture_during_export_has_no_completed_read(self):
        f = self.fresh()
        old = packet(f)
        before = f.state()
        with patch.object(Path, "read_bytes", side_effect=FileNotFoundError("synthetic missing fixture")):
            self.held(f.export_packet(MATTER, 1))
        self.clean_caches(f)
        self.assertEqual(f.state()["physicalFixtureLoads"], before["physicalFixtureLoads"])
        self.assertEqual(f.state()["logicalSnippetSources"], 3)
        self.assertEqual(len(old["results"]), 3)


if __name__ == "__main__":
    suite = unittest.defaultTestLoader.loadTestsFromTestCase(FolioAuthorTests)
    result = unittest.TextTestRunner(verbosity=2).run(suite)
    names = ("README.md", "folio_records.json", "folio_lab.py", "test_folio_lab.py")
    report = {"scope": "Actual author tests only; not independent, professional or security acceptance.",
        "testsRun": result.testsRun, "failures": len(result.failures), "errors": len(result.errors),
        "skipped": len(result.skipped), "failureDetails": [{"test": str(t), "traceback": detail} for t, detail in result.failures + result.errors],
        "files": {name: hashlib.sha256((HERE / name).read_bytes()).hexdigest() for name in names},
        "snapshots": SNAPSHOTS, "independentReview": "PENDING", "realUseStatus": "HOLD"}
    (HERE / "author-test-results.json").write_bytes((json.dumps(report, indent=2) + "\n").encode())
    sys.exit(0 if result.wasSuccessful() else 1)