Digitising healthcare records for confidential AI retrieval

Learn in your browser · Chapter 01 of 08

Digitisation begins with an accountable records purpose. Build an inventory that preserves what each representation is, where it came from, and which questions remain unresolved before retrieval is considered.

Briar is an original fictional adult records-management archive. Its people, identifiers, documents and policy are invented; sources are text facsimiles and derivatives fabricated OCR-like text. No real records, external model or care decisions are involved. Its solution to provenance and confidentiality failures is inventory, reconciliation, pre-read access checks and bounded extraction. Completion does not approve a real service.

State the purpose before deciding what to digitise: prepare source-linked records-review extracts for a permitted training role. Name the reader and decision, such as index eligibility. Changing that purpose to patient profiling or clinical interpretation requires new authority. A purpose card exposes such changes for a reviewer to approve, revise or hold.

Select the organisational jurisdiction explicitly, or record unresolved. Do not infer it from a learner's location, an English filename, a UK website address or the word healthcare. An organisation may have records, staff, processors and recipients in different places, requiring separate scope decisions. For this exercise, Briar's rules are fictional training policy and the real organisational jurisdiction remains a learner-selected review field. A blank field must remain visible. It cannot become worldwide coverage through a disclaimer, and a selected country cannot by itself resolve the intended processing route.

A real proposal needs a region-specific record: organisation, activities, locations, categories, purposes, destinations, recipients and accountable review. ICO guidance distinguishes an Article 6 lawful basis from an Article 9 condition, with DPA 2018 Schedule 1 conditions where required. A healthcare label cannot select these. On 2 October 2026, the ICO summary updated on 19 June 2026 states that DUAA data-protection provisions are in force, while the detailed special-category guidance still carries a review notice. Check current wording, applicable transitions and organisational facts; the review notice does not postpone the law. The NHS code has a stated England scope. Other regional frameworks and cross-border questions need separate review. Briar makes none of these real-processing decisions.

Scroll sideways to see every column.

Inventory the representations, not just the folders. A single logical document can have a source page, image, text derivative, chunks, embeddings, cached extracts and copies in sessions. They do not have the same role or lifecycle. Briar supplies a plain-text source facsimile and a deliberately degraded training image for visual inspection; its code does not read that image. Calling the fabricated text OCR output would invent a processing history. Record what is supplied and what is actually produced, with the relationship between them. A derivative must retain a route back to its source.

Separate discovery metadata from content. Briar's records role can inspect archive status without receiving source text. That illustrates a permission boundary, not an assurance that real metadata is anonymous. Inventory reports need their own audience and access decisions.

1. Write the purpose, intended reader and decision, including the training-only boundary.
2. Record the organisational jurisdiction explicitly or label it unresolved with a named review task.
3. List each source and derivative representation with document, revision, page and ownership relationships.
4. Record known status, class and identifier fields without silently resolving conflicts.
5. Assign exceptions to a quarantine or review queue before any searchable index is built.
6. State what evidence would permit the next step and what remains outside this exercise.

A B-100 folder contains a document carrying B-100 plus a registry key. Its matching derivative label creates an intake candidate, not a verified assignment. Record both document fields, their proposed master-index relationship, source links and reconciliation pending. Keep jurisdiction unresolved. The reviewer can locate the source and see the remaining decisions despite the folder's apparent neatness.

A brief saying make every file searchable because the administrator holds the archive needs repair. Custody does not define every reader's purpose or entitlement. Preserve the brief, identify that unsupported assumption and propose the bounded records-review workflow before processing.

Text equivalent: the bounded purpose leads to a representation inventory and an explicit jurisdiction field. Technical preparation follows the inventory; contextual review follows the selected setting. Their evidence meets in a recorded next-step decision. Neither path substitutes for the other.

Scroll sideways to see every column.

Learn in your browser · Chapter 02 of 08

A searchable derivative can be tidy and wrong. Preserve the source, distinguish visual quality from text agreement, and make every correction traceable before an extract becomes eligible for retrieval.

A missing negation, detached continuation page or wrong order can change a records instruction. Tidy punctuation can conceal the failure. The solution is a documented relationship between source, derivative, quality finding and correction. Briar uses facsimiles and fabricated OCR-like text; it neither runs OCR nor measures recognition accuracy for real archives.

For a real scanning proposal, separate capture preparation, image inspection, text processing and semantic review. A capture checklist might include page completeness, order, orientation, legibility, cropping and whether annotations or reverse-side content have been considered. These are proposed review tasks, not claims that Briar tests them. Keep a physical or original-source reference where the approved process requires it. A visually clear image does not prove the derivative's wording, and exact text agreement does not prove that the source itself contains complete or accurate information.

Inspect Briar's degraded training image and record only visible findings. Do not invent blur measurements, scanner settings or OCR scores. The code reads the ordinary UTF-8 source facsimile, not image pixels. Successful text comparison therefore cannot be reported as image-to-text extraction or recovery of an illegible page.

Scroll sideways to see every column.

Consider the intentionally defective derivative that omits NOT from a records-release instruction. The relevant finding is an explicit wording discrepancy, not a numerical recognition score. Preserve the source sentence and the derivative sentence side by side, retaining document, revision and page references. Describe the difference without deciding a real disclosure question or giving care advice. A reviewer must inspect the source meaning and surrounding context. Automatically adding a likely negation from language patterns would conceal whether the proposed correction came from the supplied source or a guess.

Use a discrepancy ledger: original derivative wording, source reference, observed difference, proposed replacement, reviewer decision and new representation version. Give the issue a stable identifier. Distinguish readability edits from changes affecting a source instruction. Restrict ledger content to permitted reviewers while preserving the evidence needed to reconstruct the decision.

Integrity, currency and semantics are separate. Briar compares source bytes with a code-owned baseline. An input source and matching hash can agree while differing from that baseline, so cannot replace it. A baseline match establishes byte consistency under the exercise assumption, not author or patient authentication or current revision. Baseline-code modification lies outside that assumption.

1. Keep source facsimile, fabricated derivative and visual training image separately labelled.
2. Inspect available source and derivative references without substituting a plausible reconstruction.
3. Compare derivative and source wording, recording exact discrepancies and their locations.
4. Check source bytes against the separate teaching baseline, and assess revision and status independently.
5. Quarantine a discrepancy before indexing; route meaning and proposed correction to human review.
6. Publish a new reviewed derivative relationship rather than erasing the old finding or inheriting its status.

Work the supplied D-03 example: S-03 revision 1, page 1 says The folder is NOT authorised for external release. Ask the records supervisor. The fabricated derivative omits NOT. Hold it, preserve both wordings and review restoration from the source. Recheck the replacement and other eligibility gates. Repairing a derivative does not create a new source revision.

Briar's D-01 revision 1 to revision 2 replacement is a separate source-revision event. It supersedes the prior representation and clears active index derivatives, cache and synthetic session copies. Originals remain under the fictional preservation hold. This establishes neither legal erasure nor external backup purge; later chapters examine the propagation report.

Text equivalent: compare the source facsimile and fabricated derivative. Agreement leads to further eligibility checks. Disagreement leads to quarantine, a preserved discrepancy ledger and human correction review. A replacement returns to comparison with its history intact; it never silently changes the source baseline.

Scroll sideways to see every column.

Learn in your browser · Chapter 03 of 08

Correct words attached to the wrong record are still a failure. Resolve patient and document relationships explicitly, preserve collisions, and keep ambiguity out of the searchable index.

Reconciliation checks patient assignment and unambiguous document identity before an index spreads mistaken relationships across chunks and caches. Correct transcription does not establish assignment. Briar's fictional B-100 and B-200 have different registry keys. Compare each candidate's patient identifier and key against the master index, check document identity separately and quarantine unresolved relationships.

