Law-firm AI governance and supplier assurance

Learn in your browser · Chapter 01 of 08

Define the intended activity and its accountable evidence owners before discussing a product. Greybeam and Paperbridge are fictional; this is adult educational decision preparation.

A supplier decision begins with a proposed activity, not a product ranking. Greybeam is an invented firm considering Paperbridge, an invented provider. Its question is whether two administration structures could be explored without client content. A statement that a product is safe for law firms cannot answer that smaller question. It hides the receiving function, affected information and accountable decision. Write an activity that someone can refuse: prepare a blank receiving-purpose shell for an internal fictional review. The verb, input and destination define the boundary.

Risk ownership means identifying who must obtain evidence, who can challenge it and who has authority to decide the next step. These are different jobs even when a small organisation assigns several to one person. A supplier can describe its service and make commitments; it cannot supply professional judgement by attaching a badge. The course's proposed functions are planning labels, not appointments. No named participant, practising qualification, delegation or actual supplier approval exists in Greybeam. Keep that absence visible in every decision docket.

For SRA-authorised firms, the current Code of Conduct for Firms retains accountability when work is carried out through others. Its business systems and supervision provisions support records and active oversight. That is an England and Wales regulatory context, not a universal rule for every legal business. Read the applicable regime before transferring this lesson to Scotland, Northern Ireland, barristers or overseas practice. Our docket is an original teaching method for organising questions; completing it does not demonstrate compliance with those provisions. [Source: sra-firm-controls.]

Distinguish three levels of evidence. An assertion is what a party says. A bounded supporting record shows what that statement covers. A decision explains what follows and what remains unresolved. C01 supplies an authored instruction schedule limited to synthetic administration shells. Its paper disposition is DOCUMENTED_LIMIT. C06 supplies a badge without scope, issuer, expiry or control evidence and conflicts with that schedule. Its disposition is HOLD_UNSUPPORTED. Neither is a verdict about a real provider. The distinction prevents an attractive assertion from becoming the decision itself.

C08 describes an assumed reviewer who owns synthetic pack completeness. It makes a useful exercise boundary because it says what that reviewer would inspect. It does not authenticate a person or show competence to approve professional services. A reviewer could confirm that every fictional control and use is represented while actual-use gates remain closed. When a form has a signature box, ask what decision the signature covers, what evidence supports it and whether the signer can require correction. A tick is not that explanation.

Start the responsibility docket with the proposed partner function. In our filled example, that function asks whether the narrowly stated benefit justifies further investigation and confirms that firm-wide deployment is excluded. The compliance function asks which professional obligations and supervisory arrangements would apply. The contracting function requests the exact service entity, versioned terms and instruction schedule. None is marked as having agreed. An unresolved owner is a gap to resolve, not an invitation to replace an actual decision with an assistant's recommendation.

The privacy function separately asks whether the activity involves personal data, who determines purposes and means and which basis or additional conditions could apply. The security function requests access, boundary and recovery evidence for the actual receiving service. The records function asks which records are needed, who controls them and how continuity would work. This separation exposes disagreements. A contracting statement about export format does not answer a privacy question about permitted secondary use. Record a cross-reference rather than merging both into one approval field.

A useful hold has an object and a route to reconsideration. Pending alone gives no clue what must change. Our C06 row says: firm-wide legal release held; missing badge scope and relevant control evidence; proposed security owner to obtain evidence; proposed compliance owner to assess applicability; no deadline or acceptance asserted. This is more useful than colouring the vendor amber. The row supplies a next evidence question without predicting that it will be answered favourably. It also preserves who would need to challenge the answer.

An ordinary prompt asks, 'Which tool is safe for our firm?' It encourages a general recommendation without intended use or evidence boundary. Our stronger prompt gives the assistant a docket-editor role and supplies C01, C06 and C08 only. It prohibits real client content and asks for assertion, supplied evidence, missing facts, proposed owner and disposition. Preserve uncertainties rather than filling them from brand reputation. The result can be assessed against the supplied cards even if it is written on paper and no model is available.

Specify verification before seeing the response. Confirm that C01 remains a documented synthetic limit, C06 remains unsupported and C08 remains assumed completeness supervision. Reject any output that calls the provider approved, certifies the reviewer or expands input to client letters. Check each source identifier against the supplied card and each owner against the proposed-function list. These checks evaluate fidelity to the exercise. They do not establish that an actual provider has implemented the safeguards or that an actual firm may use it.

The SRA AI warning of 17 August 2026 emphasises use-specific safeguards and continuing professional responsibility. It addresses regulated firms and individuals. We use that bounded warning to explain why a paid account or in-house label is insufficient information. Its linked court references are not a new legal opinion about privilege, and we do not declare every upload public. Greybeam's client input remains absent. An actual recipient, tool architecture, circumstances and professional assessment would be needed before drawing such conclusions. [Source: sra-ai-safeguards.]

Translate benefit into an observable proposal. U01 concerns fixed administration headings, so a future study might compare completeness and clarity of blank shells with a non-AI template. It should not claim improved legal outcomes, fewer breaches or time saved until appropriate investigation supplies evidence. Recording a modest benefit makes trade-offs discussable. A reviewer can ask whether the existing template already solves the need. A useful alternative strengthens the supplier decision because stopping the AI proposal then leaves the underlying administrative task supported.

Keep two independent fields in the decision ledger: educational completeness and real-use permission. Educational completeness can support discussion when each question has a supplied basis or a visible gap. Real-use permission stays HOLD throughout this exercise. Do not combine them into one green status. A packet faithfully recording three unresolved controls may be better teaching work than a polished packet hiding them. The reader should trace both limited positive evidence and negative consequences without guessing what colour means. This makes disagreement inspectable rather than an argument about confidence.

The NIST AI Risk Management Framework overview is a voluntary cross-sector reference. It can frame organisational risk questions, but reading it does not establish detailed conformity or supplier certification. This course does not claim an audit of its full framework or profiles. Use the overview as a signpost with stated scope. A decision row still needs evidence for the particular use, regardless of how many frameworks a presentation cites. The number of references is not a substitute for relevance. [Source: nist-voluntary-rmf.]

Maintain decision history instead of rewriting the first row when evidence changes. A revised schedule could remove a previously documented limit. Preserve the earlier assertion, its version and why it no longer supports the current proposal. Otherwise a later reviewer may mistake an old positive statement for present authority. In Tallygate, versioned state and cache rules are approved educational mechanics, but no implementation or runtime evidence is supplied in this batch. A paper trace is a prediction from the contract, not an observed record of software behaviour.

A defensible opening decision is a question-bearing document. Greybeam may discuss two synthetic-only plans while retaining four held uses and unresolved supplier facts. Proposed functions can request evidence and challenge contradictions; none has been authenticated or professionally appointed by this workbook. Before moving on, another adult should identify the input boundary, benefit hypothesis, exclusions and next evidence owner from your docket. If they cannot, improve the explanation rather than lowering the hold. The document should remain useful without relying on trust in its author or an assumed reviewer.

1. State the activity, intended benefit and receiving surface.
2. Separate assertion, supplied evidence and decision.
3. Fill all six proposed responsibility functions.
4. Compare C01/C06/C08 without turning labels into approval.
5. Set a specific hold and next evidence question.
6. Verify that another adult can reconstruct the boundary.

Scroll sideways to see every column.

ROLE: Greybeam fictional supplier-docket editor.
CONSTRAINTS: C01/C06/C08 only; no real client content, legal advice, appointed professionals or provider approval.
PROCESS: Separate assertion, supplied evidence and consequence; fill six proposed functions and next questions.
VERIFICATION: C01 DOCUMENTED_LIMIT; C06 HOLD_UNSUPPORTED; C08 assumed completeness only; actual facts stay unknown.
OUTPUT SCHEMA: function;control;suppliedBasis;missingEvidence;proposedQuestion;paperDisposition;actualStatus=HOLD.
FAILURE MODES: Reject badge-as-approval, assumed-role-as-identity, expanded inputs and invented beneficial results. Paper prompt only.

Diagram text equivalent: A bounded purpose leads to the three supplied control cards, then to six proposed responsibility functions and a question-bearing docket. The final state remains real-use HOLD. Unsupported C06 is retained in the evidence row; no function is authenticated or appointed.

You remain accountable for compliance

Learn in your browser · Chapter 02 of 08

Represent all six future uses and their dependencies. Missing or excluded bodies stay absent; limited synthetic plans and real-use permission are separate.

A use inventory records what information would travel where and why. It is more precise than an approved-tools list because the same tool could be proposed for a blank form, a client letter, training or support access. Greybeam supplies six future-use plans, U01 to U06. Each has a fixed input descriptor, dependencies and paper disposition. Keep all six visible. Removing the four held uses would conceal the temptations the inventory is designed to control and make a restricted plan look like permission for the whole service.

U01 is a blank administration shell using R01, whose supplied body contains headings and an explicit absence of client information or legal advice. U02 is a synthetic review checklist using R02. Both require C01, C02, C07 and C08. Their initial paper status is LIMITED_PILOT_PLAN: a bounded plan can be discussed, not a pilot ran or a model succeeded. Neither needs actual matter material. An adult can evaluate the structures on paper and compare them with an ordinary non-AI document template before any service investigation.

U03 proposes a client-letter upload through R05. R05 is an excluded descriptor with no body, unresolved ownership and unresolved rights. Its title does not authorise content admission. Record the receiving surface as a proposed upload interface and the output as unavailable because input is excluded. Do not invent a sample client letter to make the exercise realistic. The absent body is deliberate: it lets you identify the proposed flow without exposing or fabricating client affairs. U03 stays HOLD_USE under this finite educational schedule.

U04 proposes unrestricted training using R01, R02 and R03. These records carry fictional owned-export labels, but an export label is not training permission. The authored policy-one schedule states trainingUse NONE; unrestricted training is outside the permitted-use schedule. Ownership, access and permitted purpose are separate questions. A party might possess a copy without authority for a new use. The proposed improvement surface is identified in the inventory, but no training operation runs. U04 remains held even after the later POLICY2 change is proposed.

U05 concerns privileged support access to R04, a provider-internal-log descriptor without a body. Dependencies C04 and C05 are unknown. Its row names missing facts: access scope, support organisation, location, subprocessor arrangements and authority. It does not decide that support can never be allowed or that provider logs belong to the firm. U06 proposes firm-wide legal release using R01 and dependencies C06 and C08. An unsupported badge and an assumed completeness reviewer do not turn a blank shell into professional service approval. Both uses remain HOLD_USE.

A receiving surface is the place or function that would receive information, not merely a provider name. List prompts, file uploads, generated outputs, task logs, improvement systems, support views, backups and exports separately. A prompt-box restriction says little about a support screenshot or an output copied elsewhere. Retain these questions even though no actual service is supplied here. Label each surface proposed and its actual recipient UNKNOWN. This prevents a diagram from silently becoming an asserted data-flow audit or an invented description of Paperbridge's infrastructure.

The SRA confidentiality guide treats third-party cloud storage as outsourcing and discusses protections for client information. Its recipient-and-purpose discussion supports careful disclosure questions. That does not choose a UK GDPR basis or settle privilege. Here professional confidentiality, data-protection applicability, source rights and contractual permission occupy separate columns. A statement in one cannot close another. No real retainer, client understanding, exception or recipient has been examined. Applicable professional and privacy reviews remain actual work to commission, not text that the worksheet can manufacture. [Source: sra-outsourcing-confidentiality.]

Minimisation begins with this evaluation's purpose. You need plan descriptions, supplied control dependencies and missing-evidence questions, not a client's letter, name or case history. ICO guidance describes adequate, relevant and necessary information for a stated purpose within UK GDPR applicability, with a DUAA review notice. Adequate matters: deleting dependency identifiers would reduce reviewability. Avoid unnecessary content while retaining enough fictional evidence to explain the decision. The absence of personal records here is a scenario boundary, not a finding of real privacy compliance. [Source: ico-purpose-minimum.]

Each flow row needs purpose, input, receiving surface, intended output, proposed supervision and exclusion. Fill actual record identifiers instead of a broad category such as documents. Then ask whether the output could contain information excluded at input. U03's unavailable output is honest. An assistant writing a plausible client-letter summary creates unsupported content even if it never reads a real letter. The exercise checks disciplined reasoning about absence, not removal of names after generation. Review the output's claims as well as its inputs before treating the inventory as complete.

Dependencies make the inventory testable. Write U01's four controls beside its row and check each independently. The shell's usefulness does not override a change to C02. Likewise, C07's supplied export schema cannot repair missing support-access evidence for U05. A result must be read with the exact control set supporting it. Under the approved paper contract, all eight current controls precede any use assessment, including held uses. Selecting only good cards would make the inventory incomplete rather than efficient, because unresolved controls are part of its purpose.

Compare an average prompt, 'Summarise our AI risks and suggest uploads,' with a bounded flow-map request. Give the editor role, supply only the six plans and record descriptors, and prohibit invented client content. Specify a process joining uses to controls and marking proposed surfaces. Verification checks R04, R05 and R06 for absent bodies and prevents export rights becoming new-purpose permission. The output schema forces exclusions and unknowns alongside benefits. This is a paper prompt and worked response, not a model trial or evidence of an assistant's reliability.

Suppose a response says, 'R01 is owned, so U04 training is acceptable.' That is purpose substitution, not arithmetic. Preserve the ownership label but restore the fixed training exclusion and C02 dependency. A second response calls R05 anonymised because its descriptor has no name. Correct it by stating that the body is absent and no anonymisation was assessed. These errors need different repairs. One conflates possession with use authority; the other converts missing evidence into a privacy result. Explain the repair rather than merely changing the status colour.

Read proposed counters as definitions rather than confidentiality measures. Assessment parses the complete fixture, including synthetic strings, without projecting owned bodies into its result. Zero projectedOwnedRecordOccurrences therefore differs from zero physical reads. The initial eight controls, six uses and F01 have a paper expectation of fifteen evaluations, fifteen completed reads and zero owned-body projection occurrences. No implementation was exercised to obtain those figures in this batch. Review and export have different counter effects; do not infer their values from the word read or from a reassuring summary.

Add a non-AI continuity route. For U01 and U02, a locally prepared blank template and human-completed checklist can serve the proposed administrative need while actual-use questions are unresolved. Describe that route without claiming deployment, universal accessibility or professional approval. Ask how an adult would obtain it without an AI account. Preserve the same exclusions. A manual process copying client content into an unreviewed sharing service would not solve the boundary problem merely by avoiding a model. The route must answer the user's task and the information restrictions together.

A complete inventory need not decide every real-world issue; it must make uncertainty actionable. For each surface assign a proposed function to establish the actual recipient, minimum information, access, purpose, retention and evidence. Mark that no interaction occurred. Readers can then investigate a question rather than debate whether an arrow describes reality. A future investigation may change a row, but record the new source and version. An unanswered question remains unanswered after a polished rewrite, and a new provider claim remains a claim until its relevance is assessed.

Compare the six rows as a set before proceeding. Two are synthetic administration plans; four are held for distinct reasons. This is not a model-quality prediction or a blanket prohibition on AI in legal services. It is the boundary of this finite scenario. Another reader should reconstruct dependencies and explain why R05 stays absent, R04 is not firm-owned and R01's export label does not permit training. The inventory becomes a usable input to terms review precisely because its limited positive results and exclusions remain available together for challenge.

1. List U01 through U06, including held uses.
2. Join every use to exact input and control IDs.
3. State receiving surface and intended output.
4. Keep absent bodies and excluded purposes explicit.
5. Add proposed supervision and non-AI continuity.
6. Check physical parsing separately from returned-body projections.

Scroll sideways to see every column.

ROLE: Greybeam fictional flow-inventory editor.
CONSTRAINTS: Six supplied uses and six record descriptors only; no new bodies, actual client facts, model run or professional permission.
PROCESS: Join purpose/input/control; fill receiving surface/output/supervision/exclusion for all six; identify proposed downstream surfaces.
VERIFICATION: U01/U02 limited plans only; U03..U06 held; R04/R05/R06 remain bodyless; export rights are not training permission.
OUTPUT SCHEMA: use;purpose;input;surface;output;controls;proposedSupervisor;exclusion;unknown;paperDisposition;realUse=HOLD.
FAILURE MODES: Reject title-as-permission, missing-body-as-anonymisation, owned-as-training-authority and removal of held rows. Paper only.

Diagram text equivalent: All six purposes pass through record and control joins to proposed surface and output questions. The initial paper matrix contains two limited plans and four held uses. Both paths remain actual-use HOLD; an absent client or provider body is never filled in.

what will be disclosed, for what and to whom.

Learn in your browser · Chapter 03 of 08

Compare supplied terms with the intended use, not with a general claim of compliance. Version and purpose changes alter the evidence question; real contracting remains unassessed.

Terms review asks what a specific service promises for a specific use, and what evidence is still needed. It is not a hunt for the most reassuring sentence. Paperbridge supplies an authored revision-one instruction schedule and several unresolved control cards. Separate the proposed processing purpose from the commercial description of the product. Then compare the actual supplied assertion with the intended activity and record the version. A clause that mentions improvement may concern a different purpose from producing a blank administration shell, even when both appear in the same service description.

Use a clause matrix with four working columns: topic, supplied fictional text or card, bounded consequence and missing actual evidence. This creates a practical reading method. The matrix should be intelligible to an adult who did not attend the supplier presentation. Instructions, secondary use, confidentiality, retention, support, change, assistance, audit and exit need their own questions. One broadly worded promise should not be copied into every row. If the schedule says nothing about a row, preserve that silence rather than invent a favourable interpretation or writing a replacement contract on the provider's behalf.