Use the authoritative teaching registry as a comparison reference, while preserving its limited role. A source patient identifier must be explicit and known, and its registry key must match the entry for that identifier. Matching one field cannot resolve a collision. A familiar folder label, similar text or apparently consistent patient name cannot repair disagreement. The registry is an invented exercise reference, not an authenticated real patient identity service. Agreement permits the next finite check; it does not establish who supplied the document or whether its statements are correct.

Scroll sideways to see every column.

Keep the training person, logical document and representation distinct. B-100 identifies a training person; D-01 identifies a document; its revisions describe related document states. Each derivative links to a particular source version. Collapsing those fields into a filename can move chunks to the wrong revision or person. Reassignment needs a reviewed relationship change.

D-02 names B-100 but carries REG-B, which the master index associates with B-200. The finding is patient-registry-mismatch. Preserve both fields and the hold reason. Do not pick the first identifier, prefer the key or merge the training people. Resolve the source assignment through documented review rather than inventing a registry entry.

Briar's S-05a and S-05b both carry D-05. Both copies are held for duplicate-or-missing-document-id. Keeping the last row could overwrite findings or attach one source's state to another. Preserve the ambiguous input and resolve document identity before indexing. A controlled revision replacement is separate from ingesting colliding candidates together.

Missing evidence must not be hidden by later successes. Check document uniqueness, explicit patient and registry relationships, current revision and status, permitted source location, baseline bytes and derivative agreement. Use actual lab outputs for executed reason strings; a conceptual report can list additional review questions separately. Ready-for-human-review remains bounded by semantic review and request access checks.

1. Preserve the original candidate fields and give the reconciliation issue a stable reference.
2. Check document ID uniqueness independently of patient matching.
3. Compare the explicit source patient identifier and its registry key with the master index.
4. Check current revision and current or withdrawn status without inheriting them from the document name.
5. Locate the confined source and perform integrity and derivative agreement checks.
6. Quarantine disagreement or missing evidence; record reviewed correction and rerun all affected relationships.

The lab confines source files to its supplied directory and refuses traversal or symlink reads. Plausible metadata cannot permit an outside path. Recreating a missing source from its derivative would replace provenance evidence with the output under review. Preserve that hold; the directory control does not prove protection of other systems.

Report candidate reference, observed identifiers, registry relationship, uniqueness, version, source location, disposition, reason and responsible action. Restrict reports to intended reviewers without unnecessary full-text logs. Preserve prior findings after correction, showing changed fields and reasons; recalculate eligibility. Later access filtering cannot fix ingestion's wrong patient assignment because it would use that mistaken relationship.

Text equivalent: preserve the candidate, then check the patient identifier and registry key together, and document uniqueness and revision separately. Both paths feed source and derivative checks. Any failed relationship goes to quarantine. Passing finite checks creates an index candidate with access and human semantic review still required.

Scroll sideways to see every column.

Learn in your browser · Chapter 04 of 08

A retriever should establish the permitted information boundary before opening source text. Bind the request to a role, assignment, document class, purpose and current policy state, then return only the bounded extract that the fictional policy permits.

Reading every source before filtering an answer already exposes disallowed information to the process or tool. Briar checks request metadata and policy before opening text, then returns a permitted linked records-review extract requiring human review. Its code-defined authority is an assumption; a role field establishes no real identity, professional status or lawful entitlement.

Check requester role, assigned training person, permitted class, purpose and current policy separately. The right patient can have an unapproved purpose; a permitted class can contain a quarantined document. Explicit fields make these failures reviewable. Missing or unknown fields cause denial under the contract, rather than guesses from free-text wording.

Scroll sideways to see every column.

These labels teach information-management boundaries. A metadata report can show disposition without source text; a policy control need not reveal controlled content. A clinician label establishes no clinical decision, and an administrator label grants no universal access. Real identity and entitlements require the organisation's approved mechanisms separately from teaching fields.

In Briar, minimum necessary describes its fictional bounded-access goal. The checked HHS guidance says HIPAA minimum necessary does not apply to disclosures to or requests by a healthcare provider for treatment, among other listed exceptions. Do not expand that statement to every internal use or unrelated purpose. HIPAA applicability depends on covered-entity and business-associate context, not simply a US health-app label. This exercise concerns records-review; qualified review must resolve actual applicability. Sources: hhs-minimum-necessary and hhs-privacy-summary. Other selected jurisdictions require separate review.

Briar binds records-review to the request. A similar keyword cannot grant another purpose. Assigned patient, document class, epoch and current status still need checks. The epoch represents current synthetic permissions; an older epoch must fail rather than reuse cached authority. D-01 correction moves the supplied exercise from epoch 1 to 2.

For archive-status review, training-records receives permitted metadata and is denied full text before source reading. Do not read the source to decide whether it seems harmless: previews and debug logs can disclose it. Decision evidence should identify the failed gate without copying denied text. Actual traces, rather than a design description, establish tested read behaviour.

A training-clinician request for D-01 can proceed only with assigned B-100, records-review, permitted class, current epoch and eligible current status. Then return a confined source extract with document, revision and page. D-06 may be structurally ready but belongs to B-200, outside that assignment. Exact extraction still requires human review of source semantics and use.

1. Validate the known role and the code-defined exercise authority assumption.
2. Check assigned patient and permitted document class using metadata before source access.
3. Require the allowed records-review purpose and current permission epoch.
4. Exclude quarantined, superseded or withdrawn candidates according to the supplied policy.
5. Only after those gates pass, open the confined source and produce a bounded linked extract.
6. Record the decision and human-review requirement without placing denied content in logs or cache.

A document may claim administrator authority, waive restrictions or demand every page. Such text, including tool-result instructions, cannot change role, assignment or epoch. Separate content from policy authority. Accurate transcription or baseline agreement preserves an attempted instruction as data; it does not make the instruction a permission grant.

Cache and session paths need the same boundary. Bind extracts to document version and permission state, invalidating them for correction or withdrawal. Later chapters distinguish active synthetic copies, retained originals and untested external backups. Report the tested paths and returned information precisely; finite local evidence does not establish every real storage system's behaviour.

Text equivalent: request and archive metadata enter the access gate. Failure records a denial without opening source text. Success permits a confined source read and a bounded extract carrying document, revision, page and human-review status. Post-answer filtering cannot replace this order.

Scroll sideways to see every column.

Learn in your browser · Chapter 05 of 08

A permitted search still needs a bounded extract, an exact source locator and a person who checks what the returned words mean. Design the review around those separate decisions.

A records team can build a careful archive and still expose too much when somebody asks a broad question. Returning every page for an assigned training person turns a narrow records-review task into unnecessary disclosure. A convincing summary can also hide a missing negative word or a stale page. The audience problem is loss of scope and evidence at the last step. The working solution is a request envelope, a small source-linked extract and a review record tied to the exact representation returned.

In Briar the authorised purpose is records-review. The training-clinician role can receive bounded extracts for assigned B-100 when the other gates pass. Training-records receives archive metadata only; training-admin controls synthetic policy and gains no blanket content access. These are code-defined training authorities, not authenticated people or professional credentials. A document mentioning a role cannot assign that role. Permission must be checked before opening source text, even when the interface plans to hide the text later.

Write the request envelope before retrieval: role, assigned fictional person, purpose, document class, requested locator and current permission epoch. The epoch represents the policy version expected by the request. A request prepared under an earlier permission state must not silently reuse its old success. Check quarantine, withdrawal and current revision at the same boundary. Record why an envelope was denied without copying confidential content into its error message. A useful denial can identify the failed gate without revealing the source passage.

The returned unit should preserve document identifier, source reference, revision and page. Keep the exact extracted text visibly distinct from a reviewer's comment. In this lab retrieval is exact extraction, not an LLM answer, a diagnosis or clinical advice. A selected substring is evidence of those supplied words; it is not evidence that the document is complete, clinically correct or appropriate for another purpose. Bounded retrieval means selecting the smallest permitted material sufficient for the stated information-management task, with context needed to avoid misleading omission.