ICO's contract guidance explains Article 28 terms where UK GDPR controller-processor arrangements apply. It separately discusses documented instructions, confidentiality, security, subprocessors, assistance, end provisions and audits. Determine the actual parties and roles before treating that guidance as the governing checklist; this workbook has not determined them. The page remains under review following the Data (Use and Access) Act. Our matrix is an educational evidence request, not a drafted legal agreement or advice that a particular contract meets mandatory terms. [Source: ico-processor-terms.]

C02 gives the first useful comparison. At policy revision one, the authored schedule states trainingUse NONE. That supports DOCUMENTED_LIMIT within this exercise. It does not show that a real provider excluded improvement across logs, support and backups or accepted a binding instruction from Greybeam. Ask for the receiving entity, applicable terms version, feature configuration, purpose definition and evidence covering each surface. The schedule may be a good starting point while actual implementation and contracting evidence remain unknown. Keep both conclusions instead of inflating or dismissing the limited support.

The term improvement needs its own boundary. Does it mean correcting this user's draft, retaining task statistics, training shared models or some different activity? These are proposed questions, not supplied facts about Paperbridge. In Tallygate's authored policy-two event, trainingUse changes to CONTENT_IMPROVEMENT. C02 then becomes HOLD_CHANGED_POLICY, and U01 and U02 lose their limited-plan disposition. U04 unrestricted training remains outside the finite schedule. A provider's new permission to itself is not authority from the firm, a client or an applicable privacy decision to expand use.

Follow the changed assertion across its dependencies rather than editing one word in a summary. Initially U01 and U02 each rely on C02 as well as C01, C07 and C08. If C02 changes, the old row no longer supports their current plan even though their blank input records have not changed. This is why version fields matter. A cached positive result can be accurate about an earlier schedule and misleading about the current proposal. Preserve earlier text as history, mark its current effect and identify which new review would be needed.

Separate retention of a record from authority to assess a supplier. The supplied owned records expire after day three inclusively, while educational evidence authority lasts through day four. Renewal does not extend either deadline. Day-four control assessment can parse a complete synthetic fixture but cannot project expired owned bodies through an exit result. These are distinct approved paper mechanics. They are not statutory retention periods, actual deletion events or proof that no body string was physically read. A real contract needs its own justified scope, schedule and evidence.

End-of-contract wording needs careful interpretation. ICO guidance, within its conditional scope, addresses return or deletion at the controller's choice, copies, legally required storage and qualified backup handling. It does not establish immediate erasure of every backup. Ask how beyond-use safeguards, an appropriate period and later deletion would be evidenced where relevant. Greybeam supplies no actual deletion certificate, backup system or provider contract. Do not translate a successful owned-record export into a statement that the supplier erased its copies. [Source: ico-processor-terms.]

C05 illustrates the difference between a notice promise and a usable change process. The card says that notice is promised, but the actual parties and authorisation remain unresolved. The paper result is HOLD_UNKNOWN. A useful question asks who receives notice, which proposed change it covers, how the relevant owner can evaluate it and what happens while the question is unresolved. Do not claim a legal right was exercised or a subprocessor was rejected. A notification button alone does not supply the missing party, authority, timing or evidence.

Assistance and audit are evidence topics, not magical access to every supplier file. Our filled row asks what information, cooperation and review route would support the firm's applicable duties. The real recipient, commercial scope, confidentiality of audit material and access limitations remain unknown. Distinguish a promise to assist from an observed response to a request. Also distinguish an audit summary from a control that meets the particular use. The matrix should describe what the future reviewer would need, without claiming that this educational request establishes a contractual entitlement.

An average prompt says, 'Write terms that make this AI supplier compliant.' It invites unsupported drafting and a false success claim. The stronger paper prompt asks a clause-evidence editor to compare supplied C02, C03 and C05 at policy one and policy two. It prohibits legal drafting, actual client data and new provider facts. The process identifies the changed dependency before suggesting evidence questions. The output schema separates authored schedule text, consequence, actual unknown, proposed owner and real-use HOLD. A well-organised answer remains a set of review questions.

Verify that the response does not silently broaden the instruction schedule. It must retain trainingUse NONE at policy one and CONTENT_IMPROVEMENT after the fixed POLICY2 event. It must not call a training label lawful authority, infer deleted backups or replace C05's unknown parties with invented names. Check that the old limited U01 and U02 plans become held under changed policy. If a response says only 'review the contract regularly', it has missed the supplied consequence. Verification requires the filled before-and-after rows, not just advice to fill them later.

The approved paper sequence reinforces that terms changes affect current authority. Starting from stopped version two, applying POLICY2 produces version three and clears renewal and current evidence. Fresh renewal permits rebuilding evidence while stopped; no resume is needed for that assessment. Resume is a separate rehearsal-mode event and itself increments version, clearing renewal and results. These predictions are not observed software behaviour in this batch. In later exercises, label exact version and mode before a challenge so that a generic hold is not mistaken for proof of the intended causal gate.

Retain evidence that a change was noticed, its source and the consequence for each use. A fictional docket entry might read: POLICY2 supplied; C02 changed; U01 through U06 held under the schedule; proposed contracting and privacy functions to clarify current purpose and authority; actual supplier involvement absent. This is more actionable than saying the vendor is now unsafe. It does not prejudge every possible future arrangement. A new investigation could reach a different bounded decision, but it would need actual facts and appropriate review rather than reusing an old positive card.

Government lock-in guidance offers an adaptable method for considering usable formats and exit dependencies. Its government-specific duties do not automatically bind a private law firm. We use the distinction as a reminder to ask whether promised export can support continuity, not to claim a universal procurement rule. A record delivered as a dictionary may still require interpretation, configuration and an actual receiving process. Terms, format, ownership and practical switching capacity are separate evidence questions. The later exit chapter develops that reconciliation without treating portability as deletion or sovereignty proof. [Source: gds-portability-exit.]

A strong terms worksheet ends with an explicit decision boundary. In this exercise, five initially documented limits can coexist with unknown access, unknown subprocessors and an unsupported badge. Changed secondary-purpose wording can remove the two limited-plan possibilities while leaving a complete educational gap pack achievable. Actual contracting, confidentiality, privilege, privacy basis, security and professional use remain unresolved. Your work is complete when a reader can identify the text relied upon, its version, its consequence and the next evidence question without assuming that the worksheet itself is a contract or a professional approval.

1. Identify use, service entity and schedule version questions.
2. Separate instructions, secondary purpose and end terms.
3. Fill supplied support and actual unknowns for each topic.
4. Trace POLICY2 through C02 and dependent uses.
5. Distinguish record expiry, authority expiry and deletion.
6. Verify the comparison without drafting or approving a legal contract.

Scroll sideways to see every column.

ROLE: Fictional clause-evidence comparison editor.
CONSTRAINTS: Approved C01..C08 and POLICY2 only; no contract drafting, client data, real supplier facts or compliance certification.
PROCESS: Fill clause topic/supplied support/unknown; compare C02 at policy1 and policy2; trace U01/U02/U04 consequences.
VERIFICATION: NONE becomes CONTENT_IMPROVEMENT; C02 held changed; U01/U02 held; U04 always held; no backup-erasure inference.
OUTPUT SCHEMA: topic;sourceRevision;suppliedAssertion;boundedEffect;dependentUse;actualUnknown;proposedOwner;realUse=HOLD.
FAILURE MODES: Reject new-purpose-by-ownership, changed-terms-as-authority, expired-body export and invented actual contract. Paper comparison only.

Diagram text equivalent: Policy-one NONE supports a documented C02 limit. POLICY2 changes the authored training label to CONTENT_IMPROVEMENT. C02 becomes held-changed and U01/U02 become held; U04 remains held throughout. Fresh evidence questions do not grant rights. Assessment can be rebuilt while stopped, but actual use remains HOLD.

Processing only on the documented instructions of the controller.

Illustration text equivalent: Eight fictional policy-revision-1 control rows: C01 instruction, C02 training, C03 retention, C07 export and C08 assumed supervision are DOCUMENTED_LIMIT. C04 administrator access and C05 subprocessor change are HOLD_UNKNOWN. C06 security badge is HOLD_UNSUPPORTED. U01 and U02 are LIMITED_PILOT_PLAN, while U03 through U06 are HOLD_USE. Every real use remains HOLD.

Learn in your browser · Chapter 04 of 08

Separate information surfaces, actors and underlying responsibilities. A filled investigation map is useful while all actual access, supplier and professional decisions remain unknown.

A supply-chain review asks who can do what at each boundary. Start with the receiving activity and information, then identify proposed access paths and the layer supplying a claimed control. Paperbridge's invented cards do not identify an actual infrastructure provider, support organisation or administrator. C04 records that a privileged administrator may view task logs, but provides no actual access test or location. C05 leaves parties and authorisation unresolved. The correct starting point is therefore a map of evidence questions, not a drawing pretending to show a verified provider architecture.

Content and derived metadata need distinct rows. A document body can carry confidential affairs; a title, task identifier or usage record can also matter even when the body is excluded. Do not declare metadata harmless merely because it is shorter. In this finite scenario, R04, R05 and R06 are bodyless descriptors. Their labels let adults reason about ownership and exclusion; they are not actual anonymised records or proof of privacy. The proposed map should state which information would be needed for the question and avoid manufacturing missing detail.

NCSC cloud principle eight supports understanding how customer data and derived metadata may be shared or accessed through third-party supply chains. It also asks which party supplies security functions across underlying layers. These are technical guidance questions, not statutory permissions or an SRA approval. We adapt them to the invented supplier map while leaving actual parties unknown. Linked guidance and provider infrastructure have not been audited. A complete map of questions can direct an investigation, but it cannot establish that the answers or controls exist. [Source: ncsc-supply-chain.]

Tenant administration is different from ordinary task use. A proposed tenant administrator might configure users or features without being authorised to inspect every matter. Provider support is another route, potentially involving a different organisation or location. Underlying infrastructure may provide a separation control that the application relies on. These are possible layers to investigate, not asserted Paperbridge behaviours. Name the proposed function, information surface and evidence request separately. A label such as private workspace should prompt a question about how the boundary is enforced rather than answer it.

The responsibility map should include the firm side as well as the supplier side. Greybeam's proposed security function asks for technical evidence; the contracting function establishes commitments and the actual entity; the privacy function assesses applicable data roles and purposes; the professional-risk function decides the legal-service boundary. No single function can make the others' factual questions disappear. A supplier response should be routed to the appropriate challenge, not pasted into an approved column merely because it arrived from a sales representative or appears on a branded page.

C06's badge is useful precisely because its deficiency is specific. No issuer, scope, expiry or relevant control evidence is supplied. A review should therefore ask for the claimed scheme, assessed service, included functions, time period and limitations before deciding what it contributes. A relevant assurance record could inform one question without approving every use. Our paper result remains HOLD_UNSUPPORTED. This is not a claim that all badges are worthless or a real supplier is insecure; it is an accurate consequence of the evidence supplied to this exercise.

ICO security guidance, where UK GDPR applies, links appropriate measures to risk and circumstances and includes testing and review. It retains a DUAA review notice. We do not select actual measures or claim a security audit here. A proposed access map should consequently say what evidence would be needed for the intended information and consequence, rather than treating encryption or a certificate label as a complete answer. Actual testing, confidentiality, continuity and recovery conclusions require their own evidence and review. [Source: ico-risk-security.]

Define evidence requests narrowly enough to be answered. For task-log access, ask which roles can access which fields, under what circumstance, with what authorisation and review record. For support, ask which organisation and jurisdiction receives the minimum necessary material and whether access can be bounded and revoked. For infrastructure, ask which layer implements separation and what assurance covers that layer. These are proposed questions for an actual investigation, not steps for attacking a service. The workbook contains no accounts, operational access instructions or real network tests.

Location is one fact in the map, not a synonym for sovereignty. A hosting-country label does not reveal support access, secondary use, key control, backups, transfer arrangements or export capability. Sovereign control should be broken into specific source, processing, administration and exit questions that the firm can inspect. Greybeam has not commissioned or deployed a sovereign system. Mickai could be considered for a proposed engagement to organise owned records and controlled workflows, but this teaching scenario claims no live supplier capability, legal clearance, secure identity or completed migration.

Revocation must be described at the boundary it affects. Removing a person from a visible interface need not remove an existing export, support copy, backup or a separate service credential. The finite Tallygate contract only changes mutable local rehearsal state. Its old returned copies persist, and a fresh process resets overlays and counters. Those limits belong beside the proposed control, not hidden in a footnote. A genuine service review would require evidence across the actual paths and storage surfaces before claiming that revocation was durable.

A responsibility map should make unresolved dependencies observable. U05 requires C04 and C05, both unknown; U06 requires unsupported C06 and assumed C08. Filling an infrastructure row cannot make either use permitted. The map records why each proposed owner is needed and what would count as relevant evidence for that boundary. Distinguish completion of the map from satisfaction of its questions. This allows a reviewer to accept the quality of a teaching dossier while retaining every actual-use hold and rejecting unsupported expansion.

Compare 'Draw a secure architecture for this law firm' with the paper request supplied below. The stronger prompt asks a responsibility-map editor to use the approved fixed contract and use matrix, C02/C04/C05/C06/C07/C08, and all six record descriptors. It prohibits actual provider facts, legal approval and exploit instructions. The process separates firm, tenant, support and infrastructure functions and marks each missing fact. Verification checks that bodyless records stay bodyless and assumed roles remain assumed. The response schema links each proposed surface to evidence, owner, unknown and disposition so another adult can challenge it.

A misleading map might draw a shield around the entire provider and label everything compliant. Another might put support outside the drawing because it is not visible in the ordinary interface. Both suppress questions rather than resolve them. Repair the first by removing the unsupported certification and attaching specific evidence requests. Repair the second by adding a proposed support boundary with actual facts UNKNOWN. The corrective task is to restore distinctions, not create more decorative nodes. Colour and arrows should support the explanation; text must carry the same reasoning.

The state observer in the approved contract can inspect aggregate presence and counters, not record bodies, identifiers or provider secrets. That is an educational interface promise, not a professionally authenticated access-control system. Other source/control methods should reject the observer before fixture I/O under the proposed rules. No implementation has been run here to show this. When later runtime evidence is supplied, look for the actual method, actor, current authority and read delta, rather than accepting a generic HOLD as evidence of a particular access boundary.

Record contradictions without constructing a verdict from them. C01's narrow schedule conflicts with C06's unrestricted-use assertion. C04's incomplete access description and C05's missing parties create unanswered dependencies. The map can show all three while maintaining proposed owner routes. The adult reviewer should ask whether a new supplier fact changes a specific row and whether dependent uses need reassessment. A positive fact in one layer does not automatically travel to another. Keeping the rows separate makes that question practical and prevents architecture language from disguising a change in purpose.

The chapter succeeds when a second reader can distinguish the ten proposed surfaces, identify their evidence owners and state what is unknown. The filled exercise is a starting investigation map, not a service design, security test or professional sign-off. Actual client rights, confidentiality, privilege, data roles, transfers, identity, deletion and deployment remain unassessed. Continue to the later pilot chapter with those holds intact. A bounded synthetic plan can still teach useful governance reasoning while declining to pretend that a complete diagram authorises legal practice or a real supplier relationship.

1. Identify each proposed information surface separately.
2. Distinguish task use, tenant administration, support and infrastructure.
3. Fill minimum-content questions and proposed evidence owners.
4. Retain C04/C05 unknowns and C06 unsupported assertion.
5. Specify revocation/copy/continuity questions beyond the UI.
6. Verify the map without claiming actual architecture or security tests.

Scroll sideways to see every column.

ROLE: Greybeam fictional supply-chain responsibility-map editor.
CONSTRAINTS: Approved fixed contract and use matrix, relevant C02/C04/C05/C06/C07/C08 cards, and six record descriptors only; no real provider identities, client bodies, legal/security approval, exploit steps or operational accounts.
PROCESS: Separate ten surfaces and firm/tenant/support/infrastructure functions; fill minimum-content question, owner and evidence needed.
VERIFICATION: C04/C05 unknown; C06 unsupported; R04/R05/R06 bodyless; role tokens assumed; old copies survive local changes.
OUTPUT SCHEMA: surface;proposedInformation;proposedFunction;evidenceQuestion;actualUnknown;dependency;disposition=HOLD.
FAILURE MODES: Reject metadata-as-harmless, location-as-sovereignty, UI-removal-as-erasure, badge-as-approval and diagram-as-test. Paper map only.

Diagram text equivalent: Information surfaces connect to firm and tenant questions, then to support and underlying-stack questions. The resulting evidence-owner map retains all actual decisions as HOLD. This is a proposed question structure, not a verified architecture or a test of separation.

which party is responsible for implementing which security functions.

Learn in your browser · Chapter 05 of 08

Prepare an inspectable synthetic-only proposal, its non-AI comparison and stopping rules. No pilot, model response or actual professional supervision is observed.

A pilot proposal should make the activity small enough to inspect and the decision small enough to refuse. Greybeam is not commissioning legal drafting in this chapter. It is designing a future comparison of two blank administration structures, U01 and U02, against an existing non-AI template. No provider, model, client or working professional participates. The useful deliverable is a plan identifying the supplied information, intended output, exclusions and evidence needed before any real investigation. Calling this a pilot does not mean a trial has occurred.

Separate the benefit hypothesis from the entry conditions. The hypothesis is that fixed headings might help adults notice missing purpose, owner and held-decision fields. The entry conditions are synthetic-only inputs, the current permitted-use schedule and an actual future supervisory arrangement still to be established. A favourable hypothetical response cannot repair missing permission. Write both columns before considering a supplier so that the proposed benefit cannot silently expand the input boundary. The plan should remain understandable to someone who never saw the product demonstration or the assistant's first draft.

R01 contains an administration heading structure; R02 contains a checklist. Neither supplies a worked legal answer or an actual firm's record. The two proposed outputs are a blank shell preserving the R01 headings and a checklist preserving the R02 review tasks. Comparison can therefore examine whether those supplied functions remain visible, whether unknown facts are retained and whether prohibited suggestions appear. It cannot examine legal accuracy on real matters, professional efficiency or client outcomes. Those would need different authority, evidence and appropriately designed investigations that are not supplied here.

Use the non-AI alternative as an active continuity route. An adult can copy the fixed heading set into a local blank document and perform the checklist without an assistant. The proposed comparison includes that route using the same fictional tasks and criteria. It is not automatically worse because it is simple. A plan that would leave staff unable to perform the administrative task when AI is held creates unnecessary dependence. Keep the fallback's format, responsible function and correction route visible rather than treating it as an afterthought at the end of the supplier presentation.

Tallygate evaluates the dependencies of proposed uses, not their performance. U01 and U02 depend on C01, C02, C07 and C08. Initial paper evidence gives those cards DOCUMENTED_LIMIT, so these uses have LIMITED_PILOT_PLAN. That label means the restricted plan is represented in the schedule. It supplies no model response, test result, actual supervision or permission to upload something else. R01 and R02 remain the only proposed inputs for these plans. A change to any dependency must be reconsidered even if the blank output structure looks identical.

Keep all six uses in the worksheet. U03's client-letter descriptor is bodyless and excluded; U04 unrestricted training is outside the purpose schedule; U05 lacks actual support and subprocessor evidence; U06 relies on an unsupported badge and assumed reviewer. They remain HOLD_USE. A pilot plan displaying only U01 and U02 could mislead the reader into thinking the whole service was accepted. The held rows explain precisely where the limited plan ends. Review the dependency and exclusion together rather than treating a status as an independent assurance score.

The ordinary prompt asks an assistant to prove that the provider is ready for a law-firm pilot. It predetermines a favourable conclusion and omits how to challenge it. The stronger prompt assigns a pilot-plan editor, supplies the six uses and all eight cards, forbids real content and requests entry conditions, comparison tasks, observation criteria, stopping rules and unresolved owners. Verification is source fidelity: no invented run, no widened input, no hidden held use. This is a reusable specification for an adult drafting activity, not evidence that a model complied with it.

Define success criteria as inspectable observations a future authorised investigation would record. Our paper criteria are preservation of every required heading, recognition of missing owner or purpose fields, accurate references to the supplied cards, and absence of invented legal advice. A response that adds realistic client detail fails the boundary even if it appears useful. A response that reports missing information without supplying a substitute may be the stronger output. Record the reason, task version and reviewer question rather than collapsing several criteria into a vague confidence rating.

Predetermine stop and correction conditions. Stop the proposal if the input changes to real matter content, supplier terms change, an owner cannot explain the review boundary, or the comparison route cannot retain uncertainty. The proposal must state who would consider these events and how the non-AI task continues. Those functions have not actually been appointed. Tallygate's stop_use changes a local educational state; it does not block a provider connection. A complete planning row therefore distinguishes the paper event from the actual organisational action that would still need authority and evidence.

Meaningful supervision includes the ability to reject the proposed use, obtain missing evidence and require a corrected plan. An assumed token cannot demonstrate that capacity. C08 owns synthetic completeness only, so it cannot resolve privilege, client confidentiality, security or professional judgement. In the England and Wales SRA context, firm governance and supervision provisions retain the firm's responsibilities. Our checklist helps organise questions under that context, but completing it cannot establish compliance. Actual appointed people, scope and current arrangements remain unresolved. [Source: sra-firm-controls.]

A useful paper challenge changes one condition at a time. For example, keep the R01 headings unchanged but replace the claim that the result is a blank internal shell with firm-wide legal release. The supplied schedule now points to U06 and its held dependencies, not to U01. The content may look similar while the purpose has materially changed. This teaches why an activity cannot inherit permission merely from a familiar input. A second challenge replaces policy one with POLICY2; the training-use dependency then removes support for both restricted plans.

Record planned measurements honestly. The worksheet can include columns for a future attempt identifier, reviewer comment, missing-field count and boundary failure. Leave measured values uncollected. Do not fill the comparison with fabricated percentages, invented adult reactions or a claimed time saving. The approved contract predicts two limited plans and four held uses initially, but these are classification expectations, not effectiveness measurements. A stronger proposal tells a decision maker exactly what evidence is absent and how a later authorised investigation could address it without importing real client examples.

The SRA's current AI warning addresses use-specific safeguards and continuing responsibility rather than making a paid account an approval credential. Keep its regulated-person scope distinct from a general product recommendation. An internal deployment label also leaves important questions unanswered. We use the warning to challenge a claim that a subscription makes this pilot ready; no real subscription, vendor terms or linked court decision is investigated here. Scotland, Northern Ireland and other professional regimes need their own applicable assessment before this method is transferred. [Source: sra-ai-safeguards.]

The finite paper inventory has an exact accounting convention. After renewal, eight supplier checks, six use assessments and F01 produce fifteen evaluations and fifteen completed fixture reads, with zero owned-body projection occurrences. That zero does not mean the synthetic body strings were never physically parsed; each full fixture read includes them. No model inference or use execution is counted. Counting each category separately stops a teaching report from turning source-read activity into a privacy assurance, a performance result or a claim that fifteen operational tests succeeded.

A knowledge question can check whether a learner distinguishes LIMITED_PILOT_PLAN from actual use, or notices the dependency that changed. It cannot verify that the learner can supervise a real supplier or make a professional decision. Future written exercises and this pilot-plan practice are ungraded educational work unless a later assessment explicitly says otherwise. Keep a practical observation separate from a multiple-choice result. A named educational certificate, if a checked assessment flow later exists, would not authenticate the named person or confer a practising qualification, authority or professional accreditation.

The completed proposal ends with two bounded rows and four held rows, a non-AI template route, explicit entry and stopping conditions, proposed evidence owners and no observed comparison values. Its purpose is to make the next question answerable, not to secure a favourable procurement verdict. Ask another adult to identify what would cause U01 to be held and where the administrative task would continue. If the answer requires trusting the provider's badge or inventing a supervisor, improve the plan before seeking any actual investigation. Real-use status remains HOLD throughout.

1. State the small benefit hypothesis and supplied input.
2. List every use and exact dependency.
3. Supply the same-task non-AI route.
4. Define observation fields and fail/hold criteria before any future investigation.
5. Assign proposed evidence questions and stopping functions.
6. Verify scope and retain uncollected measurements and actual-use HOLD.

Scroll sideways to see every column.

ROLE: Greybeam synthetic-only pilot-plan editor for adult decision discussion.
CONSTRAINTS: Use supplied C01..C08, U01..U06 and R01/R02 administration structures only; never supply R04/R05/R06 bodies, legal advice, provider facts, measured results or actual-use permission.
PROCESS: List all six uses; specify U01/U02 benefit hypothesis, entry criteria, same-task non-AI comparison, observation fields, stopping conditions and proposed owners.
VERIFICATION: Check exact dependencies; initially two LIMITED_PILOT_PLAN/four HOLD_USE; any real input or new purpose remains excluded; actual observations uncollected; no model run.
OUTPUT SCHEMA: useId;input;dependencies;paperDisposition;comparisonTask;plannedObservation;stopCondition;proposedOwner;actualUnknown;realUseStatus=HOLD.
FAILURE MODES: Reject pilot-as-observed, badge-as-permission, omitted held uses, fabricated scores/time savings, widened inputs and token-as-professional-competence.

Diagram text equivalent: Synthetic tasks and exclusions lead to all dependency questions. Those lead to a proposed comparison with a non-AI fallback. No comparison evidence has been collected. The resulting planning document retains real-use HOLD and proposed evidence owners; it is not an actual pilot result.

Learn in your browser · Chapter 06 of 08

Use an absent-body unsafe-workflow tabletop to identify containment questions. Trace policy change and fresh evidence without inventing a breach or notification decision.

A confidentiality failure exercise is useful when it exposes decisions before information is sent. F01 is a proposed unredacted client-letter workflow into an unreviewed public tool. R05 is only a bodyless descriptor; no letter, upload or breach has occurred. Adults can discuss containment questions without inventing a client story or reconstructing confidential text. The worksheet should explicitly distinguish the unsafe proposal from an observed incident. That distinction determines which facts are known, which must be investigated and which reporting or professional decisions cannot yet be made.

Begin with the proposed boundary: prohibit admission of the absent letter and identify an appropriately authorised person who would stop the actual proposal. Tallygate's local stop_use is a rehearsal control, not proof of a successful network block. It increments the permission version and clears current authority, results, review and packet. An exported copy already held by a caller is unaffected. The filled worksheet must preserve both facts so that a stopping action is not mistaken for retrospective erasure or evidence that every downstream recipient has been reached.

Map affected surfaces before choosing remedies. For F01 our proposed list includes prompt and upload interfaces, generated outputs, support views, task logs, improvement systems, backups and exported copies. Actual presence, recipients, locations and contents are UNKNOWN because no real service or upload is supplied. The rows are questions, not an invented incident map. A useful row names the evidence needed and proposed accountable function. Do not write that the provider deleted a log or that an output was clean merely because the proposed local packet contains no client body.

Separate professional confidentiality from privilege, data-protection applicability, source rights and notification obligations. These questions may interact, but they require different facts and competent decisions. The SRA confidentiality guide supports careful recipient and purpose investigation in its England and Wales regulated context. It does not choose an actual privacy basis or settle privilege. In F01 the proposed compliance, privacy, contracting and security functions have not reviewed a client or provider. Avoid writing an automatic waiver or a universal reporting deadline into a teaching answer. [Source: sra-outsourcing-confidentiality.]

A changed policy is a different event from the F01 unsafe proposal. POLICY2 changes the authored trainingUse value from NONE to CONTENT_IMPROVEMENT and policyRevision from one to two. It does not authorise an unrestricted training use, create client permission or resolve contract applicability. C02 becomes HOLD_CHANGED_POLICY, and U01 and U02 lose their initial restricted-plan support. U04 remains held. Keeping both events separate prevents an incident worksheet from treating changed supplier wording as a cure for an unsafe information flow or as retrospective authority for a past activity.

Use a precise paper sequence. Start from a complete stopped version-two pack, apply POLICY2 with the exact assumed owner, and the version becomes three. Old export_pack(2) fails before source I/O and invalidates current renewal and cache. Renew version three, rebuild eight controls, six uses, F01 and the complete exit, then review and export while still stopped. No resume is required for these governance assessments. This paper journey adds eighteen reads, sixteen evaluations and three projection occurrences to the first pack, absent any other calls.

Do not conflate renewed assessment authority with service activation. Renewal permits current evidence questions within the finite expiry boundary. resume_use requires stopped mode and fresh authority, then changes to active rehearsal, increments version and clears that authority and all current results again. A person who resumes and immediately uses the previous packet has missed this invalidation. Stopped evidence assessment is intentionally possible because decision makers need to inspect changed terms while the proposed service remains held. Actual organisational suspension and reinstatement would require separate arrangements that this mutable educational session does not implement.

The ordinary incident prompt says, 'Write a reassuring notice saying no client data escaped.' It demands a conclusion the scenario cannot support. Our stronger prompt appoints a tabletop recorder and states that only descriptors and the fixed F01 proposal exist. It asks for known facts, missing evidence, surfaces, proposed owners, immediate boundary and unresolved professional questions. Verification rejects invented uploads, impacts, provider actions or completed notifications. The output should be calm and readable without falsely reassuring affected people or assigning blame to a fictional staff member.

A proportionate evidence worksheet retains enough context to investigate the proposal without collecting a real letter for convenience. Its fields include scenario identifier, current schedule, described intended destination, absent input, decision version and evidence question. A later actual incident might need different records, preservation arrangements and access limits under applicable advice. That work has not occurred here. The ICO minimisation principle is conditional on actual personal-data processing and specified purposes; synthetic exercises do not prove compliance or establish a lawful basis. Its current DUAA review notice remains relevant. [Source: ico-purpose-minimum.]

Containment and continuity belong together. Greybeam's proposed fallback is a blank local administration template and a separately controlled review checklist, with no client input admitted by this exercise. If the owner questions cannot be answered, the AI proposal stays stopped and the task can remain in that modest route. Do not copy questionable material into another unreviewed tool while attempting to contain it. The teaching answer identifies the original boundary and alternative process, rather than offering operational procedures for a live firm, provider or client matter.

After a valid same-version recheck, the individual result is replaced and other current checks remain, but aggregate review and packet are cleared. New evidence requires a new review even when its content looks unchanged. If export is attempted prematurely, that handled failure clears the full current cache and renewal, requiring reconstruction. Contrast this with an unexpected keyword argument: Python raises TypeError before entering the method, so the entire prior state remains unchanged. State traces should distinguish these causes rather than labelling every failed invocation a cache-clearing rejection.

Preserve facts needed to understand old copies. A version-two export continues to contain its earlier policy and records after a later change. The current session must not treat it as current authority, but it cannot remove the dictionary someone already received. Real copies might exist in backups, support systems or other organisations. The ICO processor-contract guidance discusses conditional return or deletion arrangements and qualified backup safeguards, not immediate universal erasure. Actual parties, instructions, legal storage exceptions and verification remain unassessed in this course. [Source: ico-processor-terms.]

The ICO security guide considers context, risks, appropriate measures and testing or recovery where UK GDPR applies. It supports asking how an actual organisation would know a control worked. F01 supplies no access test, incident response test or security audit. Our worksheet therefore records a proposed security function and exact missing evidence rather than an assurance conclusion. The DUAA review notice, conditional personal-data scope and need for actual specialist review must stay visible when transferring this exercise into a real institution. [Source: ico-risk-security.]

Do not let an owner label hide conflicting evidence. The contracting function could report a secondary-use clause, while the privacy function still cannot determine applicable basis and the professional function still excludes the client-letter purpose. The worksheet must retain each answer with scope and version. A packet can be complete because it contains these contradictions. It is not complete if it changes UNKNOWN into approved to make the document easier to read. The purpose of review is to surface the decisions that remain open, including who can require another answer.

A useful teach-back asks a second adult to reconstruct the changed-policy sequence and explain why old authority fails. They should identify the current version, stopped mode, renewal, complete checks and fresh review without claiming any event was executed. Then ask them to name one fact needed before deciding actual impact or reporting duties. If they answer with the absence of a fixture body as proof that no real incident could exist, return to the distinction between the authored tabletop and facts an organisation would need in the real world.

The filled failure plan is deliberately unresolved in the right places. It records the unsafe proposed input, forbids its admission, assigns evidence questions to proposed functions, identifies eight downstream surfaces, separates policy change from incident facts and retains the non-AI route. It states that prior copies persist and reporting applicability is unknown. This is more useful than an invented successful containment report because it gives the next authorised adult something specific to investigate. No actual privilege, privacy, professional, provider, notification or recovery approval follows from completing it.

1. Separate proposed F01 from an actual incident.
2. Keep R05 absent and specify the boundary to stop.
3. Fill every affected surface and proposed evidence owner.
4. Record POLICY2 as a separate versioned event.
5. Renew current assessment authority and rebuild while stopped.
6. Retain unknown impact/duties, prior copies and the non-AI route.

Scroll sideways to see every column.

ROLE: Fictional F01 tabletop recorder and policy-change trace editor.
CONSTRAINTS: R05 body is absent; no client, upload, incident, impact, notification, provider action or legal deadline may be invented. All actual-use flags remain false.
PROCESS: Separate unsafe proposal from POLICY2; fill eight affected-surface questions and proposed owners; trace stopped version2 to POLICY2/version3, old export denial, renewal3, full rechecks and fresh review/export.
VERIFICATION: Keep stopped assessment separate from resume; C02 HOLD_CHANGED_POLICY and all uses held after POLICY2; old copies survive; actual privilege/basis/reporting unresolved.
OUTPUT SCHEMA: scenario;knownFact;surface;actualUnknown;evidenceQuestion;proposedOwner;immediateBoundary;versionTrace;nonAIRoute;realUseStatus=HOLD.
FAILURE MODES: Reject invented breach/containment, automatic privilege outcome, universal notification deadline, renewed-training-rights, UI-erasure, stale review and generic failed-call cache claims.

Diagram text equivalent: The F01 absent-body proposal leads to stopping and evidence questions. A separate POLICY2 event requires fresh current renewal and all fresh checks before review. The resulting gap pack stays stopped and retains actual impact, reporting and provider facts as unknown. There is no observed breach or successful remote containment.

Illustration text equivalent: At fictional day 2 in stopped mode with current authority, X01 can return R01 blank shell, R02 checklist and R03 evidence ledger under FICTIONAL_OWNED_EXPORT. R04 provider log, R05 excluded client letter and R06 other-firm record have no supplied body. X03, X04 and X05 fail before loader I/O without a partial return. Initially X02 omits eligible R03 and is incomplete. After R03 withdrawal, X01 is held and X02 becomes complete. All owned records expire after day 3; day 4 has none. Whole-file parsing includes synthetic bodies, old copies survive changes and real use remains HOLD.

Learn in your browser · Chapter 07 of 08

Reconcile exact eligible ownership and complete selection before an educational copy. Retain receiving, retirement and continuity questions; no actual migration or deletion is proved.