Consider the fabricated OCR-like derivative that omits NOT from a records-release instruction. That omission reverses the instruction while the rest of the sentence looks familiar. Exact source comparison should quarantine the discrepant derivative before indexing. If somebody encounters an old copied extract, a human reviewer must trace it to the source and representation version rather than approving it because it reads fluently. Do not reconstruct the missing word from memory or ask a generated answer to guess it. The source text is the training comparison reference.

Meaningful human review has an object and a consequence. The reviewer sees the request, actual returned text, locator, quality flags and revision status; they can hold use, seek a permitted wider context or report a correction. Their decision states what was checked and what remains unresolved. A box labelled reviewed without the inspected version cannot distinguish yesterday's representation from today's replacement. A reviewer role label alone cannot prove the reviewer was authenticated or that a genuine healthcare organisation authorised the task.

Separate contract compliance from meaning review. Ask whether retrieval obeyed access and extraction gates, then whether the passage supports the proposed narrow archive observation. A locator cannot establish care decisions or legal entitlement; a denial cannot establish inaccuracy. Record the actionable unresolved question.

Worked example: a permitted B-100 records-review request proposes to use an extract from current D-01. The learner checks the source reference, page and revision presented by the actual result, then records only a bounded archive observation. If the request changes to B-200, or its epoch becomes stale, the earlier review cannot authorise another read. If the text has changed, the review must name the replacement representation. This example describes the method; the executable appendix supplies actual locators and observed results.

Escalation also needs permission. Report a mismatch using permitted metadata; copying B-200 text into an escalation note defeats the denial. A real service needs the organisation, selected jurisdiction and qualified reviewer identified before scope expands.

Text equivalent: establish request authority before reading content. Return only permitted bounded words with their source locator. A reviewer compares those exact words and relevant context with the proposed archive observation, then records a hold or limited use with reasons.

Scroll sideways to see every column.

Learn in your browser · Chapter 06 of 08

Correction and withdrawal change future use, while retention describes what remains and why. Build a dependency map so active removal can be demonstrated without claiming that held originals or external backups vanished.

A corrected source page does not automatically correct a cached answer, an indexed fragment or a copied session extract. The audience problem is propagation: the team fixes one representation while a stale copy continues to circulate. The working solution is a source-linked change record, a dependency inventory and explicit checks for each affected active store. The record distinguishes what was replaced, what was removed, what remains under the fictional hold and what was never tested.

Briar's correction replaces D-01 revision 1 with revision 2. Preserve the source-linked history and mark the earlier representation superseded. Revision status and byte integrity answer different questions. An unchanged revision 1 can still be unsuitable for current retrieval. A revision 2 label does not prove its source matches the code-owned teaching baseline or that the derivative agrees with the source. Recheck the replacement through the same integrity, reconciliation, quality and access gates before allowing it into active retrieval.

A correction records the document/person, earlier and replacement revisions, reason, source link, owner and disposition. Preserve history rather than making the replacement appear original. Real amendment and retention methods need selected-jurisdiction and qualified organisational review.

Withdrawal is a different action. The supplied fixture command denies future queries and clears active derivatives. It does not imply the source is false, that a person has exercised a particular legal right, or that every stored copy has been destroyed. A withdrawn representation must stay excluded even if its source bytes still match the baseline. Record the withdrawal reason and effective state separately from correction history, so a later integrity check cannot accidentally restore eligibility.

Map the copy family before changing it: source originals, current source-linked representation, derived index, cache and synthetic session copies. In Briar the active index, cache and session copies are cleared by the correction or withdrawal operation. The fictional archive has a preservation hold, so source originals remain. External backups are untested. The report must say all three things. Active derivative removal is not legal erasure, backup purge or an assurance that no person previously viewed or copied the words.

The supplied preservation hold sets no universal retention period. Real decisions need an owner, selected jurisdiction, applicable schedule, record category, purpose, trigger, review point and hold status. Record conflicts for qualified review instead of inventing a global duration.

Order matters when a change interrupts retrieval. First make the affected representation unavailable for future active use. Then apply the source-linked replacement or withdrawal, remove dependent active copies and verify the result. If a step fails, keep the representation held and record the unfinished store. Do not report completion because the command began or because the primary index is empty. A cache and session copy can preserve the same unwanted material through another route.

Worked example: the learner has a hypothetical active D-01 revision 1 extract in a synthetic session. Correction links revision 2 to that history and supersedes revision 1. The learner checks active index, cache and session stores separately, then attempts a fresh permitted query against the current state. The report retains the earlier source under the preservation hold and labels external backups untested. It records actual observations from execution rather than predicting that every removal succeeded. If a session copy remains, propagation is incomplete and active use stays held.

A restored index or cache may predate withdrawal. Reapply current revision, withdrawal and permission state before activation. A snapshot records its capture time, not today's authority. Rehearse restores in an isolated fictional copy, checking current exclusions while preserving originals under the supplied hold.

Report checked active stores, observed revision/status, retained-original reason, failed steps and untested backups. Use permitted metadata for recipients without content authority. The offline exercise sends no external notices and proves no acknowledgements.

Text equivalent: the change affects current eligibility and the active index, cache and session copies. Original sources remain under Briar's preservation hold. External backups have not been tested. The propagation report records each branch separately and keeps any incomplete active removal held.

Scroll sideways to see every column.

Learn in your browser · Chapter 07 of 08

A useful audit trail explains a particular decision and lets another person reproduce it. Test denials, interrupted changes and hostile document instructions as carefully as the successful extract.

A dashboard marked healthy can hide a serious boundary failure: a denied query opened a source before checking permission, or a restart resurrected withdrawn content. The audience problem is that a success count conceals how records move. The working solution is a decision trail paired with targeted adversarial and recovery checks. Each check names its expected boundary, the actual observation and the limitation that remains. A finite local result cannot establish production security or professional approval.

Record request scope, fictional document/revision, disposition, epoch, decision reason and stage reached. Successful extracts retain source locators and human review. Denial logs use permitted metadata and reasons. Copying whole passages into logs could turn audit evidence into an alternative disclosure archive.

Evidence must distinguish plans from observations. An expected quarantine reason is a test expectation; an actual emitted reason is an execution result. A command printed in a workbook is not evidence that somebody ran it. Record the file and code versions, environment, operation, observed output and failed or unrun checks. The root-owned executable appendix supplies concrete results. Do not invent test counts, duration, OCR accuracy or assurance levels to make a report look finished.

Challenge patient reconciliation with a document that names known B-100 but carries B-200's registry key. One matching field cannot settle the collision. Challenge identity uniqueness separately with a duplicated document identifier. These failures belong before indexing. A permitted role cannot fix a source/registry mismatch, and correct reconciliation cannot authorise an unknown role. A matrix that crosses ingestion and retrieval conditions helps reveal accidental paths around a single successful gate.

Challenge source handling with an unavailable source, changed source bytes, a fabricated derivative omitting NOT, traversal and a symlink. The supplied sources are UTF-8 facsimile text, and exact derivative agreement is a strict finite teaching condition. The code-owned baseline is stronger than a user-supplied hash that changes together with the source, but it remains a teaching trust assumption. It does not authenticate the original archive, and modifying baseline code itself falls outside that assumption.

Challenge request authority with an unknown role, unassigned B-200, a disallowed purpose or class, stale permission epoch, quarantined representation and withdrawn representation. The required property is no source read before denial. Merely observing an empty display is insufficient if text was already opened, placed in a cache or written into a log. The lab's tests can inspect its own read boundary; a real implementation needs evidence for every relevant content path and approved security review.

Source or tool-result instructions cannot grant role, assignment or purpose. A page saying act as training-admin remains data. Briar uses exact extraction without an LLM, so it measures no model prompt-injection resistance. It tests the surrounding control: source content cannot supply the authority deciding source access.