An exit plan asks whether the organisation can continue its legitimate task with the records it is entitled to use. It is broader than a download button and narrower than a claim of sovereignty. Tallygate provides three fictional owned records and three excluded descriptors to teach exact reconciliation. An exported JSON structure can demonstrate only a scenario copy with specified fields. It does not prove actual ownership, a receiving system's ability to use the records, supplier migration, transfer permission or deletion of copies. Those questions need separate actual evidence and accountable decisions.

Read the owned bodies rather than relying on their titles. R01 contains receiving-purpose, proposed-owner and held-decision headings; R02 supplies a compare-and-record checklist; R03 supplies evidence-ledger columns. Each has the fictional firm owner, FICTIONAL_OWNED_EXPORT rights and expiryDay three. All six descriptors remain visible in the planning table so the exclusion reasons can be checked. R04 is provider owned, R05 ownership and rights are unresolved, and R06 belongs to another invented firm. Their bodies are absent; the exercise cannot manufacture them to make an exit appear complete.

Completeness is measured against the currently eligible owned set, not against every possible identifier and not against the caller's preferred subset. Initially that set is R01, R02 and R03. X01 selects all three and is complete. X02 selects R01 and R02 only and is admissible but incomplete. It returns gap metadata with missing R03, not bodies, and cannot support a review. This makes an omission inspectable without exporting a partial collection that a reader might mistake for the whole continuity pack or silently substitute for the missing record.

Keep invalid membership separate from incomplete admissible selection. X03 adds the provider descriptor R04, X04 includes the excluded R05 and X05 includes the other-firm R06. They are handled denials before fixture I/O. No rejected selection metadata or body is returned. X02 is different: its known eligible members can be checked, the full fixture is read, a valid gap evaluation occurs and zero bodies are projected. The distinction explains why all HOLD-looking results cannot be used as evidence of the same cause or the same read boundary.

A withdrawal changes the current eligible set without changing the original fixture. WITHDRAW_R03 requires stopped mode and the exact assumed owner; it increments the version and clears renewal and current evidence. R03 is then excluded by the local overlay. X02 becomes complete with R01 and R02, while X01 is invalid because it contains the withdrawn R03. Do not repair X01 by inserting another record or by falling back to a previously exported copy. A current continuity proposal should show the changed scope and the missing function that the withdrawn ledger previously supplied.

Test membership causality in the paper trace only after other gates are satisfied. Starting from a complete stopped version-two pack, apply withdrawal to reach version three, renew three and challenge X01 with the exact current assumed custodian. Its pre-I/O denial now concerns withdrawn membership. That denial clears authority and cache, so renew three again before rebuilding the eight controls, six uses, F01 and X02, then review and export. A challenge made without renewal would show an earlier authority failure and would not demonstrate the membership rule.

Owned expiry and evidence authority have different deadlines. Day three remains eligible because expiry is inclusive. On day four authority can be renewed and control or use assessment can proceed, but no owned record remains eligible; no complete nonempty exit, review or export exists. A day-four exit is denied before I/O. On day five renewal and source authority fail before I/O. These are authored logical days, not statutory retention periods. Neither renewal nor an assumed token extends them, and advancing the day cannot be reversed within the same session.

The ordinary exit prompt asks, 'Download everything so we can switch supplier safely.' It conceals ownership, purpose, completeness, destination and currentness. A stronger prompt appoints an owned-manifest reconciler, supplies all six descriptors, five selections and the approved fixed contract's lifecycle, renewal, authority and count rules, and fixes day, version, policy and withdrawal state. It asks for the eligible set, each selection disposition, exact admitted bodies and exclusion reasons. Verification refuses absent bodies and stale membership. The final output is a paper manifest and question list, not an executed migration or a certificate of sovereign control.

Make format checks concrete without overstating their reach. The supplied record schema contains id, owner, kind, rights, expiryDay and body. A proposed receiving custodian would check that these fields and their meaning survive, that each admitted identifier appears once, and that ordinary text remains readable. The body itself is the original authored sentence, not a rewritten summary. These checks help locate loss or omission in the educational copy. They do not demonstrate an actual receiving application's import semantics, restore behaviour, access limits, retention policy or service continuity.

The government lock-in guidance distinguishes technical and commercial dependencies and encourages usable exit planning within its government context. We adapt its questions about formats, alternatives and reviewing dependencies into a private-firm teaching method. Its government-specific requirements do not automatically bind every law firm. Our completed continuity row retains the unknown actual custodian, destination, rights and import evidence. A three-record pack might be easy to read while still failing the real organisation's needs. That judgement has not been made here. [Source: gds-portability-exit.]

A non-AI continuity route should preserve the administrative task rather than imitate an unavailable service. The proposed records owner can retain blank receiving-purpose headings and a checklist in a local, appropriately controlled process if actual arrangements are later authorised. After withdrawal, the proposed ledger function needs separate reconstruction from allowed information or a changed task, not resurrection of the excluded R03 body through an old copy. This exercise does not prescribe an organisation's records management system or physical storage location. It supplies the questions needed to choose one responsibly.

Separate exporting a copy from retiring information at the source. The local method returns a deep-copied dictionary and performs no actual transfer or write. A caller can retain it after a change. Deletion questions would need an actual service entity, contractual scope, applicable storage obligations, backups, support copies, logs and evidence of completion. ICO controller-processor end provisions apply conditionally and retain qualified backup considerations. Do not change the word exported into deleted, or infer every record is free to migrate because the scenario labels it owned. [Source: ico-processor-terms.]

Read the counters as a ledger of occurrences. A complete three-record exit adds three projectedOwnedRecordOccurrences; a later complete two-record exit adds two. This counts returned-body occurrences, not unique records, physical reads or erased copies. Review and export reread the fixture but add no evaluation or projection. The initial incomplete X02 adds one read and one evaluation, with zero projections. Record these distinctions next to the matrix. Otherwise a repeated exit could be reported as newly discovered evidence or an export reread could be misreported as three further projections.

Returned-copy mutation and process reset test different limitations. A deep copy prevents ordinary changes to a returned object from changing stored checked data through that object. It does not secure internal Python attributes or local files. A fresh process resets day, policy, withdrawal, versions and counters to initial values. Therefore a current session's revoked membership is not a durable revocation service. Keep prior copies and fresh-state behaviour in the continuity questions. This course proposes no authentication infrastructure, persistent incident ledger or evidence that a real supplier honoured a withdrawal.

A complete educational exit can coexist with supplier gaps. C04 and C05 remain unknown, C06 unsupported, and four uses remain held initially. The exact owned copy merely supports an internal gap pack after all current checks are represented and a scoped review occurs while stopped. If a valid same-version check happens afterwards, a new review is needed. If an invalid export is attempted, reconstruct the full cache after fresh renewal. The manifest must show its context so a later reader cannot detach three useful sentences from the holds and present them as deployment approval.

Your final continuity explanation should let another adult account for every admitted and excluded record at a stated day and version. They should identify why X02 changes after withdrawal, why day four cannot yield a complete exit, and why a prior dictionary survives. Supply exact bodies and unresolved receiving questions rather than a generic instruction to check them later. A usable paper answer is a rehearsal of traceability, not proof of migration, privacy, legal rights or sovereignty. Actual professional and operational use remains HOLD, regardless of how portable the example appears.

1. Read all six descriptors and the three exact supplied bodies.
2. State day/version/policy/withdrawal context.
3. Compare all five selections to the current eligible set.
4. Distinguish incomplete eligible selection from invalid membership.
5. Plan receiving-format checks and the non-AI continuity route.
6. Retain expiry, old-copy and fresh-process limitations.

Scroll sideways to see every column.

ROLE: Fictional owned-manifest reconciler, not migration or deletion certifier.
CONSTRAINTS: Six exact descriptors/five selections plus approved fixed contract lifecycle, renewal, authority and count rules only; initial day2/v2/policy1/stopped/no withdrawal; export labels fictional; R04/R05/R06 bodies absent; no real transfer or rights approval.
PROCESS: Identify eligible owned set; fill all selection dispositions and admitted/gap metadata; preserve exact bodies; give day3/day4/day5 and withdrawal branches, continuity questions and proposed custodian.
VERIFICATION: Compare selected set to current eligible set, inclusive expiry and overlay; satisfy current renewal/stopped/assumed-role gates before causal membership challenge; distinguish physical reads/evaluations/projection occurrences.
OUTPUT SCHEMA: context;descriptor;owner;kind;rights;expiryDay;bodyOrAbsent;selection;paperDisposition;eligibleSet;excludedReason;receivingQuestion;realUseStatus=HOLD.
FAILURE MODES: Reject partial-as-complete, title-as-ownership, absent-body invention, obsolete fallback, renewal-as-retention-extension, export-as-migration/deletion and local-reset-as-durable-revocation.

Diagram text equivalent: All six descriptors identify the three supplied owned bodies and the excluded bodyless records. Current day and withdrawal determine the eligible set. Five selections are compared to that set; only a complete nonempty admissible selection can produce a manifest. The manifest still leaves actual receiving, rights, migration and deletion facts unknown.

Scroll sideways to see every column.

Learn in your browser · Chapter 08 of 08

Build the actual supplied fictional dossier: controls, uses, failure worksheet, exact owned manifest and decision docket. Educational completeness retains every unresolved actual-use gate.

The firm-level capstone is a completed educational gap pack, not a request to design one later. It combines the eight control cards, six use plans, F01, all record descriptors, a complete owned exit and the proposed decision docket. Its value is that another adult can inspect the bounded evidence and every unresolved question together. The packet is explicitly fictional and real-use HOLD. A polished cover or complete table must not change that conclusion. No model, provider, lawyer, client, regulator or receiving system participates in this authored exercise.

Choose a precise baseline for the filled capstone: fresh process, day two, policy one, no withdrawal, and an initial stop that produces permission version two. Renew version two before evidence checks. Stopped mode is intentional because the pack is for an internal decision discussion while the proposed service remains inactive. It does not certify that a real connection was stopped. The actual body fields are the supplied administration sentences, and the excluded descriptors stay bodyless. Any variation must identify what changed rather than pretending it is still the baseline packet.

Represent all eight controls with their assertion, supplied support, paper result, proposed accountable function and unresolved actual fact. C01, C02, C03, C07 and C08 are DOCUMENTED_LIMIT; C04 and C05 are HOLD_UNKNOWN; C06 is HOLD_UNSUPPORTED. Those five limited cards describe authored boundaries, not five passed professional safeguards. The three held controls remain in the pack. A subset of favourable cards cannot support a review. This prevents completeness from being measured by the number of green statements instead of whether every relevant uncertainty is accessible.

The six-use matrix follows the dependencies rather than a vendor ranking. U01 and U02 are LIMITED_PILOT_PLAN initially, both based on C01, C02, C07 and C08. U03 is held because its excluded client-letter input has no admitted body. U04 is held because unrestricted training is outside the schedule. U05 retains unknown support and subprocessor arrangements. U06 retains the unsupported badge and lack of professional approval. The capstone shows the proposed input, intended output and non-AI alternative for each, with no performance measurements or actual-service endorsement.

Add the F01 worksheet in full. Its known fact is an unsafe proposed unredacted-letter workflow with an absent placeholder body, not a breach. Prompt, upload, output, support, logs, improvement, backups and copies each need an actual presence-and-recipient question. Proposed professional, contract, privacy, security and records functions retain their own questions and any disagreement. Impact, privilege, basis, source rights and reporting applicability remain unknown. The immediate teaching boundary is to keep the excluded input absent and retain the administrative fallback, not to claim successful containment or send a real notification.

The exact owned manifest contains R01, R02 and R03, each with fictional firm owner, FICTIONAL_OWNED_EXPORT rights and expiryDay three. The three supplied bodies remain verbatim. R04, R05 and R06 are recorded only as excluded descriptors with their reasons; no replacement body is invented. Initially X01 is the complete selection and X02 an incomplete eligible subset. The receiving-custodian question asks how an actual organisation would verify rights, destination, usable fields and continuity. Its answer remains unresolved despite the completeness of this educational manifest.

A future decision docket has six rows, not one approval box. The partner function owns the bounded benefit and stopping decision question; compliance owns applicable professional supervision questions; contracting owns actual terms and change evidence; privacy owns applicability, purposes and relevant conditions; security owns boundaries and recovery evidence; records owns continuity and retirement evidence. Every row records actual reviewer identity and credentials as unverified, current evidence request and real-use HOLD. Functions may overlap in an actual firm, but an overlap does not remove the questions or authenticate the person answering them.

The stronger capstone prompt is an evidence-pack editor with constrained inputs, a declared sequence, independent checks and an explicit schema. It asks for controls, uses, F01 surfaces, complete manifest, decision docket and unresolved gates. The average prompt says, 'Write a confident supplier assurance report and recommend launch.' Confidence is not the task. Verification should reject a omitted hold, fabricated provider fact, invented client body, unscoped source claim or a recommendation to release. This remains a paper drafting method; no assistant output is supplied or tested by the course.

Keep the source map inside the dossier. SRA firm governance, AI warning and confidentiality guidance provide bounded England and Wales regulated-context questions. ICO minimisation, contract and security guidance apply conditionally to actual personal-data arrangements and carry the current DUAA review notices. NCSC provides technical supply-chain questions. GDS exit guidance is adapted from a government context, and NIST's overview is voluntary rather than certification. Linked instruments and frameworks have not all been audited. These nine references do not collectively produce a legal, professional or privacy approval of the fictional pack.

The complete stopped-pack paper prediction is sixteen evaluations, eighteen fixture read attempts and completed reads, and three projected owned-body occurrences. Eight controls plus six uses plus F01 plus X01 make sixteen; review and export each add one read but no evaluation or projection. These categories must stay separate. No observed code results are claimed in this batch. Later actual implementation and independent review would require their own frozen hashes and evidence. A report cannot turn predicted arithmetic into executed tests simply because it agrees with a contract or a creator's expectation.

Supply a changed-policy branch as a second filled decision. From the complete stopped version-two baseline, POLICY2 advances to version three and invalidates current evidence. An old export request fails; fresh renewal and all sixteen analytic results are needed before new review and export. C02 is now HOLD_CHANGED_POLICY and all six uses are held. The original export remains in the caller's possession. Absent other calls, the contract predicts totals of thirty-six reads, sequence thirty-two and six projection occurrences. No actual training, erasure or service activation occurs in this branch.

Supply the withdrawal branch separately so its counters are not mixed with the policy branch. Start again from the baseline stopped pack, withdraw R03 to reach version three, renew three and challenge X01 under current authority. The membership denial is before I/O and clears the cache and renewal. Renew three again, rebuild controls, uses and F01, then complete X02 and fresh review and export. The paper totals become thirty-six reads, sequence thirty-two and five projection occurrences. The old R03 copy survives; no durable revocation, substitute record or other-firm export is asserted.

A same-version branch teaches why review must remain current. Rechecking C01 adds one read and advances evaluationSequence to seventeen, preserves the other valid current results and clears aggregate review. A new review can bind that complete cache. Attempting export before review instead causes full handled-failure invalidation and requires reconstruction after fresh authority. An unexpected keyword TypeError is different: it happens before the method body and leaves prior state intact. The capstone should name these causes, not merely count a HOLD result as evidence that each boundary worked for the same reason.

Add expiry and reset branches to the decision docket. Day three permits the owned exit; day four permits evidence assessment but no owned record remains eligible and a complete reviewed pack is unavailable. Day five rejects renewal and source authority. Advancing day increments version and clears current evidence. A fresh process resets to day two, version one, policy one, active rehearsal and zero counters, with initial R03 eligibility. This means process-local retirement is not durable. Neither a retained copy nor a reset supplies authority for a real firm to use excluded material.

Preparation for the course knowledge assessment means explaining why the dispositions and transitions follow from the supplied material. A twenty-question draw requires strictly above eighty percent: sixteen correct fails and seventeen passes. After its separately checked educational release, use the official Mickai exam link after the lessons for the knowledge assessment. The capstone and written work are ungraded. A conditional educational certificate would not prove identity, professional competence, accreditation or permission to operate a legal service. Do not use a multiple-choice score as evidence that any unresolved dossier gate was independently fulfilled.

Finish with a teach-back that another adult can challenge. Present the baseline pack, then ask them to choose policy change, withdrawal, a later evaluation or expiry and locate the affected rows, version and evidence requirements. They should find the non-AI route and each proposed decision owner without assuming that a token is an authenticated person. The finished capstone is a traceable set of supplied facts and explicit gaps. Further root, independent teaching, actual implementation and native release checks remain separate; real provider, client, legal, privacy and operational decisions remain held.

1. Fix baseline context before assembling the dossier.
2. Fill all eight controls and six use dependencies including holds.
3. Supply F01 surfaces and separate actual unknowns.
4. Reconcile exact nonempty owned exit and exclusions.
5. Bind proposed owners, source scope and current paper review.
6. Teach back separate change/withdrawal/recheck/expiry/reset branches without release claims.

Scroll sideways to see every column.

ROLE: Greybeam fictional firm-level assurance-gap-pack editor for adult teach-back.
CONSTRAINTS: Approved finite C01..C08/U01..U06/F01/R01..R06/X01..X05 only; baseline day2/v2/policy1/stopped/no withdrawal; no actual client/model/provider, legal advice, professional approval or measured runtime.
PROCESS: Assemble full control/source/unknown matrix, six-use dependencies, eight-surface F01 worksheet, exact complete owned manifest/exclusions and six-function decision docket; then separate policy, withdrawal, recheck and expiry branches.
VERIFICATION: All held evidence retained; sixteen analytic results plus fresh scoped review while stopped; exact bodies; predicted18reads/sequence16/projections3 baseline; current authority/version; old-copy/reset limits and source jurisdiction retained.
OUTPUT SCHEMA: context;controls;uses;F01;ownedManifest;excludedDescriptors;selectionMatrix;proposedDocket;unresolvedGates;paperTrace;sourceScope;educationalCompleteness;realUseStatus=HOLD.
FAILURE MODES: Reject green-card subsets, invented facts/bodies, omitted holds, stale reviews, purpose expansion, portable-as-sovereign, predicted-as-executed, knowledge-as-competence and certificate-as-authenticated-identity.

Diagram text equivalent: All eight controls and six uses, including held evidence, combine with F01 and a complete current owned exit. A current scoped review while stopped binds their context and sequence. The educational output is an internal assurance gap pack. Actual professional, provider, rights and operational decisions stay HOLD, with a proposed non-AI fallback; there is no deployment approval.

Scroll sideways to see every column.

Scroll sideways to see every column.

# Tallygate: a supplier-control and owned-record exit rehearsal

Author: Mickarle Sean Junior Wagstaff-Irons - Micky Irons. Original AI-assisted educational code and records. Intended for adult learners in a bounded England and Wales legal-administration course. No legal advice, case authority, real firm/client record, model, supplier service or actual professional decision is supplied.

Tallygate compares eight fictional supplier-control cards, six future-use plans and one proposed confidentiality-failure tabletop. It then reconciles an exact owned-record exit selection. GREYBEAM_SYNTHETIC_FIRM and PAPERBRIDGE_SYNTHETIC_PROVIDER are fictional labels. The assumed role strings and tokens below are readable teaching inputs. They authenticate no person or firm and grant no real rights.

The four portable files are exactly:

- README.md
- tallygate_records.json
- tallygate_lab.py
- test_tallygate_lab.py

Use Python 3.10 or later with its standard library. No package installation, network access, model download, API key, account, payment or provider is required. Keep all four files together. The lab does not accept caller paths, URLs, record bodies, legal conclusions or approval parameters. It has no network, command or subprocess calls. The test file separately runs one fixed fresh-child Python reset check. Tests create and clean disposable copies beneath `test-temp` beside the supplied files; use a writable local educational folder, never a real client-data location. In this project all files and scratch stay on M.

Run the supplied full stopped rehearsal and then the author test suite:

```text
python -B -X utf8 tallygate_lab.py
python -B -X utf8 test_tallygate_lab.py
```

The demonstration prints a JSON-compatible internal gap pack and aggregate state. It writes no export, transfers nothing and issues no certificate. The tests exercise copied files; they do not edit the original fixture. Do not change the supplied file, line endings or code-owned digests and expect the binding to accept it. Raw SHA-256, canonical JSON, exact schemas/types, unique JSON keys/IDs and fixed dependencies must agree. A fixture failure is held. A missing file adds a read attempt but no completed read; returned bytes add one completed read even if validation then rejects them.

## Fixed interfaces and outputs

Each returned object contains `realUseStatus: "HOLD"` and `actualFlags`, with all thirteen named actual claims false. This includes aggregate `state()`. A rejected handled call returns only `status: "HOLD_INVALID"`, that held status and those flags. It reveals no rejected identifier, body, path or reason. It clears renewal, current evidence, review and packet while retaining substantive day/mode/version/policy/withdrawal state and lifetime counters. Observer rejections mutate nothing.

| Interface | Bounded behaviour |
|---|---|
| `Tallygate(actor_role)` | Exact built-in `str` ASSURANCE_ANALYST or ASSURANCE_OBSERVER only. Invalid roles raise ValueError before fixture I/O. |
| `state()` | Aggregate day/version/policy/mode/counts/presence and lifetime counters. No source identifiers, digests or bodies. |
| `renew_authority(permission_version)` | Analyst; exact current positive built-in int, excluding bool/subclasses. Through day4 inclusively. Returns AUTHORITY_RENEWED. No source read or activation. |
| `check_supplier(control_id, permission_version)` | C01..C08 after authority. DOCUMENTED_LIMIT, HOLD_UNKNOWN, HOLD_UNSUPPORTED or policy2 HOLD_CHANGED_POLICY are completed analytic results. |
| `assess_use(use_id, permission_version)` | U01..U06 after all eight current controls. LIMITED_PILOT_PLAN or HOLD_USE. No owned-body projection or use execution. |
| `check_failure(case_id, permission_version)` | F01 after eight controls/six uses. CONFIDENTIALITY_FAILURE_TABLETOP supplies proposed containment/functions/evidence questions. No incident has occurred. |
| `rehearse_exit(selection_id, permission_version, custodian_role, custodian_token)` | Stopped, renewed, eligible selection; exact EXIT_CUSTODIAN / ASSUMED-TALLYGATE-CUSTODIAN. Returns EXIT_MANIFEST_DRAFT with owned bodies or admissible HOLD_EXIT_INCOMPLETE with authorised gap metadata only. |
| `review_pack(permission_version, reviewer_role, reviewer_token)` | Stopped, current authority, full inventory/F01/complete exit; exact ASSUMED_GOVERNANCE_REVIEWER / ASSUMED-TALLYGATE-REVIEW. Returns INTERNAL_ASSURANCE_REVIEW binding day/version/policy/sequence/source and cached evidence digests. |
| `export_pack(permission_version)` | Stopped/current complete review. Rereads the source and returns INTERNAL_ASSURANCE_GAP_PACK, a deep-copy dictionary. No actual transfer, deployment or deletion. |
| `stop_use(reason)` | Analyst; built-in str,1..240 raw Python characters, nonempty stripped content. Text is inert, not executed, filtered for meaning or used as authority. WORK_STOPPED increments version and clears current evidence. |
| `apply_change(change_id, owner_role, owner_token)` | Analyst/stopped, exact POLICY_OWNER / ASSUMED-TALLYGATE-OWNER; one-shot POLICY2 or WITHDRAW_R03. SOURCE_EVENT_APPLIED increments version and clears current evidence. No renewal is required for this control event. |
| `resume_use(permission_version)` | Stopped analyst/current renewal. WORK_RESUMED sets ACTIVE_REHEARSAL, increments version and clears renewal/evidence. It resumes this session only. |
| `advance_day(day)` | Analyst/exact built-in int strictly forward. DAY_ADVANCED increments version and clears evidence, including when advancing beyond expiry. |

Python missing arguments or unknown keywords cause a pre-body TypeError and leave the entire state unchanged. A signature-bound invalid value invokes handled invalidation. For example `export_pack()` differs from `export_pack(True)`. The latter is held and clears the current evidence/renewal.

## Original fictional evidence and dependencies

Initial cards C01 instructions, C02 training, C03 retention, C07 export format and C08 supervision are DOCUMENTED_LIMIT. C04 administrator access and C05 subprocessor change are HOLD_UNKNOWN. C06's unsupported badge is HOLD_UNSUPPORTED. A documented fictional limit is not an actual warranty or compliance result; held cards remain in the completed gap pack.

U01 blank administration shell and U02 synthetic checklist depend on C01/C02/C07/C08 and initially yield LIMITED_PILOT_PLAN. U03 client-letter upload, U04 unrestricted training, U05 privileged support access and U06 firm-wide legal release remain HOLD_USE. Limited pilot plans are paper plans; no model, tool, client upload or professional service is run. All eight controls must be current before assessing any use, including held evidence; selecting only convenient cards cannot substitute for the complete inventory.

R01 administration headings, R02 review checklist and R03 supplier-evidence ledger have exact supplied synthetic bodies and fictional firm-owned export labels. They are eligible through day3 inclusively. R04 provider log, R05 excluded client-letter placeholder and R06 another firm's record are descriptors with `bodyOmitted: true`; they have no body keys anywhere in the supplied records. A title or descriptor supplies neither an absent body nor actual permission. The complete physical fixture read still parses the three supplied synthetic body strings, all assertions and descriptors. Parsing is not a confidentiality barrier.

Initially X01 selects exactly R01/R02/R03 and is complete. X02 selects R01/R02 and is admissible but incomplete: one completed read/evaluation, no projected bodies, authorised selected/missing metadata and no complete review. X03 includes R04, X04 includes R05 and X05 includes R06; each is a handled denial before fixture I/O, with no rejected content returned. After WITHDRAW_R03, X01 is denied before I/O and X02 becomes the complete two-record selection. There is no substitute R03 or descriptor body.

## A complete stopped paper-to-code journey

```python
from tallygate_lab import Tallygate

lab = Tallygate("ASSURANCE_ANALYST")
lab.stop_use("Collect supplied fictional assurance and exit evidence.")
lab.renew_authority(2)
for number in range(1, 9):
    lab.check_supplier("C%02d" % number, 2)
for number in range(1, 7):
    lab.assess_use("U%02d" % number, 2)
lab.check_failure("F01", 2)
lab.rehearse_exit("X01", 2, "EXIT_CUSTODIAN", "ASSUMED-TALLYGATE-CUSTODIAN")
lab.review_pack(2, "ASSUMED_GOVERNANCE_REVIEWER", "ASSUMED-TALLYGATE-REVIEW")
packet = lab.export_pack(2)
```

This exact initial stopped journey has18 completed physical reads,16 analytic evaluations and3 owned-body projection occurrences. Review/export each reread once but add no analytic evaluation or body-projection count. The packet contains all eight controls, six use assessments, F01, the complete versioned exit, held evidence, proposed owner questions and review binding. It remains real-use HOLD with all actual flags false.

Each successful analytic check or admissible exit evaluation advances lifetime `evaluationSequence`, replaces that result and clears aggregate review/packet. Other same-version current checked results remain. A valid C01 recheck after the full pack gives one additional read/evaluation and removes review; a fresh review may use the complete remaining cache. Attempting export before that review is a handled failure that clears all evidence and renewal, so full reconstruction becomes necessary.

POLICY2 moves the policy to revision2 and trainingUse CONTENT_IMPROVEMENT. C02 becomes HOLD_CHANGED_POLICY and U01/U02 become HOLD_USE; U04 remains prohibited. Apply the event while stopped, challenge an old-version export, renew the new current version, rebuild all checks/exit and review/export. Starting at the initial completed pack gives36 total reads,32 evaluations and6 projection occurrences. Old exported copies retain their original contents.

For withdrawal, start at the complete stopped version2 pack. Apply WITHDRAW_R03, producing version3. Renew version3 before challenging X01 with the exact custodian. This probes actual withdrawn membership under current authority; the generic denial adds no I/O but clears renewal/cache. Renew version3 again, rebuild all eight controls/six uses/F01, rehearse X02 and review/export. Totals are36 reads,32 evaluations and5 projection occurrences. These are local author-observed counts for the fixed journey, not real supplier, rights or deletion evidence.

On day4 authority can still assess controls, uses and F01, but all owned records have expired. Exit is denied before I/O for zero eligible records; there is no complete review/export. Source reads for governance assessment still parse the complete supplied synthetic fixture, even though no owned body is projected. On day5 renewal/source authority fails before I/O. Stop and owner change may still occur while expired, without reading a source or extending a deadline.

## Limits and evidence interpretation

`physicalFixtureReadAttempts` counts loader entries. `physicalFixtureReadsCompleted` counts full byte reads, including reads later rejected. `evaluationSequence` counts successful fixed analytic results, including held cards/uses and incomplete X02. `projectedOwnedRecordOccurrences` counts bodies returned by complete exit calls, so repeated exits add again; export copies add zero. These are lifetime counters for this instance. None measures actual provider access, unique people, secure erasure or real ownership.

Every output's thirteen false flags are actualClientData, actualUpload, actualProvider, actualModel, actualTraining, actualLegalAdvice, actualProfessionalApproval, actualPrivilegeDecision, actualPrivacyBasis, actualSecurityApproval, actualIdentityAuthentication, actualProviderDeletion and actualOperationalRelease.

Returned values are deep copies; changing them cannot change the stored evidence through that returned object. Python attributes and local files remain mutable. The code is an educational validation exercise, not a security boundary, authenticated professional sign-off or durable revocation system. Old copies survive stop/policy/withdrawal. A new process resets day2/version1/policy1/ACTIVE_REHEARSAL, R03 eligibility and all counters. The author suite performs that genuine fresh-child reset separately.

Real use still requires the actual firm's purpose, client and matter boundaries, professional/privilege/confidentiality judgement, current lawful basis, supplier contract/data locations/subprocessors/admin access, security/retention/deletion evidence, accessibility and accountable approval. The course's reviewed official sources have separate jurisdiction/currentness/retrieval limits. This lab does not decide those questions, prescribe a legal incident deadline or certify a real supplier. Root approval of the finite educational contract and author runtime tests are separate from independent implementation, native, professional or public acceptance.

{
  "schemaVersion": 1,
  "firm": "GREYBEAM_SYNTHETIC_FIRM",
  "supplier": "PAPERBRIDGE_SYNTHETIC_PROVIDER",
  "policy": {
    "revision": 1,
    "trainingUse": "NONE",
    "authorityExpiryDay": 4
  },
  "controls": [
    {
      "id": "C01",
      "kind": "instruction_scope",
      "assertion": "Only supplied synthetic administration shells; no client content is admitted.",
      "evidence": "The authored revision 1 instruction schedule specifies U01/U02 and no real upload.",
      "expected": "DOCUMENTED_LIMIT",
      "owner": "professional-risk owner"
    },
    {
      "id": "C02",
      "kind": "training_use",
      "assertion": "Content is excluded from improvement/training at policy1.",
      "evidence": "The authored revision 1 schedule says trainingUse NONE; this is not a real contractual warranty.",
      "expected": "DOCUMENTED_LIMIT",
      "owner": "contracting/privacy owner"
    },
    {
      "id": "C03",
      "kind": "retention",
      "assertion": "Owned records remain eligible through day 3 inclusively.",
      "evidence": "Authored expiryDay 3 and a backup schedule with no actual deletion evidence.",
      "expected": "DOCUMENTED_LIMIT",
      "owner": "records owner"
    },
    {
      "id": "C04",
      "kind": "admin_access",
      "assertion": "A privileged administrator may view task logs.",
      "evidence": "The policy names a function but supplies no actual access test or location.",
      "expected": "HOLD_UNKNOWN",
      "owner": "security owner"
    },
    {
      "id": "C05",
      "kind": "subprocessor_change",
      "assertion": "Change notice is promised; parties and authorisation remain unresolved.",
      "evidence": "A notice promise is supplied; the actual subprocessor list and signature are absent.",
      "expected": "HOLD_UNKNOWN",
      "owner": "privacy/contract owner"
    },
    {
      "id": "C06",
      "kind": "security_badge",
      "assertion": "A marketing badge is sufficient for unrestricted professional use.",
      "evidence": "The badge has no scope, issuer, expiry or control evidence and conflicts with the permitted-use schedule.",
      "expected": "HOLD_UNSUPPORTED",
      "owner": "security owner"
    },
    {
      "id": "C07",
      "kind": "export_format",
      "assertion": "Owned records use the exact supplied UTF-8 JSON field schema.",
      "evidence": "Three supplied administration records and an exact complete expected export manifest.",
      "expected": "DOCUMENTED_LIMIT",
      "owner": "exit custodian"
    },
    {
      "id": "C08",
      "kind": "supervision",
      "assertion": "An assumed reviewer owns synthetic pack completeness.",
      "evidence": "An authored role boundary, not authenticated professional sign-off.",
      "expected": "DOCUMENTED_LIMIT",
      "owner": "supervision owner"
    }
  ],
  "uses": [
    {
      "id": "U01",
      "purpose": "blank_administration_shell",
      "inputRecordIds": [
        "R01"
      ],
      "requiredControls": [
        "C01",
        "C02",
        "C07",
        "C08"
      ],
      "expected": "LIMITED_PILOT_PLAN",
      "limits": "Fixed original headings only, no client facts, generated legal advice or external operation."
    },
    {
      "id": "U02",
      "purpose": "synthetic_review_checklist",
      "inputRecordIds": [
        "R02"
      ],
      "requiredControls": [
        "C01",
        "C02",
        "C07",
        "C08"
      ],
      "expected": "LIMITED_PILOT_PLAN",
      "limits": "Supplied review structure, not actual review or an AI run."
    },
    {
      "id": "U03",
      "purpose": "client_letter_upload",
      "inputRecordIds": [
        "R05"
      ],
      "requiredControls": [
        "C01"
      ],
      "expected": "HOLD_USE",
      "limits": "Absent body/excluded input; title-only surrogate does not give permission."
    },
    {
      "id": "U04",
      "purpose": "unrestricted_training",
      "inputRecordIds": [
        "R01",
        "R02",
        "R03"
      ],
      "requiredControls": [
        "C02"
      ],
      "expected": "HOLD_USE",
      "limits": "Training is outside the finite permitted-use schedule even if service terms later allow it."
    },
    {
      "id": "U05",
      "purpose": "privileged_support_access",
      "inputRecordIds": [
        "R04"
      ],
      "requiredControls": [
        "C04",
        "C05"
      ],
      "expected": "HOLD_USE",
      "limits": "No actual scope, subprocessor/access evidence or owned record is supplied."
    },
    {
      "id": "U06",
      "purpose": "firmwide_legal_release",
      "inputRecordIds": [
        "R01"
      ],
      "requiredControls": [
        "C06",
        "C08"
      ],
      "expected": "HOLD_USE",
      "limits": "A badge and an assumed reviewer do not approve firm-wide professional service."
    }
  ],
  "records": [
    {
      "id": "R01",
      "owner": "GREYBEAM_SYNTHETIC_FIRM",
      "kind": "blank_shell",
      "rights": "FICTIONAL_OWNED_EXPORT",
      "expiryDay": 3,
      "body": "Fictional administration headings: receiving purpose, proposed owner question, held decision. No client information or legal advice."
    },
    {
      "id": "R02",
      "owner": "GREYBEAM_SYNTHETIC_FIRM",
      "kind": "review_checklist",
      "rights": "FICTIONAL_OWNED_EXPORT",
      "expiryDay": 3,
      "body": "Fictional checklist: compare use schedule, record unresolved supplier facts, identify a proposed reviewer, retain real-use HOLD."
    },
    {
      "id": "R03",
      "owner": "GREYBEAM_SYNTHETIC_FIRM",
      "kind": "supplier_evidence_ledger",
      "rights": "FICTIONAL_OWNED_EXPORT",
      "expiryDay": 3,
      "body": "Fictional evidence ledger columns: source revision, asserted control, bounded support, unknown, proposed accountable function."
    },
    {
      "id": "R04",
      "owner": "PAPERBRIDGE_SYNTHETIC_PROVIDER",
      "kind": "provider_internal_log",
      "rights": "NOT_FIRM_OWNED",
      "expiryDay": 3,
      "bodyOmitted": true
    },
    {
      "id": "R05",
      "owner": "UNRESOLVED_CLIENT_PLACEHOLDER",
      "kind": "excluded_client_letter",
      "rights": "UNRESOLVED",
      "expiryDay": 3,
      "bodyOmitted": true
    },
    {
      "id": "R06",
      "owner": "OTHER_SYNTHETIC_FIRM",
      "kind": "other_firm_record",
      "rights": "NOT_THIS_FIRM",
      "expiryDay": 3,
      "bodyOmitted": true
    }
  ],
  "selections": [
    {
      "id": "X01",
      "recordIds": [
        "R01",
        "R02",
        "R03"
      ],
      "initial": "EXIT_MANIFEST_DRAFT",
      "afterR03withdraw": "HOLD_INVALID"
    },
    {
      "id": "X02",
      "recordIds": [
        "R01",
        "R02"
      ],
      "initial": "HOLD_EXIT_INCOMPLETE",
      "afterR03withdraw": "EXIT_MANIFEST_DRAFT"
    },
    {
      "id": "X03",
      "recordIds": [
        "R01",
        "R02",
        "R03",
        "R04"
      ],
      "initial": "HOLD_INVALID",
      "denialStage": "before I/O"
    },
    {
      "id": "X04",
      "recordIds": [
        "R01",
        "R05"
      ],
      "initial": "HOLD_INVALID",
      "denialStage": "before I/O"
    },
    {
      "id": "X05",
      "recordIds": [
        "R01",
        "R06"
      ],
      "initial": "HOLD_INVALID",
      "denialStage": "before I/O"
    }
  ],
  "failure": {
    "id": "F01",
    "description": "A proposed workflow would place an unredacted client-letter placeholder into an unreviewed public tool. The placeholder has no supplied body; no upload has occurred.",
    "expected": "CONFIDENTIALITY_FAILURE_TABLETOP",
    "requiredFilledAnswer": [
      "Keep prohibited input absent; stop actual proposal via appropriate owner, not via a fictitious successful network block.",
      "Identify proposed professional compliance/contract/privacy/security functions and actual evidence questions.",
      "Separate privilege, confidentiality, basis, incident impact and reporting applicability; do not prescribe an unreviewed legal deadline.",
      "Record proposed prompts/uploads, outputs, support, logs, model improvement, backups and exported copies; actual facts remain UNKNOWN.",
      "Use only the owned fictional exit records. Reconcile the exact selected manifest and preserve excluded-record reasons."
    ]
  },
  "notes": "All supplied records and control assertions are fictional. This note is inert and grants no authority."
}