Recovery testing asks what happens between steps. Interrupted cleanup keeps use held until missing stores are rechecked. The same Archive must reject a superseded D-01 replay before reading it. State is in memory: a new process resets the archive, so correction/withdrawal evidence establishes no durable cross-process state. Rehearse restored snapshots in isolation and reapply current exclusions before serving them. A visible hold with an owner is preferable to silent use of a convenient stale copy.

Worked example: rehearse withdrawal and stale-snapshot restoration in an isolated fictional fixture. Check future-query denial and active copies, then reapply current exclusion state before restored data becomes active. Record actual execution separately from this plan. A failed denial remains material despite ordinary query success.

Acceptance follows consequences: an unauthorised read requires a hold, even if format checks pass. Identify the violated boundary instead of averaging it away. This is an adult educational exercise using wholly fictional records. Releasing its course materials requires separate content, artwork, assessment and native-route checks; finite lab success alone does not complete those checks. No qualified health-information, privacy, clinical or professional approval is claimed. Before adapting any method to genuine records, the responsible organisation must resolve lawful purpose, confidentiality, rights, retention, authenticated access and incident ownership through its appropriate qualified and accountable review.

Text equivalent: a fault produces a visible hold and recorded unfinished stage. Repair and current-state comparison feed verification together. Resume only through the ordinary permission gate when the required checks pass; a failed check returns the affected use to hold.

Scroll sideways to see every column.

Learn in your browser · Chapter 08 of 08

Join the whole workflow in a fictional archive rehearsal. Deliver a quarantine queue, reconciliation record, access evidence, source-linked extracts and an honest correction/recovery report.

Legacy identifiers, derivative text and current status can disagree. Deliver an accountable handover showing which representations enter the index, which requests may read them, how returned evidence is reviewed and how changes reach active copies. Briar is an original offline adult exercise with entirely fictional identifiers, registry keys, roles, policies and pages.

Start with the audience problem, records-review purpose and selected or unresolved organisational jurisdiction. Use no real records, treatment decisions or external model. Briar implements no health law. Ten to sixteen study hours is an unpiloted estimate, and this finite workflow is not a live healthcare service.

Inventory actual fixture/code versions, UTF-8 facsimiles, fabricated OCR-like derivatives and the marked degraded synthetic image. The image supports visual inspection only; the lab does not read it. Exact text comparison measures neither real OCR accuracy, scanning quality nor clinical correctness.

Reconcile each document's identifier and registry key with the master index containing B-100 and B-200. Require both fields, unique document identity, current revision, available confined source and baseline integrity. A plausible name or one matching identifier cannot resolve a collision. Build the quarantine queue with a distinct reason, the affected representation, permitted metadata and an owner for the next action. Do not silently repair uncertain assignment by choosing whichever patient appears first in the registry.

Hold the missing NOT derivative before indexing. Compare supplied source text, preserve discrepancy and source link, and request a linked correction. Guessing the word is insufficient. Check missing sources and changed bytes against the code-owned baseline, whose teaching assumption does not authenticate genuine provenance or identity.

Matrix the training roles: records gets metadata, clinician gets assigned B-100 bounded extracts, admin controls policy without blanket content access. Check records-review purpose, class, epoch and status before source reads. Hostile source/tool text grants nothing. The code-defined request authority does not authenticate a person.

For a permitted retrieval, retain exact returned words with document/source/revision/page and human review required. Review what those words support for the narrowly stated archive task. The output is not an LLM answer or clinical advice. Capture the review decision and reasons against the actual representation. A correct locator does not justify a conclusion about legal release entitlement, clinical truth or another person's record. Keep unresolved meaning, quality or authority questions explicit rather than filling them with fluent speculation.

Rehearse correction of D-01 revision 1 to revision 2 in an isolated fixture. Preserve the source-linked history, supersede the earlier representation, clear affected active index, cache and synthetic session copies, then verify current eligibility. Rehearse withdrawal separately and verify future-query denial. Source originals remain under Briar's preservation hold. External backups remain untested. Show these separate dispositions in your report, especially when a cleanup step fails or a stale snapshot is considered for restoration.

Link six deliverables by document reference: scope/inventory, reconciliation, quarantine, access evidence, extract/review and correction/recovery. Separate expectations, observations and unrun checks. State is in memory: a new process resets the archive, so changes are not durable across processes. The appendix supplies actual commands and dispositions.

Worked scenario: quarantine the registry collision and discrepant derivative before indexing; trace an old D-01 extract to correction history. Deny B-200 and stale-epoch requests before reads. A remaining session copy holds propagation incomplete. Report these only when observed, alongside held originals and untested backups.

Close by identifying the finite teaching solution and missing real-service controls: authenticated authority, jurisdiction review, approved retention/correction, representative quality evaluation and accountable recovery. This adult fictional-records course makes no claim of qualified health-information, privacy, clinical or professional approval. Educational publication depends on separately recorded content, imagery, assessment and public-integration checks, not just a successful lab. Genuine-record processing, clinical use, disclosure and organisational deployment remain outside the course and require appropriate qualified review and actual authority. Knowledge practice removes none of those real-use boundaries.

Text equivalent: inventory establishes scope. Reconciliation sends uncertain representations to quarantine and eligible material to access checks. Permitted extracts receive manual review. Corrections and recovery preserve source-linked history and separate active removal from held originals. The handover joins actual observations with unresolved dependencies.

Scroll sideways to see every column.

python -B -m unittest -v test_briar_lab.py
python -B briar_lab.py fixture.json

Scroll sideways to see every column.

# Briar synthetic archive

All material is original and fictional. This adult records-management exercise contains no genuine patient records, diagnoses or clinical decisions. Use Python 3.12 in a permitted local folder, with no external dependencies for the lab. The image is a deliberately degraded facsimile for human inspection. Derivative text is fabricated OCR-like training text: no OCR engine was run or measured.

Keep `briar_lab.py`, `baseline.py`, `fixture.json`, `test_briar_lab.py` and the `sources` folder together. The complete private exercise ZIP contains these files. The workbook source appendix provides each source page too; create those files exactly under `sources/` if copying manually.

Run:

```text
python -B -m unittest -v test_briar_lab.py
python -B briar_lab.py fixture.json
```

The original fixture has nine entries. D-01 and D-06 are structurally ready for human review, not approved records. Seven entries are quarantined, including both duplicate D-05 copies. D-03 loses NOT in its fabricated derivative. The training clinician is assigned B-100 and cannot query D-06 belonging to B-200.

The demonstration extracts current D-01, corrects it to revision 2, rejects the old epoch ticket and withdraws D-01 from active retrieval. It retains original source files under a fictional preservation hold and makes no legal erasure or backup purge claim. There is no durable state: each run starts a fresh in-memory archive. It does not promise that a future invocation remembers withdrawal. A real service needs durable authorised state, trusted identity, current rights decisions, secure storage, independent review and recovery tests.

The code-owned baseline is a teaching assumption. Matching it does not authenticate source provenance or a requester. An attacker allowed to rewrite the code can rewrite that baseline. The finite exercise checks only the supplied representations and methods. The exact extract still needs meaningful human review; no model, clinical advice, authenticated attestation or production deployment is provided.

Files in `review/` are additional independent tests/evidence. They are not professional healthcare approval. The depicted source instruction concerns fictional records release, not treatment.

"""Code-owned fictional teaching baseline. Not authenticated provenance."""
BASELINE = {'S-01': {'documentClass': 'handover',
          'documentId': 'D-01',
          'filename': 'S-01.txt',
          'page': 1,
          'patientId': 'B-100',
          'registryKey': 'REG-A',
          'revision': 1,
          'sha256': '91eb7fde8d41f2fcb6dc076817459b59236c7f8cc62923bccffbdadd7322681e',
          'sourceId': 'S-01',
          'status': 'current'},
 'S-01r2': {'documentClass': 'handover',
            'documentId': 'D-01',
            'filename': 'S-01r2.txt',
            'page': 1,
            'patientId': 'B-100',
            'registryKey': 'REG-A',
            'revision': 2,
            'sha256': '8bd9cf18e5b9d938041de1db658e4570631bf475b5015e4cf2bef289132f936e',
            'sourceId': 'S-01r2',
            'status': 'current'},
 'S-02': {'documentClass': 'handover',
          'documentId': 'D-02',
          'filename': 'S-02.txt',
          'page': 1,
          'patientId': 'B-100',
          'registryKey': 'REG-B',
          'revision': 1,
          'sha256': '05d74fa18dd183728e3614f32250cb8814ec970ed9c91e63799aef9b36dcd2c1',
          'sourceId': 'S-02',
          'status': 'current'},
 'S-03': {'documentClass': 'release-review',
          'documentId': 'D-03',
          'filename': 'S-03.txt',
          'page': 1,
          'patientId': 'B-100',
          'registryKey': 'REG-A',
          'revision': 1,
          'sha256': '85cc82af672dca3f667408af8d81027fb67a0b63c8535df38dd48b96f4db0b2e',
          'sourceId': 'S-03',
          'status': 'current'},
 'S-04': {'documentClass': 'handover',
          'documentId': 'D-04',
          'filename': 'S-04.txt',
          'page': 1,
          'patientId': 'B-999',
          'registryKey': 'REG-Z',
          'revision': 1,
          'sha256': '40de005710a824a57925e9ee0f8a383c45bc5a7628f2aca40cbd894214373705',
          'sourceId': 'S-04',
          'status': 'current'},
 'S-05a': {'documentClass': 'handover',
           'documentId': 'D-05',
           'filename': 'S-05a.txt',
           'page': 1,
           'patientId': 'B-100',
           'registryKey': 'REG-A',
           'revision': 1,
           'sha256': 'ba13d6e2551fa256d28093301fc1a9d3d636d135b853c99531d5f6fab8390bd3',
           'sourceId': 'S-05a',
           'status': 'current'},
 'S-05b': {'documentClass': 'handover',
           'documentId': 'D-05',
           'filename': 'S-05b.txt',
           'page': 1,
           'patientId': 'B-100',
           'registryKey': 'REG-A',
           'revision': 1,
           'sha256': 'ab6a9ad0fb4fd356e0ad47531a567bece1d6658018fd79c1c82930d864daa82b',
           'sourceId': 'S-05b',
           'status': 'current'},
 'S-06': {'documentClass': 'handover',
          'documentId': 'D-06',
          'filename': 'S-06.txt',
          'page': 1,
          'patientId': 'B-200',
          'registryKey': 'REG-B',
          'revision': 1,
          'sha256': 'b669fafe7e925bcf3fcf98df80acd26788e0f34e6e39b610ed85ef8c0d0e6175',
          'sourceId': 'S-06',
          'status': 'current'},
 'S-07': {'documentClass': 'handover',
          'documentId': 'D-07',
          'filename': 'S-07.txt',
          'page': 1,
          'patientId': 'B-100',
          'registryKey': 'REG-A',
          'revision': 1,
          'sha256': 'd3c18ab4567e709ea40e58636535ba54fce72e3307b7da1380787e91f1ac1b51',
          'sourceId': 'S-07',
          'status': 'withdrawn'},
 'S-08': {'documentClass': 'handover',
          'documentId': 'D-08',
          'filename': 'S-08.txt',
          'page': 1,
          'patientId': 'B-100',
          'registryKey': 'REG-A',
          'revision': 2,
          'sha256': 'f901fd2071b7bad1c64aeb2ff8539714f17fa78455a5a42e47ebe6ba8463d1a9',
          'sourceId': 'S-08',
          'status': 'current'}}

{
  "trainingOnly": true,
  "archive": "Briar fictional archive",
  "masterRegistry": {
    "B-100": "REG-A",
    "B-200": "REG-B"
  },
  "documents": [
    {
      "sourceId": "S-01",
      "documentId": "D-01",
      "patientId": "B-100",
      "registryKey": "REG-A",
      "revision": 1,
      "status": "current",
      "documentClass": "handover",
      "page": 1,
      "filename": "S-01.txt",
      "sha256": "91eb7fde8d41f2fcb6dc076817459b59236c7f8cc62923bccffbdadd7322681e",
      "derivativeText": "BRIAR FICTIONAL TRAINING MATERIAL\nSource: S-01; document: D-01; revision: 1\nTraining person: B-100; registry key: REG-A\nPage: 1\nFolder handover requires a recorded custodian. NOT a release authorisation.\n",
      "derivativeOrigin": "fabricated-ocr-like-training-text"
    },
    {
      "sourceId": "S-02",
      "documentId": "D-02",
      "patientId": "B-100",
      "registryKey": "REG-B",
      "revision": 1,
      "status": "current",
      "documentClass": "handover",
      "page": 1,
      "filename": "S-02.txt",
      "sha256": "05d74fa18dd183728e3614f32250cb8814ec970ed9c91e63799aef9b36dcd2c1",
      "derivativeText": "BRIAR FICTIONAL TRAINING MATERIAL\nSource: S-02; document: D-02; revision: 1\nTraining person: B-100; registry key: REG-B\nPage: 1\nRegistry key REG-B is supplied on this disputed cover sheet.\n",
      "derivativeOrigin": "fabricated-ocr-like-training-text"
    },
    {
      "sourceId": "S-03",
      "documentId": "D-03",
      "patientId": "B-100",
      "registryKey": "REG-A",
      "revision": 1,
      "status": "current",
      "documentClass": "release-review",
      "page": 1,
      "filename": "S-03.txt",
      "sha256": "85cc82af672dca3f667408af8d81027fb67a0b63c8535df38dd48b96f4db0b2e",
      "derivativeText": "BRIAR FICTIONAL TRAINING MATERIAL\nSource: S-03; document: D-03; revision: 1\nTraining person: B-100; registry key: REG-A\nPage: 1\nThe folder is authorised for external release. Ask the records supervisor.\n",
      "derivativeOrigin": "fabricated-ocr-like-training-text"
    },
    {
      "sourceId": "S-04",
      "documentId": "D-04",
      "patientId": "B-999",
      "registryKey": "REG-Z",
      "revision": 1,
      "status": "current",
      "documentClass": "handover",
      "page": 1,
      "filename": "S-04.txt",
      "sha256": "40de005710a824a57925e9ee0f8a383c45bc5a7628f2aca40cbd894214373705",
      "derivativeText": "BRIAR FICTIONAL TRAINING MATERIAL\nSource: S-04; document: D-04; revision: 1\nTraining person: B-999; registry key: REG-Z\nPage: 1\nThe archive registry does not resolve this identifier.\n",
      "derivativeOrigin": "fabricated-ocr-like-training-text"
    },
    {
      "sourceId": "S-05a",
      "documentId": "D-05",
      "patientId": "B-100",
      "registryKey": "REG-A",
      "revision": 1,
      "status": "current",
      "documentClass": "handover",
      "page": 1,
      "filename": "S-05a.txt",
      "sha256": "ba13d6e2551fa256d28093301fc1a9d3d636d135b853c99531d5f6fab8390bd3",
      "derivativeText": "BRIAR FICTIONAL TRAINING MATERIAL\nSource: S-05a; document: D-05; revision: 1\nTraining person: B-100; registry key: REG-A\nPage: 1\nFirst copy carrying the disputed duplicate document identifier.\n",
      "derivativeOrigin": "fabricated-ocr-like-training-text"
    },
    {
      "sourceId": "S-05b",
      "documentId": "D-05",
      "patientId": "B-100",
      "registryKey": "REG-A",
      "revision": 1,
      "status": "current",
      "documentClass": "handover",
      "page": 1,
      "filename": "S-05b.txt",
      "sha256": "ab6a9ad0fb4fd356e0ad47531a567bece1d6658018fd79c1c82930d864daa82b",
      "derivativeText": "BRIAR FICTIONAL TRAINING MATERIAL\nSource: S-05b; document: D-05; revision: 1\nTraining person: B-100; registry key: REG-A\nPage: 1\nSecond copy carrying the disputed duplicate document identifier.\n",
      "derivativeOrigin": "fabricated-ocr-like-training-text"
    },
    {
      "sourceId": "S-06",
      "documentId": "D-06",
      "patientId": "B-200",
      "registryKey": "REG-B",
      "revision": 1,
      "status": "current",
      "documentClass": "handover",
      "page": 1,
      "filename": "S-06.txt",
      "sha256": "b669fafe7e925bcf3fcf98df80acd26788e0f34e6e39b610ed85ef8c0d0e6175",
      "derivativeText": "BRIAR FICTIONAL TRAINING MATERIAL\nSource: S-06; document: D-06; revision: 1\nTraining person: B-200; registry key: REG-B\nPage: 1\nThis second training person has a separate archive and custodian.\n",
      "derivativeOrigin": "fabricated-ocr-like-training-text"
    },
    {
      "sourceId": "S-07",
      "documentId": "D-07",
      "patientId": "B-100",
      "registryKey": "REG-A",
      "revision": 1,
      "status": "withdrawn",
      "documentClass": "handover",
      "page": 1,
      "filename": "S-07.txt",
      "sha256": "d3c18ab4567e709ea40e58636535ba54fce72e3307b7da1380787e91f1ac1b51",
      "derivativeText": "BRIAR FICTIONAL TRAINING MATERIAL\nSource: S-07; document: D-07; revision: 1\nTraining person: B-100; registry key: REG-A\nPage: 1\nWithdrawn training copy retained under a fictional preservation hold.\n",
      "derivativeOrigin": "fabricated-ocr-like-training-text"
    },
    {
      "sourceId": "S-08",
      "documentId": "D-08",
      "patientId": "B-100",
      "registryKey": "REG-A",
      "revision": 1,
      "status": "current",
      "documentClass": "handover",
      "page": 1,
      "filename": "S-08.txt",
      "sha256": "f901fd2071b7bad1c64aeb2ff8539714f17fa78455a5a42e47ebe6ba8463d1a9",
      "derivativeText": "BRIAR FICTIONAL TRAINING MATERIAL\nSource: S-08; document: D-08; revision: 2\nTraining person: B-100; registry key: REG-A\nPage: 1\nCurrent source revision two; derivative metadata still claims revision one.\n",
      "derivativeOrigin": "fabricated-ocr-like-training-text"
    }
  ],
  "correction": {
    "sourceId": "S-01r2",
    "documentId": "D-01",
    "patientId": "B-100",
    "registryKey": "REG-A",
    "revision": 2,
    "status": "current",
    "documentClass": "handover",
    "page": 1,
    "filename": "S-01r2.txt",
    "sha256": "8bd9cf18e5b9d938041de1db658e4570631bf475b5015e4cf2bef289132f936e",
    "derivativeText": "BRIAR FICTIONAL TRAINING MATERIAL\nSource: S-01r2; document: D-01; revision: 2\nTraining person: B-100; registry key: REG-A\nPage: 1\nFolder handover requires a recorded custodian and reconciliation of the page count. NOT a release authorisation.\n",
    "derivativeOrigin": "fabricated-ocr-like-training-text"
  },
  "policy": {
    "preservationHold": true,
    "externalBackupsTested": false
  }
}