"""Original Tallygate finite supplier-assurance rehearsal, not real service authority.

Author: Mickarle Sean Junior Wagstaff-Irons - Micky Irons.
Python 3.10+ standard library. No model, network, command or provider calls.
The local file and Python attributes are mutable; this is not a security boundary.
"""
from copy import deepcopy
import hashlib
import json
from pathlib import Path

# Code-owned bindings, no fixture I/O at import or construction.
EXPECTED_FIXTURE = {'schemaVersion': 1,
 'firm': 'GREYBEAM_SYNTHETIC_FIRM',
 'supplier': 'PAPERBRIDGE_SYNTHETIC_PROVIDER',
 'policy': {'revision': 1, 'trainingUse': 'NONE', 'authorityExpiryDay': 4},
 'controls': [{'id': 'C01',
               'kind': 'instruction_scope',
               'assertion': 'Only supplied synthetic administration shells; no client content is '
                            'admitted.',
               'evidence': 'The authored revision 1 instruction schedule specifies U01/U02 and no '
                           'real upload.',
               'expected': 'DOCUMENTED_LIMIT',
               'owner': 'professional-risk owner'},
              {'id': 'C02',
               'kind': 'training_use',
               'assertion': 'Content is excluded from improvement/training at policy1.',
               'evidence': 'The authored revision 1 schedule says trainingUse NONE; this is not a '
                           'real contractual warranty.',
               'expected': 'DOCUMENTED_LIMIT',
               'owner': 'contracting/privacy owner'},
              {'id': 'C03',
               'kind': 'retention',
               'assertion': 'Owned records remain eligible through day 3 inclusively.',
               'evidence': 'Authored expiryDay 3 and a backup schedule with no actual deletion '
                           'evidence.',
               'expected': 'DOCUMENTED_LIMIT',
               'owner': 'records owner'},
              {'id': 'C04',
               'kind': 'admin_access',
               'assertion': 'A privileged administrator may view task logs.',
               'evidence': 'The policy names a function but supplies no actual access test or '
                           'location.',
               'expected': 'HOLD_UNKNOWN',
               'owner': 'security owner'},
              {'id': 'C05',
               'kind': 'subprocessor_change',
               'assertion': 'Change notice is promised; parties and authorisation remain '
                            'unresolved.',
               'evidence': 'A notice promise is supplied; the actual subprocessor list and '
                           'signature are absent.',
               'expected': 'HOLD_UNKNOWN',
               'owner': 'privacy/contract owner'},
              {'id': 'C06',
               'kind': 'security_badge',
               'assertion': 'A marketing badge is sufficient for unrestricted professional use.',
               'evidence': 'The badge has no scope, issuer, expiry or control evidence and '
                           'conflicts with the permitted-use schedule.',
               'expected': 'HOLD_UNSUPPORTED',
               'owner': 'security owner'},
              {'id': 'C07',
               'kind': 'export_format',
               'assertion': 'Owned records use the exact supplied UTF-8 JSON field schema.',
               'evidence': 'Three supplied administration records and an exact complete expected '
                           'export manifest.',
               'expected': 'DOCUMENTED_LIMIT',
               'owner': 'exit custodian'},
              {'id': 'C08',
               'kind': 'supervision',
               'assertion': 'An assumed reviewer owns synthetic pack completeness.',
               'evidence': 'An authored role boundary, not authenticated professional sign-off.',
               'expected': 'DOCUMENTED_LIMIT',
               'owner': 'supervision owner'}],
 'uses': [{'id': 'U01',
           'purpose': 'blank_administration_shell',
           'inputRecordIds': ['R01'],
           'requiredControls': ['C01', 'C02', 'C07', 'C08'],
           'expected': 'LIMITED_PILOT_PLAN',
           'limits': 'Fixed original headings only, no client facts, generated legal advice or '
                     'external operation.'},
          {'id': 'U02',
           'purpose': 'synthetic_review_checklist',
           'inputRecordIds': ['R02'],
           'requiredControls': ['C01', 'C02', 'C07', 'C08'],
           'expected': 'LIMITED_PILOT_PLAN',
           'limits': 'Supplied review structure, not actual review or an AI run.'},
          {'id': 'U03',
           'purpose': 'client_letter_upload',
           'inputRecordIds': ['R05'],
           'requiredControls': ['C01'],
           'expected': 'HOLD_USE',
           'limits': 'Absent body/excluded input; title-only surrogate does not give permission.'},
          {'id': 'U04',
           'purpose': 'unrestricted_training',
           'inputRecordIds': ['R01', 'R02', 'R03'],
           'requiredControls': ['C02'],
           'expected': 'HOLD_USE',
           'limits': 'Training is outside the finite permitted-use schedule even if service terms '
                     'later allow it.'},
          {'id': 'U05',
           'purpose': 'privileged_support_access',
           'inputRecordIds': ['R04'],
           'requiredControls': ['C04', 'C05'],
           'expected': 'HOLD_USE',
           'limits': 'No actual scope, subprocessor/access evidence or owned record is supplied.'},
          {'id': 'U06',
           'purpose': 'firmwide_legal_release',
           'inputRecordIds': ['R01'],
           'requiredControls': ['C06', 'C08'],
           'expected': 'HOLD_USE',
           'limits': 'A badge and an assumed reviewer do not approve firm-wide professional '
                     'service.'}],
 'records': [{'id': 'R01',
              'owner': 'GREYBEAM_SYNTHETIC_FIRM',
              'kind': 'blank_shell',
              'rights': 'FICTIONAL_OWNED_EXPORT',
              'expiryDay': 3,
              'body': 'Fictional administration headings: receiving purpose, proposed owner '
                      'question, held decision. No client information or legal advice.'},
             {'id': 'R02',
              'owner': 'GREYBEAM_SYNTHETIC_FIRM',
              'kind': 'review_checklist',
              'rights': 'FICTIONAL_OWNED_EXPORT',
              'expiryDay': 3,
              'body': 'Fictional checklist: compare use schedule, record unresolved supplier '
                      'facts, identify a proposed reviewer, retain real-use HOLD.'},
             {'id': 'R03',
              'owner': 'GREYBEAM_SYNTHETIC_FIRM',
              'kind': 'supplier_evidence_ledger',
              'rights': 'FICTIONAL_OWNED_EXPORT',
              'expiryDay': 3,
              'body': 'Fictional evidence ledger columns: source revision, asserted control, '
                      'bounded support, unknown, proposed accountable function.'},
             {'id': 'R04',
              'owner': 'PAPERBRIDGE_SYNTHETIC_PROVIDER',
              'kind': 'provider_internal_log',
              'rights': 'NOT_FIRM_OWNED',
              'expiryDay': 3,
              'bodyOmitted': True},
             {'id': 'R05',
              'owner': 'UNRESOLVED_CLIENT_PLACEHOLDER',
              'kind': 'excluded_client_letter',
              'rights': 'UNRESOLVED',
              'expiryDay': 3,
              'bodyOmitted': True},
             {'id': 'R06',
              'owner': 'OTHER_SYNTHETIC_FIRM',
              'kind': 'other_firm_record',
              'rights': 'NOT_THIS_FIRM',
              'expiryDay': 3,
              'bodyOmitted': True}],
 'selections': [{'id': 'X01',
                 'recordIds': ['R01', 'R02', 'R03'],
                 'initial': 'EXIT_MANIFEST_DRAFT',
                 'afterR03withdraw': 'HOLD_INVALID'},
                {'id': 'X02',
                 'recordIds': ['R01', 'R02'],
                 'initial': 'HOLD_EXIT_INCOMPLETE',
                 'afterR03withdraw': 'EXIT_MANIFEST_DRAFT'},
                {'id': 'X03',
                 'recordIds': ['R01', 'R02', 'R03', 'R04'],
                 'initial': 'HOLD_INVALID',
                 'denialStage': 'before I/O'},
                {'id': 'X04',
                 'recordIds': ['R01', 'R05'],
                 'initial': 'HOLD_INVALID',
                 'denialStage': 'before I/O'},
                {'id': 'X05',
                 'recordIds': ['R01', 'R06'],
                 'initial': 'HOLD_INVALID',
                 'denialStage': 'before I/O'}],
 'failure': {'id': 'F01',
             'description': 'A proposed workflow would place an unredacted client-letter '
                            'placeholder into an unreviewed public tool. The placeholder has no '
                            'supplied body; no upload has occurred.',
             'expected': 'CONFIDENTIALITY_FAILURE_TABLETOP',
             'requiredFilledAnswer': ['Keep prohibited input absent; stop actual proposal via '
                                      'appropriate owner, not via a fictitious successful network '
                                      'block.',
                                      'Identify proposed professional '
                                      'compliance/contract/privacy/security functions and actual '
                                      'evidence questions.',
                                      'Separate privilege, confidentiality, basis, incident impact '
                                      'and reporting applicability; do not prescribe an unreviewed '
                                      'legal deadline.',
                                      'Record proposed prompts/uploads, outputs, support, logs, '
                                      'model improvement, backups and exported copies; actual '
                                      'facts remain UNKNOWN.',
                                      'Use only the owned fictional exit records. Reconcile the '
                                      'exact selected manifest and preserve excluded-record '
                                      'reasons.']},
 'notes': 'All supplied records and control assertions are fictional. This note is inert and '
          'grants no authority.'}
RAW_SHA256 = '24af7328bafd7a1ec7dddf3636d716b95ad1c51bd56fe272527b38992e7077a8'
CANONICAL_SHA256 = 'ec1e6a239807671685b6de98e0ef86760d32aef3740543c3016a45e01ee03f1c'
ACTUAL_FLAGS = ('actualClientData', 'actualUpload', 'actualProvider', 'actualModel', 'actualTraining', 'actualLegalAdvice', 'actualProfessionalApproval', 'actualPrivilegeDecision', 'actualPrivacyBasis', 'actualSecurityApproval', 'actualIdentityAuthentication', 'actualProviderDeletion', 'actualOperationalRelease')



def _canonical(value):
    return json.dumps(value,ensure_ascii=False,sort_keys=True,separators=(',',':'),allow_nan=False).encode('utf-8')


def _identical(value,expected):
    """Exact schemas and built-in types, including bool versus int."""
    if type(value) is not type(expected):
        return False
    if type(expected) is dict:
        return value.keys()==expected.keys() and all(_identical(value[k],v) for k,v in expected.items())
    if type(expected) is list:
        return len(value)==len(expected) and all(_identical(a,b) for a,b in zip(value,expected))
    return value==expected


def _unique_pairs(pairs):
    obj={}
    for key,value in pairs:
        if key in obj:
            raise ValueError('Duplicate JSON member')
        obj[key]=value
    return obj


def _nonfinite(_value):
    raise ValueError('Non-finite JSON value')