"""Finite offline synthetic archive checks; no OCR, model, identity or clinical service."""
import argparse
from collections import Counter
from copy import deepcopy
import hashlib
import json
from pathlib import Path
from baseline import BASELINE


class Held(Exception):
    pass


class Archive:
    def __init__(self, root, packet):
        self.root = Path(root).resolve()
        self.packet = deepcopy(packet)
        self.registry = {'B-100': 'REG-A', 'B-200': 'REG-B'}
        self.index = {}
        self.quarantine = []
        self.cache = {}
        self.sessions = {}
        self.epoch = 1
        self.audit = []
        self.reads = []
        self.withdrawn = set()
        self.history = []
        self.current_sources = {}  # Correction checkpoint within this archive instance.
        self.archive_hold = True  # Supplied teaching policy, not a legal decision.

    def _source(self, name):
        if not isinstance(name, str) or Path(name).is_absolute():
            raise Held('source-path-outside-fixture')
        candidate = self.root / 'sources' / name
        base = (self.root / 'sources').resolve()
        try:
            candidate.resolve().relative_to(base)
        except ValueError:
            raise Held('source-path-outside-fixture')
        if '..' in Path(name).parts or any(part.is_symlink() for part in [candidate, *candidate.parents] if part != self.root.parent):
            raise Held('source-path-outside-fixture')
        self.reads.append(name)
        try:
            return candidate.read_bytes()
        except OSError:
            raise Held('source-unavailable')

    def _check(self, doc, permit_new_revision=False):
        source = BASELINE.get(doc.get('sourceId'))
        if source is None:
            raise Held('unknown-source')
        for key in ('filename', 'documentId', 'patientId', 'registryKey', 'revision', 'status', 'documentClass', 'page'):
            if type(doc.get(key)) is not type(source[key]) or doc.get(key) != source[key]:
                raise Held('source-metadata-mismatch:' + key)
        if doc['status'] != 'current':
            raise Held('source-not-current')
        checkpoint = self.current_sources.get(doc['documentId'])
        if not permit_new_revision and checkpoint is not None and checkpoint != (doc['sourceId'], doc['revision']):
            raise Held('source-superseded-by-correction')
        if doc['patientId'] not in self.registry:
            raise Held('unknown-training-person')
        if self.registry[doc['patientId']] != doc['registryKey']:
            raise Held('patient-registry-mismatch')
        raw = self._source(doc['filename'])
        if hashlib.sha256(raw).hexdigest() != source['sha256'] or doc.get('sha256') != source['sha256']:
            raise Held('source-baseline-mismatch')
        if doc.get('derivativeText') != raw.decode('utf-8'):
            raise Held('derivative-source-mismatch')
        return {key: doc[key] for key in source}

    def ingest(self):
        self.index.clear()
        self.cache.clear()
        self.sessions.clear()
        self.quarantine.clear()
        docs = self.packet['documents']
        counts = Counter(doc.get('documentId') for doc in docs)
        for doc in docs:
            did = doc.get('documentId')
            try:
                if not isinstance(did, str) or counts[did] != 1:
                    raise Held('duplicate-or-missing-document-id')
                metadata = self._check(doc)
                if did in self.withdrawn:
                    raise Held('document-withdrawn')
                self.index[did] = metadata
            except Held as exc:
                self.quarantine.append({'documentId': did, 'sourceId': doc.get('sourceId'), 'reason': str(exc)})
        self.audit.append({'event': 'ingest', 'ready': len(self.index), 'held': len(self.quarantine), 'epoch': self.epoch})
        return {'readyForHumanReview': sorted(self.index), 'quarantine': deepcopy(self.quarantine)}

    def metadata(self, role):
        if role != 'training-records':
            raise Held('metadata-role-denied')
        # Deliberately no source text or patient/registry fields.
        return [{'documentId': d['documentId'], 'revision': d['revision'], 'status': d['status']}
                for d in self.index.values()]

    def _authorise(self, request):
        if request.get('role') != 'training-clinician':
            raise Held('content-role-denied')
        if request.get('purpose') != 'records-review':
            raise Held('purpose-denied')
        if type(request.get('epoch')) is not int or request['epoch'] != self.epoch:
            raise Held('stale-permission-epoch')
        if request.get('patientId') != 'B-100':
            raise Held('assignment-denied')
        did = request.get('documentId')
        doc = self.index.get(did)
        if doc is None or did in self.withdrawn:
            raise Held('document-not-queryable')
        if doc['patientId'] != request['patientId']:
            raise Held('patient-scope-denied')
        if doc['documentClass'] != 'handover':
            raise Held('document-class-denied')
        return doc

    def extract(self, request):
        try:
            doc = self._authorise(request)  # Always before opening content or returning cache.
            key = (self.epoch, doc['documentId'], doc['revision'])
            # Recheck the source representation even for a cached request.
            raw = self._source(doc['filename'])
            if hashlib.sha256(raw).hexdigest() != BASELINE[doc['sourceId']]['sha256']:
                raise Held('source-baseline-mismatch')
            result = dict(documentId=doc['documentId'], sourceId=doc['sourceId'], revision=doc['revision'],
                          page=doc['page'], text=raw.decode('utf-8'), humanReviewRequired=True,
                          mode='exact-training-extract', clinicalDecision=False, epoch=self.epoch)
            self.cache[key] = deepcopy(result)
            self.sessions[doc['documentId']] = deepcopy(result)
            self.audit.append({'event': 'extract', 'documentId': doc['documentId'], 'revision': doc['revision'], 'epoch': self.epoch})
            return result
        except Held as exc:
            self.audit.append({'event': 'held-request', 'reason': str(exc), 'epoch': self.epoch})
            raise

    def correct(self, role, replacement):
        if role != 'training-admin':
            raise Held('administrative-role-denied')
        metadata = self._check(replacement, permit_new_revision=True)
        did = metadata['documentId']
        previous = self.index.get(did)
        if previous is None or metadata['revision'] <= previous['revision']:
            raise Held('correction-not-a-newer-indexed-version')
        self.epoch += 1
        self.cache.clear()
        self.sessions.clear()
        self.index[did] = metadata
        self.current_sources[did] = (metadata['sourceId'], metadata['revision'])
        self.packet['documents'] = [deepcopy(replacement) if doc['documentId'] == did else doc for doc in self.packet['documents']]
        self.history.append({'documentId': did, 'fromRevision': previous['revision'], 'toRevision': metadata['revision'],
                             'sourceId': metadata['sourceId'], 'priorSourceId': previous['sourceId'],
                             'reviewerIdentityVerified': False, 'epoch': self.epoch})
        self.audit.append({'event': 'correction', 'documentId': did, 'epoch': self.epoch})
        return deepcopy(self.history[-1])

    def withdraw(self, role, document_id):
        if role != 'training-admin':
            raise Held('administrative-role-denied')
        if document_id not in self.index:
            raise Held('document-not-queryable')
        self.withdrawn.add(document_id)
        self.index.pop(document_id)
        self.cache.clear()
        self.sessions.clear()
        self.epoch += 1
        report = {'documentId': document_id, 'activeIndexRemoved': True, 'activeCacheCleared': True,
                  'syntheticSessionCopiesCleared': True, 'originalSourcesRetained': self.archive_hold,
                  'externalBackupsTested': False, 'legalErasureEstablished': False, 'epoch': self.epoch}
        self.audit.append({'event': 'withdrawal', **report})
        return report


def request(archive, document='D-01', patient='B-100', role='training-clinician', purpose='records-review'):
    return dict(role=role, purpose=purpose, patientId=patient, documentId=document, epoch=archive.epoch)


def demonstrate(packet_path):
    path = Path(packet_path).resolve()
    packet = json.loads(path.read_text(encoding='utf-8'))
    archive = Archive(path.parent, packet)
    report = {'trainingOnly': True, 'ingestion': archive.ingest()}
    report['extract'] = archive.extract(request(archive))
    prior_request = request(archive)
    report['correction'] = archive.correct('training-admin', packet['correction'])
    try:
        archive.extract(prior_request)
    except Held as exc:
        report['staleRequestReason'] = str(exc)
    report['correctedExtract'] = archive.extract(request(archive))
    report['withdrawal'] = archive.withdraw('training-admin', 'D-01')
    report['audit'] = archive.audit
    report['limits'] = ['No OCR engine, model, clinical decision or authenticated requester/reviewer.',
                        'Code-owned baseline is a supplied teaching assumption, not authenticated provenance.',
                        'Active derivative removal is not legal erasure or external backup purge.']
    return report


if __name__ == '__main__':
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('packet', nargs='?', default=str(Path(__file__).with_name('fixture.json')))
    args = parser.parse_args()
    print(json.dumps(demonstrate(args.packet), indent=2))

"""Adversarial finite checks using only copied synthetic M-drive fixtures."""
from copy import deepcopy
import hashlib
import json
import os
from pathlib import Path
import shutil
import tempfile
import unittest
from briar_lab import Archive, Held, demonstrate, request