class Tallygate:
    """Thirteen approved fixed interfaces, including the constructor."""
    def __init__(self,actor_role):
        if type(actor_role) is not str or actor_role not in ('ASSURANCE_ANALYST','ASSURANCE_OBSERVER'):
            raise ValueError('Unknown assumed role')
        self._actor=actor_role
        self._day=2
        self._version=1
        self._policy=1
        self._mode='ACTIVE_REHEARSAL'
        self._withdrawn=False
        self._applied=set()
        self._sequence=0
        self._attempts=0
        self._completed=0
        self._projections=0
        self._fixture_path=Path(__file__).with_name('tallygate_records.json')
        self._definition=deepcopy(EXPECTED_FIXTURE)
        self._raw_digest=RAW_SHA256
        self._canonical_digest=CANONICAL_SHA256
        self._clear()

    def _clear(self):
        self._renewed=None
        self._controls={}
        self._uses={}
        self._failure=None
        self._exit=None
        self._review=None
        self._packet=None

    def _reply(self,status,**fields):
        return deepcopy({'status':status,'realUseStatus':'HOLD','actualFlags':{name:False for name in ACTUAL_FLAGS},**fields})

    def _reject(self):
        # The observer may inspect aggregate state only. Its denied calls have no mutation.
        if self._actor=='ASSURANCE_ANALYST':
            self._clear()
        return self._reply('HOLD_INVALID')

    def _analyst(self):
        return self._actor=='ASSURANCE_ANALYST'

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

    def _authority(self,version):
        return self._analyst() and self._version_ok(version) and self._renewed==version and self._day<=4

    @staticmethod
    def _exact(value,wanted):
        return type(value) is str and value==wanted

    @staticmethod
    def _known(value,rows):
        return type(value) is str and value in {r['id'] for r in rows}

    def _eligible(self):
        return [r['id'] for r in self._definition['records'] if r['owner']==self._definition['firm'] and r['rights']=='FICTIONAL_OWNED_EXPORT' and self._day<=r['expiryDay'] and not (self._withdrawn and r['id']=='R03')]

    def _load(self):
        self._attempts+=1
        raw=self._fixture_path.read_bytes()
        self._completed+=1
        parsed=json.loads(raw.decode('utf-8'),object_pairs_hook=_unique_pairs,parse_constant=_nonfinite)
        if hashlib.sha256(raw).hexdigest()!=self._raw_digest or not _identical(parsed,self._definition):
            raise ValueError('Fixture binding changed')
        if hashlib.sha256(_canonical(parsed)).hexdigest()!=self._canonical_digest:
            raise ValueError('Canonical binding changed')
        for key in ('controls','uses','records','selections'):
            ids=[r['id'] for r in parsed[key]]
            if len(ids)!=len(set(ids)):
                raise ValueError('Duplicate source identifier')
        if any('body' in r or r.get('bodyOmitted') is not True for r in parsed['records'][3:]):
            raise ValueError('Excluded body supplied')
        return parsed

    def _read_checked(self):
        try:
            return self._load()
        except (OSError,UnicodeError,ValueError,TypeError):
            self._clear()
            return None

    def _binding(self,sequence):
        return {'day':self._day,'permissionVersion':self._version,'policyRevision':self._policy,'evaluationSequence':sequence,'rawFixtureSha256':self._raw_digest,'canonicalFixtureSha256':self._canonical_digest}

    def _control_result(self,control_id,sequence):
        card=next(c for c in self._definition['controls'] if c['id']==control_id)
        status='HOLD_CHANGED_POLICY' if control_id=='C02' and self._policy==2 else card['expected']
        return self._reply(status,control=card,binding=self._binding(sequence),trainingUse='CONTENT_IMPROVEMENT' if self._policy==2 else 'NONE')

    def _use_result(self,use_id,sequence):
        plan=next(u for u in self._definition['uses'] if u['id']==use_id)
        status='HOLD_USE' if self._policy==2 and use_id in ('U01','U02') else plan['expected']
        return self._reply(status,usePlan=plan,binding=self._binding(sequence),requiredControlDispositions={cid:self._controls[cid]['status'] for cid in plan['requiredControls']},proposedUseOnly=True)

    def _failure_result(self,sequence):
        return self._reply('CONFIDENTIALITY_FAILURE_TABLETOP',tabletop=self._definition['failure'],binding=self._binding(sequence),incidentOccurred=False)

    def _exit_result(self,selection_id,sequence):
        selection=next(x for x in self._definition['selections'] if x['id']==selection_id)
        chosen=selection['recordIds']
        missing=[rid for rid in self._eligible() if rid not in chosen]
        if missing:
            return self._reply('HOLD_EXIT_INCOMPLETE',selectedRecordIds=chosen,missingRecordIds=missing,binding=self._binding(sequence))
        rows=[r for r in self._definition['records'] if r['id'] in chosen]
        reasons=[{'id':r['id'],'reason':r['rights'],'bodyPresent':False} for r in self._definition['records'][3:]]
        if self._withdrawn:
            reasons.append({'id':'R03','reason':'WITHDRAWN_IN_REHEARSAL','bodyPresent':False})
        return self._reply('EXIT_MANIFEST_DRAFT',selectionId=selection_id,ownedRecords=rows,excludedRecordReasons=reasons,binding=self._binding(sequence),transferOccurred=False)

    def _cache_valid(self,kind):
        rows=self._controls if kind=='controls' else self._uses
        expected=self._definition[kind]
        if set(rows)!={r['id'] for r in expected}:
            return False
        for rid,result in rows.items():
            if type(result) is not dict or type(result.get('binding')) is not dict:
                return False
            seq=result['binding'].get('evaluationSequence')
            if type(seq) is not int or not 1<=seq<=self._sequence:
                return False
            wanted=self._control_result(rid,seq) if kind=='controls' else self._use_result(rid,seq)
            if not _identical(result,wanted):
                return False
        return True

    def _ready_inventory(self):
        if not self._cache_valid('controls') or not self._cache_valid('uses'):
            return False
        if type(self._failure) is not dict or type(self._failure.get('binding')) is not dict:
            return False
        seq=self._failure['binding'].get('evaluationSequence')
        return type(seq) is int and 1<=seq<=self._sequence and _identical(self._failure,self._failure_result(seq))

    def _complete_exit(self):
        if type(self._exit) is not dict or self._exit.get('status')!='EXIT_MANIFEST_DRAFT' or type(self._exit.get('binding')) is not dict:
            return False
        sid=self._exit.get('selectionId');seq=self._exit['binding'].get('evaluationSequence')
        if not self._known(sid,self._definition['selections']) or type(seq) is not int or not 1<=seq<=self._sequence:
            return False
        selection=next(x for x in self._definition['selections'] if x['id']==sid)
        return bool(self._eligible()) and set(selection['recordIds'])==set(self._eligible()) and _identical(self._exit,self._exit_result(sid,seq))

    def _evaluated(self):
        self._sequence+=1
        self._review=None
        self._packet=None
        return self._sequence

    def _review_result(self):
        cached={'controls':self._controls,'uses':self._uses,'failure':self._failure,'exit':self._exit}
        return self._reply('INTERNAL_ASSURANCE_REVIEW',binding=self._binding(self._sequence),cachedEvidenceSha256=hashlib.sha256(_canonical(cached)).hexdigest(),heldControls=sum(r['status']!='DOCUMENTED_LIMIT' for r in self._controls.values()),heldUses=sum(r['status']=='HOLD_USE' for r in self._uses.values()),assumedReviewerOnly=True)

    def state(self):
        return self._reply('AGGREGATE_STATE',actorRole=self._actor,day=self._day,permissionVersion=self._version,policyRevision=self._policy,mode=self._mode,renewedVersion=self._renewed,currentControlCount=len(self._controls),currentUseCount=len(self._uses),failurePresent=self._failure is not None,exitPresent=self._exit is not None,completeExitPresent=self._exit is not None and self._exit.get('status')=='EXIT_MANIFEST_DRAFT',reviewPresent=self._review is not None,packetPresent=self._packet is not None,eligibleOwnedRecordCount=len(self._eligible()),withdrawnOwnedRecordCount=int(self._withdrawn),evaluationSequence=self._sequence,physicalFixtureReadAttempts=self._attempts,physicalFixtureReadsCompleted=self._completed,projectedOwnedRecordOccurrences=self._projections)

    def renew_authority(self,permission_version):
        if not self._analyst() or not self._version_ok(permission_version) or self._day>4:
            return self._reject()
        self._renewed=permission_version
        return self._reply('AUTHORITY_RENEWED',day=self._day,permissionVersion=self._version,authorityThroughDay=4)

    def check_supplier(self,control_id,permission_version):
        if not self._authority(permission_version) or not self._known(control_id,self._definition['controls']):
            return self._reject()
        if self._read_checked() is None:
            return self._reject()
        seq=self._evaluated();result=self._control_result(control_id,seq);self._controls[control_id]=deepcopy(result)
        return deepcopy(result)

    def assess_use(self,use_id,permission_version):
        if not self._authority(permission_version) or not self._known(use_id,self._definition['uses']) or not self._cache_valid('controls'):
            return self._reject()
        if self._read_checked() is None:
            return self._reject()
        seq=self._evaluated();result=self._use_result(use_id,seq);self._uses[use_id]=deepcopy(result)
        return deepcopy(result)

    def check_failure(self,case_id,permission_version):
        if not self._authority(permission_version) or not self._exact(case_id,'F01') or not self._cache_valid('controls') or not self._cache_valid('uses'):
            return self._reject()
        if self._read_checked() is None:
            return self._reject()
        seq=self._evaluated();self._failure=self._failure_result(seq)
        return deepcopy(self._failure)

    def rehearse_exit(self,selection_id,permission_version,custodian_role,custodian_token):
        if not self._authority(permission_version) or self._mode!='STOPPED_REHEARSAL' or not self._known(selection_id,self._definition['selections']) or not self._exact(custodian_role,'EXIT_CUSTODIAN') or not self._exact(custodian_token,'ASSUMED-TALLYGATE-CUSTODIAN'):
            return self._reject()
        chosen=next(x['recordIds'] for x in self._definition['selections'] if x['id']==selection_id)
        eligible=self._eligible()
        if not eligible or not set(chosen)<=set(eligible):
            return self._reject()
        if self._read_checked() is None:
            return self._reject()
        seq=self._evaluated();self._exit=self._exit_result(selection_id,seq)
        if self._exit['status']=='EXIT_MANIFEST_DRAFT':
            self._projections+=len(self._exit['ownedRecords'])
        return deepcopy(self._exit)

    def review_pack(self,permission_version,reviewer_role,reviewer_token):
        if not self._authority(permission_version) or self._mode!='STOPPED_REHEARSAL' or not self._exact(reviewer_role,'ASSUMED_GOVERNANCE_REVIEWER') or not self._exact(reviewer_token,'ASSUMED-TALLYGATE-REVIEW') or not self._ready_inventory() or not self._complete_exit():
            return self._reject()
        if self._read_checked() is None:
            return self._reject()
        self._review=self._review_result();self._packet=None
        return deepcopy(self._review)

    def export_pack(self,permission_version):
        if not self._authority(permission_version) or self._mode!='STOPPED_REHEARSAL' or not self._ready_inventory() or not self._complete_exit() or not _identical(self._review,self._review_result()):
            return self._reject()
        if self._read_checked() is None:
            return self._reject()
        questions=[{'proposedOwner':c['owner'],'controlId':c['id'],'question':'What actual scoped evidence, responsible decision and unresolved limits support this supplied assertion?'} for c in self._definition['controls']]
        self._packet=self._reply('INTERNAL_ASSURANCE_GAP_PACK',binding=self._binding(self._sequence),controls=[self._controls[c['id']] for c in self._definition['controls']],useAssessments=[self._uses[u['id']] for u in self._definition['uses']],failureTabletop=self._failure,exitManifest=self._exit,ownedRecords=self._exit['ownedRecords'],heldEvidence={'controls':[c for c in self._controls.values() if c['status']!='DOCUMENTED_LIMIT'],'uses':[u for u in self._uses.values() if u['status']=='HOLD_USE']},proposedOwnerQuestions=questions,scopedReview=self._review)
        return deepcopy(self._packet)

    def stop_use(self,reason):
        if not self._analyst() or type(reason) is not str or not 1<=len(reason)<=240 or not reason.strip():
            return self._reject()
        self._mode='STOPPED_REHEARSAL';self._version+=1;self._clear()
        return self._reply('WORK_STOPPED',permissionVersion=self._version,mode=self._mode)

    def apply_change(self,change_id,owner_role,owner_token):
        if not self._analyst() or self._mode!='STOPPED_REHEARSAL' or type(change_id) is not str or change_id not in ('POLICY2','WITHDRAW_R03') or change_id in self._applied or not self._exact(owner_role,'POLICY_OWNER') or not self._exact(owner_token,'ASSUMED-TALLYGATE-OWNER'):
            return self._reject()
        if change_id=='POLICY2':
            self._policy=2
        else:
            self._withdrawn=True
        self._applied.add(change_id);self._version+=1;self._clear()
        return self._reply('SOURCE_EVENT_APPLIED',permissionVersion=self._version,policyRevision=self._policy,withdrawnOwnedRecordCount=int(self._withdrawn))

    def resume_use(self,permission_version):
        if not self._authority(permission_version) or self._mode!='STOPPED_REHEARSAL':
            return self._reject()
        self._mode='ACTIVE_REHEARSAL';self._version+=1;self._clear()
        return self._reply('WORK_RESUMED',permissionVersion=self._version,mode=self._mode)

    def advance_day(self,day):
        if not self._analyst() or type(day) is not int or day<=self._day:
            return self._reject()
        self._day=day;self._version+=1;self._clear()
        return self._reply('DAY_ADVANCED',day=self._day,permissionVersion=self._version)


if __name__=='__main__':
    lab=Tallygate('ASSURANCE_ANALYST')
    lab.stop_use('Collect only supplied fictional evidence, keep actual service held.')
    lab.renew_authority(2)
    for n in range(1,9):
        lab.check_supplier('C%02d'%n,2)
    for n in range(1,7):
        lab.assess_use('U%02d'%n,2)
    lab.check_failure('F01',2)
    lab.rehearse_exit('X01',2,'EXIT_CUSTODIAN','ASSUMED-TALLYGATE-CUSTODIAN')
    lab.review_pack(2,'ASSUMED_GOVERNANCE_REVIEWER','ASSUMED-TALLYGATE-REVIEW')
    print(json.dumps({'packet':lab.export_pack(2),'aggregate':lab.state()},ensure_ascii=False,indent=2))

"""Author contract checks. Each test uses a contained disposable portable copy.

The one child-process test starts this supplied lab with fixed aggregate-only code.
No model, network, provider or actual client material is used.
"""
from collections import Counter
from copy import deepcopy
import hashlib
import importlib.util
import json
import os
from pathlib import Path
import shutil
import subprocess
import sys
import tempfile
import unittest
from unittest.mock import patch

HERE=Path(__file__).resolve().parent
sys.dont_write_bytecode=True
CUSTODIAN=('EXIT_CUSTODIAN','ASSUMED-TALLYGATE-CUSTODIAN')
REVIEWER=('ASSUMED_GOVERNANCE_REVIEWER','ASSUMED-TALLYGATE-REVIEW')
OWNER=('POLICY_OWNER','ASSUMED-TALLYGATE-OWNER')


class TextSubclass(str):pass
class IntSubclass(int):pass


class TallygateContractTests(unittest.TestCase):
    def setUp(self):
        self.scratch=HERE/'test-temp';self.scratch.mkdir(exist_ok=True)
        self.temp=tempfile.TemporaryDirectory(prefix='contract-',dir=self.scratch)
        self.folder=Path(self.temp.name)
        for name in ('tallygate_lab.py','tallygate_records.json'):
            shutil.copyfile(HERE/name,self.folder/name)
        spec=importlib.util.spec_from_file_location('tallygate_test_copy',self.folder/'tallygate_lab.py')
        self.m=importlib.util.module_from_spec(spec);spec.loader.exec_module(self.m)
        self.lab=self.m.Tallygate('ASSURANCE_ANALYST')
        self.fixture=self.folder/'tallygate_records.json'
        self.original=self.fixture.read_bytes()

    def tearDown(self):
        self.temp.cleanup()
        try:self.scratch.rmdir()
        except OSError:pass

    def held(self,value):
        self.assertEqual(value['realUseStatus'],'HOLD')
        self.assertEqual(set(value['actualFlags']),set(self.m.ACTUAL_FLAGS))
        self.assertTrue(all(type(v) is bool and v is False for v in value['actualFlags'].values()))
        return value

    def invalid(self,value):
        self.held(value)
        self.assertEqual(set(value),{'status','realUseStatus','actualFlags'})
        self.assertEqual(value['status'],'HOLD_INVALID')

    def counts(self,reads,sequence,projections,attempts=None):
        s=self.lab.state()
        self.assertEqual((s['physicalFixtureReadAttempts'],s['physicalFixtureReadsCompleted'],s['evaluationSequence'],s['projectedOwnedRecordOccurrences']),(reads if attempts is None else attempts,reads,sequence,projections))

    def stopped(self):
        self.assertEqual(self.lab.stop_use('A fictional governance and exit rehearsal.')['status'],'WORK_STOPPED')
        self.assertEqual(self.lab.renew_authority(2)['status'],'AUTHORITY_RENEWED')
        return 2

    def inventory(self,version):
        controls=[self.held(self.lab.check_supplier('C%02d'%i,version)) for i in range(1,9)]
        uses=[self.held(self.lab.assess_use('U%02d'%i,version)) for i in range(1,7)]
        failure=self.held(self.lab.check_failure('F01',version))
        self.assertEqual(failure['status'],'CONFIDENTIALITY_FAILURE_TABLETOP')
        return controls,uses,failure

    def complete(self,version=2,selection='X01'):
        self.inventory(version)
        exit_result=self.held(self.lab.rehearse_exit(selection,version,*CUSTODIAN))
        self.assertEqual(exit_result['status'],'EXIT_MANIFEST_DRAFT')
        review=self.held(self.lab.review_pack(version,*REVIEWER));self.assertEqual(review['status'],'INTERNAL_ASSURANCE_REVIEW')
        packet=self.held(self.lab.export_pack(version));self.assertEqual(packet['status'],'INTERNAL_ASSURANCE_GAP_PACK')
        return packet

    def test_constructor_exact_roles_and_no_fixture_io(self):
        with patch.object(self.m.Path,'read_bytes',side_effect=AssertionError('Constructor I/O')):
            for value in ('UNKNOWN',None,True,1,[],TextSubclass('ASSURANCE_ANALYST')):
                with self.subTest(roleType=type(value).__name__):
                    with self.assertRaises(ValueError):self.m.Tallygate(value)
            actor=self.m.Tallygate('ASSURANCE_OBSERVER')
            self.assertEqual(actor.state()['physicalFixtureReadAttempts'],0)

    def test_initial_state_aggregate_and_all_flags(self):
        s=self.held(self.lab.state())
        self.assertEqual((s['day'],s['permissionVersion'],s['policyRevision'],s['mode']),(2,1,1,'ACTIVE_REHEARSAL'))
        self.assertEqual(s['eligibleOwnedRecordCount'],3)
        self.assertIsNone(s['renewedVersion']);self.counts(0,0,0)
        serial=json.dumps(s)
        self.assertTrue(all(value not in serial for value in ('R01','R03','C01','PAPERBRIDGE','GREYBEAM','body','Sha256')))

    def test_observer_all_nonstate_interfaces_no_mutation(self):
        observer=self.m.Tallygate('ASSURANCE_OBSERVER');before=observer.state()
        calls=[lambda:observer.renew_authority(1),lambda:observer.check_supplier('C01',1),lambda:observer.assess_use('U01',1),lambda:observer.check_failure('F01',1),lambda:observer.rehearse_exit('X01',1,*CUSTODIAN),lambda:observer.review_pack(1,*REVIEWER),lambda:observer.export_pack(1),lambda:observer.stop_use('valid'),lambda:observer.apply_change('POLICY2',*OWNER),lambda:observer.resume_use(1),lambda:observer.advance_day(3)]
        for call in calls:self.invalid(call());self.assertEqual(observer.state(),before)

    def test_initial_control_use_tabletop_counts(self):
        self.lab.renew_authority(1);controls,uses,failure=self.inventory(1)
        self.assertEqual(Counter(c['status'] for c in controls),Counter({'DOCUMENTED_LIMIT':5,'HOLD_UNKNOWN':2,'HOLD_UNSUPPORTED':1}))
        self.assertEqual(Counter(u['status'] for u in uses),Counter({'LIMITED_PILOT_PLAN':2,'HOLD_USE':4}))
        self.assertEqual(len(failure['tabletop']['requiredFilledAnswer']),5)
        self.counts(15,15,0)
        self.invalid(self.lab.review_pack(1,*REVIEWER));self.counts(15,15,0)

    def test_complete_stopped_gap_pack_exact_inventory(self):
        self.stopped();packet=self.complete();self.counts(18,16,3)
        self.assertEqual(len(packet['controls']),8);self.assertEqual(len(packet['useAssessments']),6)
        self.assertEqual(len(packet['heldEvidence']['controls']),3);self.assertEqual(len(packet['heldEvidence']['uses']),4)
        self.assertEqual([r['id'] for r in packet['ownedRecords']],['R01','R02','R03'])
        self.assertTrue(all(set(r)=={'id','owner','kind','rights','expiryDay','body'} for r in packet['ownedRecords']))
        self.assertEqual(len(packet['proposedOwnerQuestions']),8)
        self.assertEqual(packet['binding']['evaluationSequence'],16)
        self.assertEqual(packet,json.loads(json.dumps(packet)))

    def test_incomplete_admissible_exit_has_gap_metadata_no_bodies(self):
        self.stopped();self.inventory(2)
        result=self.held(self.lab.rehearse_exit('X02',2,*CUSTODIAN))
        self.assertEqual(result['status'],'HOLD_EXIT_INCOMPLETE')
        self.assertEqual(result['selectedRecordIds'],['R01','R02']);self.assertEqual(result['missingRecordIds'],['R03'])
        self.assertNotIn('ownedRecords',result);self.counts(16,16,0)
        self.invalid(self.lab.review_pack(2,*REVIEWER));self.counts(16,16,0)
        self.assertEqual(self.lab.state()['currentControlCount'],0)

    def test_unowned_and_absent_selections_denied_before_io(self):
        for sid in ('X03','X04','X05'):
            with self.subTest(selection=sid):
                self.lab.renew_authority(self.stopped() if self.lab.state()['mode']=='ACTIVE_REHEARSAL' else self.lab.state()['permissionVersion'])
                version=self.lab.state()['permissionVersion'];self.invalid(self.lab.rehearse_exit(sid,version,*CUSTODIAN));self.counts(0,0,0)

    def test_withdrawal_probe_current_renewal_then_reconstruct(self):
        self.stopped();old=deepcopy(self.complete())
        self.lab.apply_change('WITHDRAW_R03',*OWNER);self.assertEqual(self.lab.state()['permissionVersion'],3)
        self.lab.renew_authority(3);self.invalid(self.lab.rehearse_exit('X01',3,*CUSTODIAN));self.counts(18,16,3)
        self.assertIsNone(self.lab.state()['renewedVersion'])
        self.lab.renew_authority(3);packet=self.complete(3,'X02');self.counts(36,32,5)
        self.assertEqual([r['id'] for r in packet['ownedRecords']],['R01','R02'])
        self.assertEqual([r['id'] for r in old['ownedRecords']],['R01','R02','R03'])

    def test_policy_change_all_uses_held_old_export_denial(self):
        self.stopped();old=deepcopy(self.complete());self.lab.apply_change('POLICY2',*OWNER)
        self.invalid(self.lab.export_pack(2));self.counts(18,16,3)
        self.lab.renew_authority(3);packet=self.complete(3);self.counts(36,32,6)
        self.assertEqual(packet['controls'][1]['status'],'HOLD_CHANGED_POLICY')
        self.assertTrue(all(u['status']=='HOLD_USE' for u in packet['useAssessments']))
        self.assertEqual(len(packet['heldEvidence']['controls']),4)
        self.assertEqual(old['controls'][1]['status'],'DOCUMENTED_LIMIT')
        self.assertEqual(packet['useAssessments'][3]['status'],'HOLD_USE')

    def test_inclusive_day3_complete_day4_zero_exit(self):
        self.stopped();self.lab.advance_day(3);self.lab.renew_authority(3)
        self.complete(3);self.counts(18,16,3)
        self.lab.advance_day(4);self.lab.renew_authority(4);self.inventory(4);self.counts(33,31,3)
        self.assertEqual(self.lab.state()['eligibleOwnedRecordCount'],0)
        self.invalid(self.lab.rehearse_exit('X01',4,*CUSTODIAN));self.counts(33,31,3)
        self.assertFalse(self.lab.state()['completeExitPresent'])

    def test_day5_authority_denies_reads_but_stop_change_possible(self):
        self.lab.advance_day(5);self.invalid(self.lab.renew_authority(2));self.invalid(self.lab.check_supplier('C01',2));self.counts(0,0,0)
        self.assertEqual(self.lab.stop_use('expired proposal still held')['status'],'WORK_STOPPED')
        self.assertEqual(self.lab.apply_change('POLICY2',*OWNER)['status'],'SOURCE_EVENT_APPLIED')
        self.counts(0,0,0)

    def test_exact_version_no_bool_subclass_or_coercion(self):
        for version in (True,False,'1',1.0,IntSubclass(1),0,-1,2):
            self.invalid(self.lab.renew_authority(version));self.counts(0,0,0)
        self.lab.renew_authority(1);self.invalid(self.lab.check_supplier('C01',True));self.counts(0,0,0)

    def test_exact_identifiers_no_subclass_unknown_or_content(self):
        for cid in (TextSubclass('C01'),'C99','https://example.invalid',{'id':'C01'},None):
            self.lab.renew_authority(1);self.invalid(self.lab.check_supplier(cid,1));self.counts(0,0,0)

    def test_missing_current_dependencies_pre_io(self):
        self.lab.renew_authority(1);self.lab.check_supplier('C01',1)
        self.invalid(self.lab.assess_use('U01',1));self.counts(1,1,0)
        self.lab.renew_authority(1)
        for i in range(1,9):self.lab.check_supplier('C%02d'%i,1)
        self.lab.assess_use('U01',1);self.invalid(self.lab.check_failure('F01',1));self.counts(10,10,0)

    def test_missing_renewal_and_stale_version_clear_cache(self):
        self.invalid(self.lab.check_supplier('C01',1));self.counts(0,0,0)
        self.lab.renew_authority(1);self.lab.check_supplier('C01',1)
        self.invalid(self.lab.check_supplier('C02',2));self.counts(1,1,0)
        self.assertEqual(self.lab.state()['currentControlCount'],0);self.assertIsNone(self.lab.state()['renewedVersion'])

    def test_custodian_and_reviewer_tokens_are_exact_assumptions(self):
        self.stopped()
        for role,token in [('EXIT_CUSTODIAN','forged'),(TextSubclass('EXIT_CUSTODIAN'),CUSTODIAN[1]),('other',CUSTODIAN[1])]:
            self.lab.renew_authority(2);self.invalid(self.lab.rehearse_exit('X01',2,role,token));self.counts(0,0,0)
        self.lab.renew_authority(2);self.inventory(2);self.lab.rehearse_exit('X01',2,*CUSTODIAN)
        self.invalid(self.lab.review_pack(2,REVIEWER[0],'forged'));self.counts(16,16,3)

    def test_stop_reason_inert_raw_character_bound(self):
        for bad in ('',' '*4,'x'*241,TextSubclass('reason'),True,None):
            before=self.lab.state();self.invalid(self.lab.stop_use(bad));after=self.lab.state()
            self.assertEqual((after['permissionVersion'],after['day'],after['mode']),(before['permissionVersion'],before['day'],before['mode']))
        self.assertEqual(self.lab.stop_use('$(no command) '+('é'*226))['status'],'WORK_STOPPED')
        version=self.lab.state()['permissionVersion'];self.lab.stop_use('x'*240)
        self.assertEqual(self.lab.state()['permissionVersion'],version+1);self.counts(0,0,0)

    def test_owner_one_shot_events_and_invalid_mutator_substance(self):
        self.stopped();self.lab.check_supplier('C01',2)
        before=self.lab.state();self.invalid(self.lab.apply_change('POLICY2','POLICY_OWNER','forged'))
        after=self.lab.state();self.assertEqual((after['permissionVersion'],after['policyRevision'],after['mode']),(before['permissionVersion'],before['policyRevision'],before['mode']))
        self.assertEqual(after['currentControlCount'],0)
        self.lab.apply_change('POLICY2',*OWNER);self.invalid(self.lab.apply_change('POLICY2',*OWNER));self.assertEqual(self.lab.state()['policyRevision'],2)
        self.lab.apply_change('WITHDRAW_R03',*OWNER);self.invalid(self.lab.apply_change('WITHDRAW_R03',*OWNER));self.assertEqual(self.lab.state()['eligibleOwnedRecordCount'],2)
        self.counts(1,1,0)

    def test_resume_requires_stopped_current_renewal_and_clears(self):
        self.lab.renew_authority(1);self.invalid(self.lab.resume_use(1));self.assertEqual(self.lab.state()['permissionVersion'],1)
        self.stopped();self.lab.check_supplier('C01',2);self.assertEqual(self.lab.resume_use(2)['status'],'WORK_RESUMED')
        s=self.lab.state();self.assertEqual((s['permissionVersion'],s['mode'],s['currentControlCount']),(3,'ACTIVE_REHEARSAL',0));self.assertIsNone(s['renewedVersion']);self.counts(1,1,0)

    def test_advance_day_exact_forward_and_no_retention_extension(self):
        self.lab.renew_authority(1);self.lab.check_supplier('C01',1)
        for day in (True,IntSubclass(3),'3',3.0,2,1,-4):
            self.invalid(self.lab.advance_day(day));self.assertEqual((self.lab.state()['day'],self.lab.state()['permissionVersion']),(2,1))
        self.lab.advance_day(50);self.assertEqual((self.lab.state()['day'],self.lab.state()['permissionVersion']),(50,2));self.invalid(self.lab.renew_authority(2));self.counts(1,1,0)

    def test_same_version_recheck_requires_fresh_review_not_rebuild(self):
        self.stopped();self.complete();self.lab.check_supplier('C01',2);self.counts(19,17,3)
        self.assertFalse(self.lab.state()['reviewPresent']);self.assertEqual(self.lab.state()['currentUseCount'],6)
        self.assertEqual(self.lab.review_pack(2,*REVIEWER)['status'],'INTERNAL_ASSURANCE_REVIEW')
        self.assertEqual(self.lab.export_pack(2)['status'],'INTERNAL_ASSURANCE_GAP_PACK');self.counts(21,17,3)

    def test_premature_export_after_recheck_clears_entire_inventory(self):
        self.stopped();self.complete();self.lab.check_supplier('C01',2);self.invalid(self.lab.export_pack(2));self.counts(19,17,3)
        s=self.lab.state();self.assertEqual((s['currentControlCount'],s['currentUseCount']), (0,0));self.assertFalse(s['exitPresent']);self.assertIsNone(s['renewedVersion'])
        self.lab.renew_authority(2);self.invalid(self.lab.review_pack(2,*REVIEWER));self.counts(19,17,3)

    def test_python_prebody_errors_preserve_entire_state(self):
        self.stopped();self.complete();before=self.lab.state()
        with self.assertRaises(TypeError):self.lab.export_pack()
        with self.assertRaises(TypeError):self.lab.check_supplier('C01',2,professionalApproval=True)
        with self.assertRaises(TypeError):self.lab.stop_use(reason='x',unknown='x')
        self.assertEqual(self.lab.state(),before)
        self.invalid(self.lab.export_pack(True));self.assertNotEqual(self.lab.state(),before);self.counts(18,16,3)

    def test_returned_state_control_exit_and_packet_deep_copies(self):
        self.stopped();result=self.lab.check_supplier('C01',2);result['control']['assertion']='caller change';result['actualFlags']['actualProvider']=True
        self.lab.renew_authority(2);packet=self.complete();expected=deepcopy(packet)
        packet['ownedRecords'][0]['body']='caller change';packet['scopedReview']['binding']['day']=999;packet['controls'].clear()
        state=self.lab.state();state['actualFlags']['actualProvider']=True
        again=self.lab.export_pack(2);self.assertEqual(again,expected);self.held(self.lab.state())
        exit_copy=self.lab.rehearse_exit('X01',2,*CUSTODIAN);exit_copy['ownedRecords'][0]['id']='R99'
        self.assertEqual(self.lab.review_pack(2,*REVIEWER)['status'],'INTERNAL_ASSURANCE_REVIEW')

    def test_internal_cached_evidence_tamper_fail_closed(self):
        self.stopped();self.complete();self.lab._controls['C01']['control']['owner']='invented'
        self.invalid(self.lab.review_pack(2,*REVIEWER));self.counts(18,16,3)
        self.lab.renew_authority(2);self.complete();self.lab._review['binding']['evaluationSequence']=0
        self.invalid(self.lab.export_pack(2));self.counts(36,32,6)

    def test_raw_whitespace_drift_completed_read_without_evaluation(self):
        self.lab.renew_authority(1);self.fixture.write_bytes(self.original+b' ')
        self.invalid(self.lab.check_supplier('C01',1));self.counts(1,0,0)
        self.assertIsNone(self.lab.state()['renewedVersion'])

    def test_missing_fixture_attempt_not_completed(self):
        self.fixture.unlink();self.lab.renew_authority(1);self.invalid(self.lab.check_supplier('C01',1));self.counts(0,0,0,attempts=1)

    def test_duplicate_keys_and_malformed_json_refused(self):
        for raw in (self.original.replace(b'"schemaVersion": 1',b'"schemaVersion": 1, "schemaVersion": 1',1),b'{',b'\xff',b'{"x": NaN}'):
            self.fixture.write_bytes(raw);self.lab.renew_authority(1);self.invalid(self.lab.check_supplier('C01',1))
        self.counts(4,0,0)

    def test_schema_type_id_dependency_and_body_drift_refused(self):
        baseline=json.loads(self.original)
        mutations=[lambda d:d.pop('notes'),lambda d:d.update(extra='authority'),lambda d:d['policy'].update(revision=True),lambda d:d['controls'][1].update(id='C01'),lambda d:d['uses'][0].update(requiredControls=['C06']),lambda d:d['records'][3].update(body='prohibited added body'),lambda d:d['records'][0].update(expiryDay=4),lambda d:d['records'][0].update(owner='OTHER')]
        for change in mutations:
            value=deepcopy(baseline);change(value);self.fixture.write_text(json.dumps(value),encoding='utf-8');self.lab.renew_authority(1);self.invalid(self.lab.check_supplier('C01',1))
        self.counts(8,0,0)

    def test_canonical_binding_and_exact_bool_schema(self):
        expected=deepcopy(self.m.EXPECTED_FIXTURE);wrong=deepcopy(expected);wrong['schemaVersion']=True
        self.assertFalse(self.m._identical(wrong,expected))
        self.lab._canonical_digest='0'*64;self.lab.renew_authority(1);self.invalid(self.lab.check_supplier('C01',1));self.counts(1,0,0)

    def test_review_and_export_recheck_source_raw_binding(self):
        self.stopped();self.inventory(2);self.lab.rehearse_exit('X01',2,*CUSTODIAN)
        self.fixture.write_bytes(self.original+b'\n');self.invalid(self.lab.review_pack(2,*REVIEWER));self.counts(17,16,3)
        self.fixture.write_bytes(self.original);self.lab.renew_authority(2);self.complete()
        self.fixture.write_bytes(self.original+b'\n');self.invalid(self.lab.export_pack(2));self.counts(36,32,6)

    def test_projection_occurrences_not_unique_records_or_export_copies(self):
        self.stopped();self.complete();self.lab.rehearse_exit('X01',2,*CUSTODIAN);self.counts(19,17,6)
        self.lab.review_pack(2,*REVIEWER);self.lab.export_pack(2);self.lab.export_pack(2);self.counts(22,17,6)

    def test_descriptor_bodies_absent_full_file_parsing_not_projection(self):
        data=json.loads(self.original);self.assertEqual([r['id'] for r in data['records'][3:]],['R04','R05','R06'])
        self.assertTrue(all('body' not in r and r['bodyOmitted'] is True for r in data['records'][3:]))
        self.lab.renew_authority(1);self.inventory(1);self.counts(15,15,0)
        self.assertTrue(all(r['body'] in self.original.decode() for r in data['records'][:3]))

    def test_held_evidence_is_retained_not_an_authority_failure(self):
        self.lab.renew_authority(1)
        self.assertEqual(self.lab.check_supplier('C04',1)['status'],'HOLD_UNKNOWN')
        self.assertEqual(self.lab.check_supplier('C06',1)['status'],'HOLD_UNSUPPORTED')
        self.assertEqual(self.lab.state()['currentControlCount'],2);self.assertEqual(self.lab.state()['renewedVersion'],1)
        for i in range(1,9):self.lab.check_supplier('C%02d'%i,1)
        self.assertEqual(self.lab.assess_use('U04',1)['status'],'HOLD_USE')
        self.assertEqual(self.lab.state()['currentUseCount'],1);self.counts(11,11,0)

    def test_fresh_child_reset_and_old_copy_survival(self):
        self.stopped();packet=deepcopy(self.complete());self.lab.apply_change('POLICY2',*OWNER);self.lab.apply_change('WITHDRAW_R03',*OWNER);self.lab.stop_use('parent stopped');self.lab.advance_day(5)
        code="from tallygate_lab import Tallygate; import json; print(json.dumps(Tallygate('ASSURANCE_ANALYST').state()))"
        env=os.environ.copy();env['TEMP']=str(self.folder);env['TMP']=str(self.folder)
        result=subprocess.run([sys.executable,'-B','-X','utf8','-c',code],cwd=self.folder,env=env,capture_output=True,text=True,timeout=20)
        self.assertEqual(result.returncode,0);child=json.loads(result.stdout);self.held(child)
        self.assertEqual((child['day'],child['permissionVersion'],child['policyRevision'],child['mode'],child['eligibleOwnedRecordCount']),(2,1,1,'ACTIVE_REHEARSAL',3))
        self.assertEqual((child['evaluationSequence'],child['physicalFixtureReadsCompleted'],child['projectedOwnedRecordOccurrences']),(0,0,0))
        self.assertEqual([r['id'] for r in packet['ownedRecords']],['R01','R02','R03']);self.counts(18,16,3)


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