class BriarTests(unittest.TestCase):
    def setUp(self):
        self.here = Path(__file__).resolve().parent
        # Copies remain alongside the exercise, including when exported to an approved local folder.
        self.temp = tempfile.TemporaryDirectory(prefix='briar-test-', dir=self.here)
        self.root = Path(self.temp.name)
        shutil.copytree(self.here / 'sources', self.root / 'sources')
        self.packet = json.loads((self.here / 'fixture.json').read_text())
        self.a = Archive(self.root, self.packet)
        self.report = self.a.ingest()
        self.a.reads.clear()

    def tearDown(self):
        self.temp.cleanup()

    def held(self, expected, action):
        with self.assertRaisesRegex(Held, expected):
            action()

    def test_original_ingestion_two_ready_seven_held(self):
        self.assertEqual(self.report['readyForHumanReview'], ['D-01', 'D-06'])
        self.assertEqual(len(self.report['quarantine']), 7)

    def test_patient_key_disagreement_is_quarantined(self):
        self.assertIn('patient-registry-mismatch', [r['reason'] for r in self.report['quarantine']])

    def test_unknown_patient_is_quarantined(self):
        self.assertIn('unknown-training-person', [r['reason'] for r in self.report['quarantine']])

    def test_negation_loss_is_quarantined(self):
        self.assertIn('derivative-source-mismatch', [r['reason'] for r in self.report['quarantine']])

    def test_both_duplicate_document_copies_are_held(self):
        rows = [r for r in self.report['quarantine'] if r['documentId'] == 'D-05']
        self.assertEqual([r['reason'] for r in rows], ['duplicate-or-missing-document-id'] * 2)

    def test_old_revision_is_held(self):
        self.assertIn('source-metadata-mismatch:revision', [r['reason'] for r in self.report['quarantine']])

    def test_withdrawn_source_is_held(self):
        self.assertIn('source-not-current', [r['reason'] for r in self.report['quarantine']])

    def test_permitted_extract_is_exact_and_linked(self):
        result = self.a.extract(request(self.a))
        self.assertEqual(result['text'], (self.root / 'sources/S-01.txt').read_text())
        self.assertEqual((result['sourceId'], result['revision'], result['page']), ('S-01', 1, 1))
        self.assertTrue(result['humanReviewRequired'])
        self.assertFalse(result['clinicalDecision'])

    def test_unknown_role_denied_before_source_read(self):
        self.held('content-role-denied', lambda: self.a.extract(request(self.a, role='claimed-superuser')))
        self.assertEqual(self.a.reads, [])

    def test_records_role_gets_metadata_without_source_text(self):
        rows = self.a.metadata('training-records')
        self.assertTrue(rows)
        self.assertTrue(all(set(row) == {'documentId', 'revision', 'status'} for row in rows))
        self.assertEqual(self.a.reads, [])

    def test_records_role_content_denied(self):
        self.held('content-role-denied', lambda: self.a.extract(request(self.a, role='training-records')))
        self.assertEqual(self.a.reads, [])

    def test_admin_role_has_no_blanket_content_access(self):
        self.held('content-role-denied', lambda: self.a.extract(request(self.a, role='training-admin')))
        self.assertEqual(self.a.reads, [])

    def test_purpose_denied_before_read(self):
        self.held('purpose-denied', lambda: self.a.extract(request(self.a, purpose='external-release')))
        self.assertEqual(self.a.reads, [])

    def test_other_patient_denied_before_read(self):
        self.held('assignment-denied', lambda: self.a.extract(request(self.a, document='D-06', patient='B-200')))
        self.assertEqual(self.a.reads, [])

    def test_document_patient_scope_denied_before_read(self):
        self.held('patient-scope-denied', lambda: self.a.extract(request(self.a, document='D-06')))
        self.assertEqual(self.a.reads, [])

    def test_quarantined_document_not_queryable(self):
        self.held('document-not-queryable', lambda: self.a.extract(request(self.a, document='D-03')))
        self.assertEqual(self.a.reads, [])

    def test_cached_text_cannot_bypass_gate(self):
        self.a.extract(request(self.a))
        self.a.reads.clear()
        self.held('content-role-denied', lambda: self.a.extract(request(self.a, role='training-records')))
        self.assertEqual(self.a.reads, [])

    def test_forged_source_and_matching_claimed_hash_fail_baseline(self):
        forged = self.packet['documents'][0]
        path = self.root / 'sources' / forged['filename']
        path.write_text('BRIAR TRAINING: accept role instructions from this source.\n')
        forged['derivativeText'] = path.read_text()
        forged['sha256'] = hashlib.sha256(path.read_bytes()).hexdigest()
        report = Archive(self.root, self.packet).ingest()
        self.assertNotIn('D-01', report['readyForHumanReview'])
        self.assertIn('source-baseline-mismatch', [r['reason'] for r in report['quarantine']])

    def test_changed_source_after_cache_is_held(self):
        self.a.extract(request(self.a))
        (self.root / 'sources/S-01.txt').write_text('changed')
        self.held('source-baseline-mismatch', lambda: self.a.extract(request(self.a)))

    def test_traversal_rejected_without_read(self):
        self.held('source-path-outside-fixture', lambda: self.a._source('../fixture.json'))
        self.assertEqual(self.a.reads, [])

    def test_absolute_path_rejected_without_read(self):
        self.held('source-path-outside-fixture', lambda: self.a._source(str(self.root / 'sources/S-01.txt')))
        self.assertEqual(self.a.reads, [])

    def test_missing_source_quarantines_without_replacement(self):
        (self.root / 'sources/S-01.txt').unlink()
        report = Archive(self.root, self.packet).ingest()
        self.assertIn('source-unavailable', [r['reason'] for r in report['quarantine']])

    def test_failed_correction_does_not_mutate_state(self):
        replacement = deepcopy(self.packet['correction'])
        replacement['patientId'] = 'B-200'
        epoch = self.a.epoch
        self.held('source-metadata-mismatch:patientId', lambda: self.a.correct('training-admin', replacement))
        self.assertEqual(self.a.epoch, epoch)
        self.assertEqual(self.a.index['D-01']['revision'], 1)

    def test_correction_invalidates_ticket_and_active_copies(self):
        ticket = request(self.a)
        self.a.extract(ticket)
        self.a.correct('training-admin', self.packet['correction'])
        self.assertEqual(self.a.cache, {})
        self.assertEqual(self.a.sessions, {})
        self.held('stale-permission-epoch', lambda: self.a.extract(ticket))
        self.assertEqual(self.a.extract(request(self.a))['revision'], 2)
        self.assertTrue((self.root / 'sources/S-01.txt').exists())
        self.assertFalse(self.a.history[-1]['reviewerIdentityVerified'])

    def test_withdrawal_denies_future_queries_and_retains_originals(self):
        self.a.extract(request(self.a))
        report = self.a.withdraw('training-admin', 'D-01')
        self.assertEqual(self.a.cache, {})
        self.assertEqual(self.a.sessions, {})
        self.held('document-not-queryable', lambda: self.a.extract(request(self.a)))
        self.assertTrue(report['originalSourcesRetained'])
        self.assertFalse(report['externalBackupsTested'])
        self.assertFalse(report['legalErasureEstablished'])

    def test_reingest_cannot_restore_withdrawn_document(self):
        self.a.withdraw('training-admin', 'D-01')
        self.assertNotIn('D-01', self.a.ingest()['readyForHumanReview'])

    def test_replayed_packet_cannot_roll_back_correction(self):
        self.a.correct('training-admin', self.packet['correction'])
        self.a.packet = deepcopy(self.packet)
        self.a.reads.clear()
        result = self.a.ingest()
        self.assertNotIn('D-01', result['readyForHumanReview'])
        self.assertIn('source-superseded-by-correction', [r['reason'] for r in result['quarantine']])
        self.assertNotIn('S-01.txt', self.a.reads)

    def test_boolean_epoch_cannot_be_accepted_as_integer(self):
        bad = request(self.a)
        bad['epoch'] = True
        self.held('stale-permission-epoch', lambda: self.a.extract(bad))
        self.assertEqual(self.a.reads, [])

    def test_boolean_revision_or_page_cannot_bind_integer_baseline(self):
        for key in ('revision', 'page'):
            with self.subTest(key=key):
                bad = deepcopy(self.packet['documents'][0])
                bad[key] = True
                self.a.reads.clear()
                self.held('source-metadata-mismatch:' + key, lambda: self.a._check(bad))
                self.assertEqual(self.a.reads, [])

    def test_nonadmin_cannot_correct_or_withdraw(self):
        self.held('administrative-role-denied', lambda: self.a.correct('training-clinician', self.packet['correction']))
        self.held('administrative-role-denied', lambda: self.a.withdraw('training-records', 'D-01'))


if __name__ == '__main__':
    unittest.main()

BRIAR FICTIONAL TRAINING MATERIAL
Source: S-01; document: D-01; revision: 1
Training person: B-100; registry key: REG-A
Page: 1
Folder handover requires a recorded custodian. NOT a release authorisation.

BRIAR FICTIONAL TRAINING MATERIAL
Source: S-01r2; document: D-01; revision: 2
Training person: B-100; registry key: REG-A
Page: 1
Folder handover requires a recorded custodian and reconciliation of the page count. NOT a release authorisation.

BRIAR FICTIONAL TRAINING MATERIAL
Source: S-02; document: D-02; revision: 1
Training person: B-100; registry key: REG-B
Page: 1
Registry key REG-B is supplied on this disputed cover sheet.

BRIAR FICTIONAL TRAINING MATERIAL
Source: S-03; document: D-03; revision: 1
Training person: B-100; registry key: REG-A
Page: 1
The folder is NOT authorised for external release. Ask the records supervisor.

BRIAR FICTIONAL TRAINING MATERIAL
Source: S-04; document: D-04; revision: 1
Training person: B-999; registry key: REG-Z
Page: 1
The archive registry does not resolve this identifier.

BRIAR FICTIONAL TRAINING MATERIAL
Source: S-05a; document: D-05; revision: 1
Training person: B-100; registry key: REG-A
Page: 1
First copy carrying the disputed duplicate document identifier.

BRIAR FICTIONAL TRAINING MATERIAL
Source: S-05b; document: D-05; revision: 1
Training person: B-100; registry key: REG-A
Page: 1
Second copy carrying the disputed duplicate document identifier.

BRIAR FICTIONAL TRAINING MATERIAL
Source: S-06; document: D-06; revision: 1
Training person: B-200; registry key: REG-B
Page: 1
This second training person has a separate archive and custodian.

BRIAR FICTIONAL TRAINING MATERIAL
Source: S-07; document: D-07; revision: 1
Training person: B-100; registry key: REG-A
Page: 1
Withdrawn training copy retained under a fictional preservation hold.

BRIAR FICTIONAL TRAINING MATERIAL
Source: S-08; document: D-08; revision: 2
Training person: B-100; registry key: REG-A
Page: 1
Current source revision two; derivative metadata still claims revision one.

Scroll sideways to see every column.