Defence stores records for noncombat inventory

Learn in your browser · Chapter 01 of 08

Bound routine record reconciliation before opening information. A worksheet supports review and carries no purchasing or posting authority.

Fern is an invented training-centre storeroom containing pens, paper, chairs and cleaning cloths. The learner problem is a routine reconciliation request quietly acquiring wider authority: a tidy worksheet might be treated as permission to adjust stock, replace an item or buy supplies. The solution provided here is a scope card before reconciliation. It specifies the task, information, recipients, decision boundary and conditions for stopping. It is adult administrative education, with no real inventory, personal information or operational defence supply records.

AI can help organise descriptions and draft review notes, but fluent writing does not establish item identity or quantity accuracy. A confident paragraph might count the same receipt twice, interpret a carton using an assumed size or explain a variance as theft. None follows from the wording quality. Fern separates input eligibility, deterministic arithmetic and human interpretation. Its offline lab invokes no language model, places no order and changes no actual stock system. Proposed worksheets have a human-review requirement.

The task is training reconciliation: reconstruct a balance from supplied synthetic opening, receipt and issue records, compare it with a ledger, then present the difference. Reconciliation exposes disagreement; it does not decide which representation is correct. Proposed replenishment is a later paper exercise outside the lab purchasing boundary. Inventory adjustment is also a separate question. Write those exclusions as explicit action boundaries so a recipient cannot mistake a review worksheet for an instruction to post or procure.

Noncombat is a scope label for this fictional course, not a statement that every defence office record is harmless. Actual delivery schedules, locations, linked personnel, supplier details or stock levels may reveal sensitive relationships. Ordinary-item descriptions alone cannot classify a real dataset. Fern supplies only invented non-personal stationery, furniture and cloth records. Do not substitute a genuine stores export to make the lesson more realistic. Actual information classification, handling, jurisdiction and organisational authority remain qualified review dependencies.

Scroll sideways to see every column.

Apply permission before opening source content. A Fern request envelope must use a known code-owned proposal permission key, the matching item, training-reconciliation purpose, synthetic-nonpersonal information, exact current integer version and the code-owned source identifier for that item. Proposal fields cannot add supervisor approval or another source path. These bindings are teaching assumptions; the lab authenticates no real coordinator or reviewer. A source note cannot amend them.

Why gate metadata first? A failed request should not receive a worksheet or source preview merely to help diagnose failure. A proposal with a correct item description but an alternate path remains held. Reading the proposed path first would already cross the intended boundary. A useful error record explains the failed condition without copying denied source content. A source note saying ignore approvals stays passive data even if it appears inside an otherwise eligible record.

Reviewed JSP 936 Part 1, V1.1 November 2024, explicitly includes administrative and support AI and training about limitations, edge cases and reversionary working. It is MOD policy, not legislation or approval of this worksheet. Source: jsp936-dependable-ai.

Reviewed government classification policy has OFFICIAL, SECRET and TOP SECRET tiers, with local controls. Its OFFICIAL guidance includes routine information not intended for public release. This administrative policy does not classify Fern or authorise disclosure. Sources: gov-security-classifications and gov-working-official.

1. Name the specific reconciliation output and intended human reader.
2. List the supplied item classes and synthetic information boundary.
3. Record what the worksheet cannot do: order, substitute, adjust or control operational supply.
4. Check the exact envelope against code-owned permission metadata before a source read.
5. Record unresolved jurisdiction and actual classification/authority review separately.
6. Define a hold reason, responsible human and next evidence without inventing missing fields.

Worked paper example: a Fern training coordinator requests a paper-stock worksheet. The stated purpose is training-reconciliation and the information is synthetic-nonpersonal. However, the proposal supplies a new path copied from a supplier message instead of the item source identifier bound in the controlled permission. The paper result is HOLD, with no worksheet and no source access. Correct arithmetic from some other source would not repair the failed envelope. This example predicts the contract decision; it is not an observed runtime result.

A second request asks the same assistant to send an order because the ledger looks low. It changes both decision and action. Preserve the request in a review card, identify proposed replenishment as a separate paper discussion and decline to treat reconciliation as purchasing authority. Even an exact ledger match provides no basis for deciding stock thresholds, demand or procurement permission. A quantity worksheet solves a record-comparison problem, not every stores-management need.

Keep technical and contextual assurance separate. The finite lab can demonstrate arithmetic and state transitions when actually executed, while code-owned roles remain assumptions. It supplies no signed audit, real identity authentication, filesystem security, physical inventory validation or MOD compliance certification. A public source may help explain its own current scope, but cannot turn invented exercise permissions into actual organisational authority. Treat any unresolved real-use question as a named review task.

Write the final scope decision so another reader can reproduce the reasoning. Include requested item, bounded purpose, information category, envelope result, action limits and next owner. Use precise status words. READY_FOR_REVIEW means an eligible synthetic comparison can be inspected, not that the ledger should be changed. HOLD means no item worksheet is supplied. Recording a useful hold preserves the next decision without forcing the assistant to complete an unauthorised task.

Text equivalent: describe the reconciliation decision and its action limits; confirm the invented information scope; compare the exact request envelope with controlled metadata before reading content; return either a bounded human-review worksheet or a hold without an item worksheet.

Scroll sideways to see every column.

Text equivalent: Fern is a fictional civilian training-centre case using stationery, furniture and cleaning cloths. The scene illustrates a source-linked review worksheet, not a real defence site, stock count, purchase or posting authority.

Educational scope: Fern uses fictional civilian stationery, furniture and cleaning-cloth records. This course teaches bounded source comparison and knowledge assessment, not an approved MOD or organisational stores procedure. No qualified stores, security or procurement review has been completed. Do not use this lab or its role strings to process real stores records, classify information, place orders, post a ledger or claim operational competence. Real organisational use remains on hold until the actual information owner, current local procedures, applicable jurisdiction and authorised qualified reviewers have supplied their own approvals. Any checked educational release or knowledge certificate does not satisfy those requirements.

Learn in your browser · Chapter 02 of 08

A normalized number needs an exact item and an approved unit. Preserve the original fields so a reviewer can reproduce its meaning.

Fern stores staff need a quantity that means the same thing across sources. The learner problem is mistaking a familiar description or mathematically plausible conversion for approved item identity. The solution is an explicit item-and-unit register before arithmetic. Fern has four exact item IDs and integer unit factors. An assistant may help format the register, but descriptions, supplier notes and model knowledge cannot add IDs, change factors or approve substitutions.

Item identity answers which controlled thing is recorded. Unit identity answers how its quantity is expressed. Those questions must pass independently. A record could use the correct PEN-01 ID but an unsupported carton unit; another could say pen while carrying an unknown ID. Neither becomes valid because the expected number seems reasonable. Match exact IDs and approved units, then use the supplied factor to express the quantity in that item base unit.

Scroll sideways to see every column.

A factor is part of Fern fictional policy, not a fact about every product in the world. Two boxes of PEN-01 mean twenty each in this exercise. A carton of PAPER-01 means five reams, not a guessed number of sheets. Two packs of CLOTH-01 mean twelve each. CHAIR-01 has no approved box unit. Even if a supplier normally packs chairs in pairs, that description supplies no Fern conversion.

Preserve the original quantity and unit alongside the normalized quantity. A reviewer should see receipt 2 box, factor 10 and normalized 20 each rather than just twenty. This relationship distinguishes an arithmetic error from a source error or a conversion-policy change. Keep item identity attached to every normalized value. Adding twenty pens to twelve cloths produces a meaningless total unless a separately defined reporting purpose explains the aggregation.

Fern quantities must be positive integers whose type is exactly int. Boolean, floating-point and string values are held even when they resemble a useful number. In Python, bool is related to int, so a broad integer-type check can mistakenly accept true as one. The teaching contract instead requires exact type. The string 2 and float 2.0 do not become eligible through silent coercion. Hold the source record and ask for reviewed correction evidence.

This strict input rule is not a claim that all real stores records must use integer quantities. Some organisations handle fractions under different approved units and rules. The exercise supplies no such register. Its lesson is to make the representation contract explicit instead of allowing model guesses to decide. An unknown item, unsupported unit or substitution remains held until the responsible organisational process resolves it outside the current finite rules.

The official withdrawn JSP 886 collection establishes historical status: Defence Support Chain policy authority moved to the DLF in 2016. Archived unit or stores procedures cannot supply current authority here. Authenticated DLF contents were not reviewed. Source: jsp886-withdrawal.

1. Match the exact item ID against the code-owned four-item register.
2. Check that the unit belongs to that item, not merely to another item.
3. Require quantity type exactly int and a positive value; reject silent coercion.
4. Multiply the original quantity by the approved integer factor.
5. Retain item, original quantity/unit, factor, normalized value and source reference.
6. Hold unknown identity, unsupported units or proposed substitutions without inventing a conversion.

Worked paper example: Fern supplied pen records contain opening 20 each, receipt 2 box and issue 5 each. Normalize separately: opening 20 times 1 equals 20 each; receipt 2 times 10 equals 20 each; issue 5 times 1 equals 5 each. Reconstruct 20 plus 20 minus 5 equals 35 each. The ledger comparison is 35 each, so variance is zero. This is contract arithmetic worked on paper, not an observed lab run or proof that thirty-five pens physically exist.

Compare a tempting failure. An assistant treats box as an ordinary count and computes 20 plus 2 minus 5 equals 17. The result is numerically tidy but combines incompatible units. Another assistant guesses twelve pens per box and reports 39. Both errors are traceable by preserving original units and the approved factor. The reviewer can check the conversion before debating the ledger or any explanation of missing stock.

Substitution is a different decision from normalization. A product note might offer a larger paper carton or an equivalent cleaning cloth. Converting a known approved unit does not approve either replacement. Reconciliation asks what the supplied event records mean for the identified item. It does not decide fit, specifications, purchasing authority or whether another product can meet the same need. Keep those proposals outside the worksheet rather than rename the new product PAPER-01 or CLOTH-01.

Numeric precision can create false reassurance. Exact multiplication gives a reproducible result only if item, unit and source relationships are eligible. It does not authenticate the document, verify a physical count or show that all events were supplied. Record those limits next to the number so a later reader does not mistake a correct calculation for complete stores assurance. A zero variance is a comparison result within the supplied records, not proof of no error.

Text equivalent: match an exact registered item, verify its approved unit and positive exact-integer quantity, multiply by the supplied factor while preserving original fields, then review the normalized value. Unknown IDs, unsupported units and substitutions remain held.

Scroll sideways to see every column.

Learn in your browser · Chapter 03 of 08

An imported row is a representation of an event. Resolve exact document identity and source defects before comparing totals.

Fern receives imported source records, not a self-explanatory history of physical stock. The learner problem is confusing import rows with events: two copies of a receipt can look like two deliveries, while conflicting copies can be reduced to whichever row arrived last. The solution is event identity and source reconciliation before arithmetic. Preserve document references, validate all required fields and distinguish an identical repeat from a conflict. Do not solve disagreement by deleting inconvenient records.

A Fern source has documentId, itemId, kind, quantity, unit, verified and passive note fields. Kind is opening, receipt or issue. Quantity and units follow the approved register. Verified must be exact true, not a similarly spelled string or an inferred status. Incomplete or malformed records hold rather than disappear. The verified flag is a code-owned exercise assumption; it authenticates no real source or employee and proves no delivery occurred.

Document IDs identify an event across imports. Two equivalent copies carrying the same document ID are counted once. They remain traceable as repeated representations of one event. Same-ID copies with conflicting fields hold the item: the lab does not pick first, last, largest or most recent-looking wording. A repeated ID is therefore a reconciliation question, not an instruction to add every row or keep an arbitrary winner.

Scroll sideways to see every column.

Equivalent does not mean roughly the same description. Normalize quantities only after source eligibility, while duplicate identity concerns the supplied records and their fields. A note or quantity difference on the same event should not be ignored because the balance would otherwise match the ledger. Conversely, two independent deliveries can have the same quantity and item. Similarity alone cannot prove they are one event. Human review needs event relationships, not an assistant judgement that rows look repetitive.

Opening stock is special because it supplies the starting state. Fern holds an absent or nonunique opening, rather than assume zero or sum unrelated openings. Once identical import repeats have been resolved, there must still be one eligible opening for the item. A positive-looking result does not repair a missing starting state. The reviewer needs the proposed opening source and cut-off context before evaluating receipts and issues.

The reviewed section 46 records code addresses value, integrity and accountability, preserving technical and contextual information and authorised disposition. Its scope is relevant authorities in England, Northern Ireland and Wales, not a complete MOD stores manual or universal retention period. Source: tna-section46-records.

1. Confirm the request envelope before opening the item canonical synthetic source.
2. Validate required fields, kind, exact item identity, units, positive exact integers and verified exact true.
3. Group event representations by document ID and preserve source references.
4. Count equivalent same-ID copies once; hold conflicting duplicates rather than selecting a winner.
5. Check for one eligible opening and reconstruct the normalized balance.
6. Present deduplicated source references and unresolved record concerns for human review.

Worked paper example: the supplied cloth history has opening 12 each and receipt 2 pack imported identically twice. Pack factor 6 makes the receipt 12 each. Both receipt copies describe the same document event, so opening 12 plus one normalized receipt 12 equals 24 each. The ledger also records 24 each, giving variance zero. Counting both imports would produce 36 each, an invented second receipt. This calculation is from the written contract, not an observed executable result.

In a separate illustrative paper case, two copies of one cloth receipt document disagree: one says 2 pack and the other 3 pack. Do not choose 2 because it matches the ledger, or 3 because it arrives later. The record conflict precedes balance comparison and holds the item. Preserve both quantities and their source relationship, name the assumed reviewer and request source-linked resolution. An attractive balance cannot decide document identity.

Consider a second failure: an assistant silently drops an unverified issue because excluding it produces agreement. The final number hides a material input defect. Fern instead holds incomplete or malformed records. The review queue must show what failed and why, without generating an item worksheet that appears complete. A failed record is information about the reconciliation state, not disposable noise. Keep its effect visible in the disposition.

A reconstructed balance uses eligible opening plus receipts minus issues in base units. Negative balance is a hold condition, not a negative stock order. It may indicate missing records, a wrong starting point or another unresolved problem. The exercise does not choose a cause. Separating validation, duplicate resolution and arithmetic lets a reviewer see which stage failed instead of treating every problem as a numerical variance.

Traceability should survive a readable summary. List the deduplicated event references that support the worksheet and identify its revision. A phrase such as all sources reconciled is too broad if it conceals held items or omitted inputs. State the covered item and supplied source set. The lab sources are fabricated; public policy sources, if reviewed separately, have different evidential roles. Neither should be presented as an authenticated real stores transaction.

Text equivalent: validate the supplied source fields before arithmetic. Group representations by event document ID, count equivalent repeated copies once and hold conflicts. Confirm one eligible opening. Only then reconstruct the balance with deduplicated source references for human review.

Scroll sideways to see every column.

Learn in your browser · Chapter 04 of 08

A numerical difference is a question for review. Preserve its sign, source relationships and uncertainty before considering correction.

Fern paper stock exposes an apparent shortage in reconstructed records. The learner problem is treating a difference as a diagnosis: minus two reams might be reported as loss, misconduct or an instruction to change the ledger. The solution is a variance and uncertainty card. State the arithmetic, distinguish representations from physical observations, list competing explanations and require source-linked review before any correction. The worksheet supports a decision; it does not make the decision.

Use one sign convention consistently: variance equals reconstructed balance minus ledger quantity. A negative value means reconstructed records show less than the ledger, not that a theft or missing delivery occurred. A positive value means they show more. Keep the base unit in every comparison. A difference between twelve reams and fourteen reams is meaningful; a subtraction between reams and cartons without approved normalization is not.

For the supplied paper history, opening 10 ream plus receipt 1 carton times factor 5 minus issue 3 ream gives 12 ream. The ledger is 14 ream, so variance is 12 minus 14 equals -2 ream. This is an unapproved suggested correction context, not an automatic posting. The supplied pen, chair and cloth reconstructed quantities agree with their ledgers. These are worked contract calculations, not claims that the runtime has been executed.

Scroll sideways to see every column.

Competing explanations include a missing transfer, incorrect issue quantity, damaged stock handled differently, a count error or different cut-off times. Listing them does not assert any occurred. Write unknown beside each unsupported event rather than assign a probability from intuition. The finite source set cannot establish a causal explanation or complete stock movement history. A missing document is a question for review, not permission to manufacture a balancing receipt.

A physical count is another observation with scope and limitations. It needs a stated item, approved unit, time, counting method and reviewer context before comparison. A later count can differ because movement occurred after the record cut-off. A count agreeing with the ledger does not automatically disprove a source event; agreeing with reconstruction does not automatically authorise adjustment. Fern supplies no physical stock and validates no count, so any classroom count scenario must be labelled invented paper evidence.

Uncertainty can be recorded precisely without pretending to be numerical. Distinguish known arithmetic, missing context, unverified hypothesis and required review. A range should have a defensible basis; do not turn two disagreeing totals into a statistical confidence interval. Twelve and fourteen are competing representations, not a sample distribution. Useful next evidence narrows a specific question, such as whether an issue document was entered with the wrong quantity.

The reviewed NIST AI RMF offers voluntary GOVERN, MAP, MEASURE and MANAGE functions for iterative risk review. They can organise uncertainty and review ownership, but supply no correction authority, physical validation or MOD certification. Source: nist-ai-rmf.

1. Confirm item, normalized units, eligible source references and ledger comparison.
2. Show reconstructed calculation and variance sign explicitly.
3. Separate supplied records from any physical-count observation.
4. List competing explanations as hypotheses with missing evidence and cut-off questions.
5. Propose correction only from separately supplied source-linked review evidence, with current role/version conditions.
6. Preserve old/new values and reason; recompute, invalidate old permissions and require explicit renewal before another read.

Worked paper example: an invented reviewer inspects separate correction evidence and confirms that the paper issue source should record 1 ream rather than 3. This is an additional paper scenario, not a fact supplied by the original history. The proposed replacement is a positive exact integer on the known issue document, using the assumed correction role and exact current version. Recompute 10 plus 5 minus 1 equals 14 ream. The arithmetic explains the proposal; it does not grant permission to execute it.

Under the contract, an accepted separate correction records old quantity, new quantity and reason, advances version, recomputes the source and invalidates worksheets and permissions. The assumed coordinator must renew current permissions explicitly. An old worksheet must not remain usable merely because its item is unchanged. Resumption after suspension likewise does not silently renew stale permission. This teaches an in-memory transition, without signed audit, durable storage or distributed revocation assurance.

Contrast an unsafe shortcut: the assistant sees -2 and posts +2 to the ledger. It has chosen a representation, invented adjustment authority and hidden uncertainty. Another shortcut adds a fictional transfer to make totals agree. Neither preserves correction evidence. A proper variance card records the discrepancy and responsible reviewer, explains what evidence would change the decision and leaves replenishment separate. A discrepancy is not a demand forecast or approved order.

Human review is more useful when it can disagree. Show the original source-linked calculation, the proposed replacement evidence and what remains unresolved. A reviewer unable to inspect those relationships cannot meaningfully decide from a polished conclusion alone. Keep a hold available when evidence is incomplete. The finite lab roles are assumptions, so its correction operation does not authenticate a person or authorise an adjustment in any real organisation.

Text equivalent: compare reconstructed and ledger quantities in the same unit, record uncertainty and competing explanations, obtain separate source-linked correction evidence, then recompute through the controlled correction operation. Version changes invalidate prior worksheets and permissions, which need explicit coordinator renewal.

Scroll sideways to see every column.

Text equivalent: The supplied fictional factors are ten pens per box, five paper reams per carton and six cloths per pack; chairs use each only. Reconstructed minus ledger paper quantity is 12 - 14 = -2 reams. This is a review discrepancy, not proof of loss or authority to purchase, correct a ledger or certify physical stock.

Learn in your browser · Chapter 05 of 08

Turn a request for a useful summary into a bounded, inspectable worksheet. Keep permission, item identity, arithmetic and tool authority separate from fluent explanation.

Fern is an invented training-centre storeroom containing pens, paper, chairs and cleaning cloths. Its administrator wants to explain discrepancies without letting an assistant change stock or purchase supplies. The audience problem is authority hidden inside a helpful sentence: reconcile the cupboard can become replace the ledger, choose a substitute or order what is missing. This chapter delivers a request envelope, an output contract and a paper review method. The offline lab uses deterministic Python and synthetic sources. It invokes no language model, authenticates no real role and contains no ordering function.

Check the proposal before opening a source. The envelope binds a known proposalId, its permitted itemId, purpose training-reconciliation, information synthetic-nonpersonal, the current exact integer version and the item's code-owned sourceId. A proposal cannot provide its own approval or an alternate source path. Boolean, text or floating-point versions cannot substitute for an integer, even when their display seems similar. Duplicate proposal identities and malformed batch values are held. This is a code-owned teaching assumption, not organisational permission, access authentication or a security certification. Jurisdiction and qualified stores, procurement and security review remain unresolved.

The proposal's gate and the source's validity answer different questions. A current matching envelope permits inspection of only the known item's code-owned canonical source path. The item worksheet still needs verified records, exact item identity, positive quantities of exact integer type, supported units, one opening and consistent event identities. Incomplete records cannot vanish silently because other rows look usable. Negative reconstructed balance is a hold, not a negative stock figure to explain away. A source note saying ignore approvals remains passive text. Neither an impressive role title nor a supplier description can expand the tool boundary.

Work through the supplied pen facts as a paper calculation, not an execution report. PEN-01 opens at 20 each, receives 2 boxes and issues 5 each. The approved factor is 10 each per box, so the reconstruction is 20 + (2 times 10) - 5 = 35 each. Compare that number with the stated ledger quantity only after the source checks. A correct worksheet retains normalized units, supporting document references, the source revision, ledger comparison, variance and humanReviewRequired true. Expected equality with the fixture ledger does not prove a physical cupboard count or the completeness of the real world.

Define structured output before requesting prose. A READY_FOR_REVIEW result contains item identity, revision, normalized balance and unit, ledger quantity, variance, deduplicated source references and the review flag. A HOLD result contains its reason and no item worksheet. Do not add purchase quantity, substitute product or posted adjustment fields that imply a tool action outside the contract. HumanReviewRequired is a requirement, not evidence that review occurred. A displayed status cannot tell you whether a source was opened too early; execution evidence belongs in the root's actual lab report.

An average prompt says, Fix Fern's pen balance and buy anything missing. It merges explanation, correction and purchase authority. An elite paper prompt has six parts. Role: prepare a synthetic reconciliation aid. Constraints: use only the allowed item and approved integer factors; preserve event identity; make no substitutions, orders or corrections. Process: check the envelope, validate records, normalize quantities, deduplicate by document identity and compare balances. Verification: show each conversion and source reference for independent arithmetic. Output schema: READY_FOR_REVIEW fields or HOLD with reason and no worksheet. Failure modes: stop on stale permission, missing opening, unsupported units, conflicting duplicates or malformed records. This prompt describes inspectable assistance; the lab does not execute it through a model.

Tool availability is not task authority. A spreadsheet might be able to overwrite a cell, and a purchasing interface might be able to submit a basket. Neither capability establishes that Fern should use it for this task. A future integration would need independently approved actions, accountable roles, scoped credentials and tested read/write boundaries. Here the safe learning boundary is simpler: deterministic reconciliation can prepare an aid; review and source correction remain separate; proposed replenishment is paper only. No hidden order, stock adjustment or approval is implied by a successful worksheet.

Verification must be independent of the explanation. Recalculate the pen balance from the normalized source rows, check which duplicate events were counted once and compare the worksheet with its actual revision. If a fluent paragraph says 45 each while the rows support 35, hold reliance on the paragraph and document the mismatch. Do not let a second polished sentence vote on the first. Record the discrepancy, the representation inspected and the next reviewer. Distinguish expected arithmetic from observed runtime output. The delivered solution is a reviewable boundary and reasoning method, not evidence of model accuracy or MOD clearance.

Text equivalent: check the request envelope against current code-owned permission before reading the source. If it passes, validate item identity, units, opening, records and event identities, then calculate. Valid records produce a review-required worksheet. Invalid records produce a hold reason and no item worksheet. Neither path can place an order or silently correct stock.

Scroll sideways to see every column.

Learn in your browser · Chapter 06 of 08

Separate explanation of a discrepancy from source correction and any proposed replenishment. Give each review a defined object, authority boundary and consequence.

Fern's paper worksheet reconstructs 12 reams while the supplied ledger states 14. The variance is -2 reams. A tempting shortcut is to call that a shortage and order two more reams. The number actually describes disagreement between representations. It does not establish physical loss, misconduct, a lawful adjustment or reorder need. This chapter delivers a discrepancy review card and a separate paper replenishment proposal. Its purpose is to keep accountable decisions visible when a useful calculation encourages an unsupported action.

Recalculate the paper example independently. PAPER-01 opens at 10 reams, receives one carton with an approved factor of five reams per carton, and issues three reams. The reconstruction is 10 + 5 - 3 = 12 reams. Subtract the ledger's 14 to obtain -2. These are expected facts under the supplied teaching contract, not reported runtime observations or a physical count. Before interpreting them, inspect source completeness, event identities, opening uniqueness, verified status and cut-off context. A convincing worksheet cannot settle what is absent from its inputs.

The review card has five fields: representation and revision inspected, arithmetic and event checks performed, unresolved questions, decision with reasons, and next owner. Questions may include a missing transfer, an unrecorded receipt, timing between ledger and count, damaged stock or a transcription discrepancy. Each is a question, not an invented transaction. If no physical count is supplied, record physical quantity unknown. Do not turn the model's suggestion into evidence by putting it in a source-shaped row. Preserve the existing discrepancy until supported correction or authorised clarification changes the representation.

Segregation of duties is a proposed organisational control that separates incompatible responsibilities so one person does not silently initiate, verify and approve their own change. In Fern, the code-owned correction role and assumed coordinator have distinct exercise functions. The reviewer can perform a separate authorized source correction operation; the coordinator explicitly renews permissions after a version change. These strings are not authenticated people. The lab does not demonstrate real independent oversight. A genuine design needs the organisation to define responsibilities, substitutes, conflicts and escalation, with selected jurisdiction and qualified stores, procurement and security review.

A permitted source correction needs an exact current version, the assumed correction role, a known source document and a positive integer replacement quantity. It revises the source and recomputes the balance; it is not a direct ledger posting to whichever value looks convenient. The exercise audit records old and new quantities and a reason. Version increments, worksheets invalidate and previous permissions become stale. The coordinator must renew them explicitly. A request to make the balance agree with 14 without supporting a source correction is insufficient. An equality target is not evidence that a source value should change.

Make proposed replenishment a different paper document. It states the routine noncombat item, approved unit, verified basis for need, requested quantity, existing commitments if known, uncertainty, proposed reviewer and approval dependencies. It must distinguish a documented need from a variance question. An unknown incoming order remains unknown, rather than assumed zero. Supplier descriptions cannot substitute a different item or alter the approved unit factor. If evidence of need is missing, the proposal stays incomplete or held. There is no purchasing function in this lab, and no paper approval causes an order.

Compare two prompts. Average: Paper is short by two, so order two cartons and fix the ledger. It confuses reams with cartons, discrepancy with shortage and calculation with authority. Elite: role, draft a paper review aid; constraints, use exact PAPER-01 units and supplied verified sources, invent no count or transfer, make no posting or order; process, recalculate, separate explanations from facts, then assess whether a replenishment proposal has enough evidence; verification, independently check conversion, event identity and revision; schema, discrepancy card and a distinct incomplete-or-proposed replenishment card; failure modes, hold stale permission, missing basis, unsupported substitutions and unresolved quantity units. A disciplined prompt helps inspection but grants no correction or purchase authority.

A meaningful reviewer must see the actual worksheet and supporting sources, have relevant knowledge and be able to stop or change reliance. Record what they checked rather than only a signature-like label. Their review of arithmetic does not settle physical stock, supplier commitment or procurement approval. If the person preparing a proposal also performs a check, disclose that arrangement and obtain the organisation's required independent approval. This workbook sets no universal approval threshold or procurement law. Its fictional control method cannot certify a real defence organisation's compliance or authorise sensitive supply operations.

The practical worked outcome is bounded: retain -2 as an unresolved paper variance, ask for authorised source/count and timing clarification, and hold replenishment pending evidence of need and appropriate organisational approval. If a supported source correction is supplied later, name its document and revision, recompute, and renew stale permissions through the separate coordinator. Never relabel an unrun correction as completed. The learner should be able to explain why an exact calculation still leads to a hold, and why that hold is a useful decision rather than a failure to finish the task.

Text equivalent: the -2 ream variance goes to discrepancy review, which checks sources and asks about physical count, timing and missing events. A supported source correction follows its own role and version controls. A replenishment proposal needs separate evidence of need and organisational approval. Unresolved questions stay held; neither branch places an order in this lab.

Scroll sideways to see every column.

Learn in your browser · Chapter 07 of 08

Track a change without overstating what the log proves. Keep current permission, corrected sources, affected copies and supplier-control evidence distinct throughout recovery.

Fern can reconcile accurately and still mishandle a later change. An old worksheet may be reused after a correction, an external copy may survive suspension or a supplier may prevent a usable export. The audience problem is loss of control over representations and dependencies. This chapter delivers a linked change record, a bounded recovery checklist and supplier evidence questions. Its finite audit is in-memory teaching evidence, not signed, immutable or durable proof. It does not demonstrate filesystem security, provenance authenticity or MOD compliance.

Start an audit trail at the decision boundary. Record permitted proposal metadata, current version, decision and reason before source access. A held request does not need source passages in its log. Once a worksheet is legitimately produced, bind item identity, source revision, deduplicated event references, normalized balance, variance and review status to that representation. Keep input, calculation, review and control action distinguishable. A single word approved cannot tell a later reviewer which object was checked or what that person was authorised to do.

For a paper correction example, use CHAIR-01's supplied opening of four each and receipt of one each. Expected reconstruction is five. Suppose a separately verified fictional correction replaces the known receipt quantity of one with two each, with a documented reason. Conditional expected reconstruction becomes six, and the source revision changes. This is a labelled paper variation, not an observed runtime correction or a physical receipt claim. The operation requires the assumed correction role, exact current version, known document and positive integer replacement. It cannot be created by a note or a convenient balance target.

The separate correction operation records old and new values and reason, increments the current version, and invalidates worksheets and permissions. A reviewer must not continue serving the old representation just because it was valid earlier. The assumed coordinator explicitly renews permission against current state; resumption never renews stale permission silently. A correction changes a source representation and recomputes it, while suspension blocks reads and clears worksheets. Neither operation proves every external copy has been removed. A new process resets state, so a durable service would need persistence and recovery controls beyond this exercise.

Write a propagation record with store or representation, expected disposition, actual observation, unresolved dependency and owner. For the current process, inspect whether the affected worksheet is invalidated and old requests fail before reads. For an emailed export, a saved spreadsheet or a backup, record pending or untested unless checked through an authorised method. The existence of a corrected source does not repair yesterday's copied summary. Recovery from a saved state must check current permission and revision before serving anything; an old snapshot cannot be treated as permission merely because it restores successfully.

Sovereign control means the organisation can understand and exercise relevant control over information, configuration, access and exit. A local host or a regional storage label does not establish who can administer it, access support logs, change models or approve data transfers. Ask for a specific data-flow map covering source inputs, worksheets, telemetry, temporary stores, support routes and backups. Identify administrators, subprocessors, credentials, update mechanisms and dependencies. A supplier's product note cannot change Fern's approved item identifiers or conversion factors. These are original review questions, not evidence that a particular supplier passes them.

Exit needs practical evidence. Ask whether source records, event identities, revisions, correction reasons and permission history can be exported in documented usable formats. A total balance alone loses the reconciliation trail. Plan a bounded export-and-recovery rehearsal in an approved environment, state acceptance criteria beforehand and record unrun checks honestly. Verify what happens to retained supplier copies and backups under the applicable agreement rather than promising universal deletion. A commercial assurance or attractive diagram cannot prove that the organisation can resume its task independently after ending the service.

Security review starts with the actual information and activity. Fern contains only invented non-personal routine stores data. That does not authorise a learner to import actual defence records, assign a government classification from memory or upload sensitive supply information. Jurisdiction and qualified stores, procurement and security review remain unresolved. A future implementation needs authenticated roles, scoped access, source integrity, safe restoration and an accountable incident route. This lab's code-owned roles and fixed sources illustrate the separation of responsibilities; they are not tested production safeguards or complete organisational policy.

Compare an average instruction, Delete the old records and prove the supplier is sovereign, with an elite paper review prompt. Role: prepare an accountable change and exit handover. Constraints: inspect only permitted metadata and synthetic representations, preserve correction history, make no deletion or transfer outside approved scope. Process: trace source revision, invalidate old use, list copies and supplier dependencies. Verification: check actual version and export evidence independently. Schema: change, representation, owner, expected disposition, observation and unresolved issue. Failure modes: stop on stale permission, incomplete propagation or unsupported supplier claims. Prompt detail makes missing evidence visible; it cannot supply security authority.

Mickai could propose a scoped engagement covering data inventory, digitisation quality, supplier-control mapping, permission design, correction propagation and an exit rehearsal. Confirm delivery capability, organisation agreement, selected jurisdiction and qualified review before presenting that as an available defence service. The actual solution in this unit is private education and a synthetic finite lab contract. No live sovereign stores platform, measured digitisation system or completed procurement assurance is claimed. Naming the gap allows a useful service discussion to begin with evidence rather than with an unsupported promise.

Text equivalent: a separate supported source correction records old and new values and reason, then increments version and invalidates prior worksheets and permissions. Coordinator renewal must be explicit. A copy and exit register separately tracks local state, exports, supplier stores and backups. The handover states actual observations and pending or unrun checks without claiming durable audit or universal removal.

Scroll sideways to see every column.

Learn in your browser · Chapter 08 of 08

Deliver a reconciliation pack that another learner can inspect. Explain its limits, respond to stale information and prepare for knowledge assessment without claiming operational competence.

Fern's capstone asks you to reconcile routine invented stores records while keeping sensitive supply operations outside scope. The problem is not simply obtaining four totals. It is showing which sources and permissions support them, what remains uncertain and which actions the exercise cannot take. Deliver a linked learning pack, then rehearse a stale-copy incident and teach back your decisions. The course author attribution is Mickarle Sean Junior Wagstaff-Irons - Micky Irons, with AI assistance disclosed for teaching material. This identifies educational authorship, not defence credentials, MOD endorsement or personal operational experience.

Begin with a scope card: adult training, Fern's four noncombat items, synthetic non-personal information, training-reconciliation purpose and selected or unresolved jurisdiction. Exclude actual inventory, operational supply data and supplier credentials. Identify qualified stores, procurement and security review as outstanding. Record the exact supplied fixture and policy version when root provides them. Never invent an actual run, source hash or authenticated supervisor.

Your first deliverable is the proposal register. Bind each actual proposal identity to permitted item, purpose, information, current exact version and code-owned source. Show expected, observed and unrun columns. A malformed or stale request stays held before source reading; no proposal approves itself or chooses another path. A valid request still needs source-record validation. Hold unknown items, unsupported units, substitutions, noninteger quantities, inconsistent duplicates, missing or nonunique opening and negative reconstructed balance. Do not omit malformed rows to keep the display tidy. Root owns final runnable identifiers and observations.

The second deliverable is the reconciliation pack. The supplied paper contract predicts PEN-01 at 35 each; PAPER-01 at 12 reams against ledger 14, variance -2; CHAIR-01 at five each; CLOTH-01 at 24 each after one repeated import of the same receipt is counted once. Derive each with approved unit factors and source-event references. Identical document identity means one event, not two deliveries. A conflicting repeat would hold the item instead. These expected results are not physical counts or observations of code. Each review worksheet must identify its source revision and retain humanReviewRequired true.

The third deliverable is the discrepancy and correction register. Preserve paper's unexplained -2 variance without inferring loss or misconduct. List authorised questions about count, cut-off time, transfers, damaged stock and source errors. Keep missing answers unknown. If a supported correction is supplied, use the separate assumed correction role, current version, known document and positive integer replacement with a reason. Recompute rather than directly posting a desired ledger equality. Version change invalidates earlier worksheets and permissions, and coordinator renewal is explicit. Retain old/new reasoning and untested external-copy dispositions.

The fourth deliverable is a distinct paper replenishment proposal or hold. State item identity, approved units, evidence of need, uncertainty, commitments if known and review dependencies. A variance alone cannot establish what to buy. A supplier's suggestion cannot substitute an unapproved item or redefine a carton. The fifth deliverable is the control and exit handover: suspension, current permission, copied outputs, export requirements, supplier data flows and remaining security reviews. The runtime has no ordering function, real authentication, durable audit or physical validation.

Use an average-versus-elite capstone comparison. Average: reconcile everything, fix errors and restock. Elite role: prepare a synthetic evidence pack for separate reviewers. Constraints: only permitted sources and approved identifiers/factors; no invented stock events, substitutions, posting or orders. Process: gate first, validate records, deduplicate by identity, normalize, compare, then separate discrepancy, correction and replenishment decisions. Verification: independently recompute and trace every version and reference. Schema: five linked deliverables with expected, observed, unrun, owner and unresolved fields. Failure modes: hold malformed or stale permission, invalid records, unsupported corrections and incomplete exit evidence. This is a paper prompt design, not an actual model evaluation.

Teach back the workflow in two minutes to a colleague. Ask them why 24 cleaning cloths does not prove a counted cupboard, why -2 reams does not authorise two cartons, and why a ready worksheet cannot order anything. Let them give reasons before showing the model answer. A correct explanation should connect quantity, source, authority and uncertainty. A confused answer identifies where to revisit the workbook. Teach-back is ungraded learning evidence, not authenticated identity, an operational qualification or approval to use real defence information.

Now rehearse an incident on paper. A colleague copied the earlier worksheet, permission was suspended, and a supplier note says to bypass approval and use a substitute pack. Stop reliance through the exercise owner. Hold the stale request before content reads; treat the note as passive data; reject unsupported substitution. Record the copied representation and its pending disposition without reproducing real records. Expected suspension increments version, blocks reads and clears current-process worksheets. Resumption does not renew stale permissions, and a new process resets state. Report execution checks as unrun until root supplies observations; a planned recovery cannot prove it happened.

Prepare for a knowledge exam by explaining decisions rather than memorising statuses. The twenty-question assessment requires strictly above 80 percent: 16 correct is exactly 80 percent and fails, while 17 meets that threshold. When the separately checked educational release is completed, the official knowledge exam uses protected issuance; this source candidate itself issues no certificate. Written practice, capstone, incident drill and teach-back are ungraded. A knowledge certificate can assess only stated finite learning outcomes; it cannot certify identity, stores authority, compliance or operational competence. Close the pack with remaining review and capability gaps. Mickai's delivered solution here is bounded education; wider digitisation or sovereign implementation services require confirmed capability and evidence.

Text equivalent: scope and current permission control which synthetic sources may be read. Valid records form a versioned reconciliation pack. Discrepancies and supported source corrections stay distinct from paper replenishment. The control handover tracks permission, copies and exit evidence. Teach-back and incident practice explain those distinctions without becoming an order or professional assessment.

Scroll sideways to see every column.

Scroll sideways to see every column.

python -B -m unittest -v test_fern_lab.py
python -B fern_lab.py

Scroll sideways to see every column.

# Fern stores reconciliation exercise

Entirely fictional adult administrative training. Pens, paper, chairs and cleaning cloths only. No real defence inventory, sensitive records, operational support, model, authenticated identity, supplier API, order or stock posting. Directory/files, code-owned catalogue, reviewer roles and verification flags are teaching assumptions. They are not tamper-resistant evidence or MOD permission.

Keep all files together, including the sources subfolder. Use Python 3.10 or later with the standard library. No installation or paid service is needed. On Windows, point TEMP and TMP to a chosen local training folder if required; this programme runs them on M.

```
python -B -m unittest -v test_fern_lab.py
python -B fern_lab.py
```

The first four fixture requests propose worksheets; the remaining eight intentionally fail the envelope gate. Follow document IDs, approved unit factors, normalized balances and comparison variances. A worksheet is READY_FOR_REVIEW, not approved inventory or a purchasing action. The duplicate CLOTH receipt counts once. The PAPER discrepancy is an investigation lead, not proof of loss. Source notes cannot alter the catalogue or authorise actions.

Try a conflict between duplicate document records, an unsupported unit, bool quantity, missed opening, negative balance or request source substitution. Expect a visible hold without a valid worksheet. Do not silently drop bad records and publish the remaining total. Gates prevent the finite request defects before their source reads; they are not a general filesystem, prompt-injection or adversarial model security mechanism.

Separate assumed correction example, after examining fictional source evidence:

```python
from fern_lab import Fern
lab = Fern()
lab.correct('training-reviewer', 1, 'PAPER-01', 'Q-I1', 1,
            'Training reviewer verified the fictional issue slip')
# All worksheets clear and permissions become stale after the new version.
lab.renew_permissions('training-coordinator', 2)
```

This only changes the current process's training memory and appends an in-memory old/new audit event. It never changes the source JSON or a real ledger. No action is accepted because a supplier or prompt claims to approve it. Both roles are plain assumed code-owned strings, not authenticated separation of duties. A new process resets source cache, version, audit and policy. Suspension blocks the finite gate; resumption requires explicit permission renewal. There is no durable/distributed revocation, cryptographic provenance, physical count or qualified procurement/security clearance. The replenishment and capstone exercises are reviewed paper designs, not purchasing functions in this code.

{
  "requests": [
    {
      "proposalId": "R-01",
      "itemId": "PEN-01",
      "purpose": "training-reconciliation",
      "information": "synthetic-nonpersonal",
      "version": 1,
      "sourceId": "pens"
    },
    {
      "proposalId": "R-02",
      "itemId": "PAPER-01",
      "purpose": "training-reconciliation",
      "information": "synthetic-nonpersonal",
      "version": 1,
      "sourceId": "paper"
    },
    {
      "proposalId": "R-03",
      "itemId": "CHAIR-01",
      "purpose": "training-reconciliation",
      "information": "synthetic-nonpersonal",
      "version": 1,
      "sourceId": "chairs"
    },
    {
      "proposalId": "R-04",
      "itemId": "CLOTH-01",
      "purpose": "training-reconciliation",
      "information": "synthetic-nonpersonal",
      "version": 1,
      "sourceId": "cloths"
    },
    {
      "proposalId": "R-05",
      "itemId": "PENCIL-01",
      "purpose": "training-reconciliation",
      "information": "synthetic-nonpersonal",
      "version": 1,
      "sourceId": "pens"
    },
    {
      "proposalId": "R-06",
      "itemId": "PEN-01",
      "purpose": "place-order",
      "information": "synthetic-nonpersonal",
      "version": 1,
      "sourceId": "pens"
    },
    {
      "proposalId": "R-07",
      "itemId": "PEN-01",
      "purpose": "training-reconciliation",
      "information": "synthetic-nonpersonal",
      "version": true,
      "sourceId": "pens"
    },
    {
      "proposalId": "R-08",
      "itemId": "PEN-01",
      "purpose": "training-reconciliation",
      "information": "synthetic-nonpersonal",
      "version": 1,
      "sourceId": "../../outside"
    },
    {
      "proposalId": "R-09",
      "itemId": "PEN-01",
      "purpose": "training-reconciliation",
      "information": "actual-sensitive",
      "version": 1,
      "sourceId": "pens"
    },
    {
      "proposalId": "R-10",
      "itemId": "PEN-01",
      "purpose": "training-reconciliation",
      "information": "synthetic-nonpersonal",
      "version": 1,
      "sourceId": "pens",
      "approved": true
    },
    {
      "proposalId": "R-11",
      "itemId": "PEN-01",
      "purpose": "training-reconciliation",
      "information": "synthetic-nonpersonal",
      "version": 1,
      "sourceId": "pens"
    },
    {
      "proposalId": "R-12",
      "itemId": "PAPER-01",
      "purpose": "training-reconciliation",
      "information": "synthetic-nonpersonal",
      "version": 1,
      "sourceId": "paper"
    }
  ]
}

"""Original fictional Fern stores teaching lab. No model or real inventory action."""
import copy
import json
from pathlib import Path

CATALOGUE = {
    'PEN-01': {'base': 'each', 'units': {'each': 1, 'box': 10}, 'ledger': 35},
    'PAPER-01': {'base': 'ream', 'units': {'ream': 1, 'carton': 5}, 'ledger': 14},
    'CHAIR-01': {'base': 'each', 'units': {'each': 1}, 'ledger': 5},
    'CLOTH-01': {'base': 'each', 'units': {'each': 1, 'pack': 6}, 'ledger': 24},
}
SOURCES = {'PEN-01': 'pens', 'PAPER-01': 'paper', 'CHAIR-01': 'chairs', 'CLOTH-01': 'cloths'}
PERMISSION_ITEMS = {
    'R-01': 'PEN-01', 'R-02': 'PAPER-01', 'R-03': 'CHAIR-01', 'R-04': 'CLOTH-01',
    'R-05': 'PEN-01', 'R-06': 'PEN-01', 'R-07': 'PEN-01', 'R-08': 'PEN-01',
    'R-09': 'PEN-01', 'R-10': 'PEN-01', 'R-12': 'PEN-01',
}
REQUEST_FIELDS = {'proposalId', 'itemId', 'purpose', 'information', 'version', 'sourceId'}
RECORD_FIELDS = {'documentId', 'itemId', 'kind', 'quantity', 'unit', 'verified', 'note'}

def text(value):
    return type(value) is str and bool(value.strip()) and len(value) <= 400

def balance(records, item):
    """Reject missing/malformed evidence, deduplicate exact document identities."""
    if type(records) is not list or not records:
        raise ValueError('nonempty record list required')
    if item not in CATALOGUE:
        raise ValueError('unknown item')
    unique = {}
    duplicate_ids = []
    for row in records:
        if type(row) is not dict or set(row) != RECORD_FIELDS:
            raise ValueError('record fields do not match')
        if not text(row['documentId']) or row['documentId'] != row['documentId'].strip():
            raise ValueError('exact nonblank document ID required')
        if type(row['itemId']) is not str or row['itemId'] != item:
            raise ValueError('item identity mismatch')
        if type(row['kind']) is not str or row['kind'] not in {'opening', 'receipt', 'issue'}:
            raise ValueError('unknown record kind')
        if type(row['quantity']) is not int or not 0 < row['quantity'] <= 1000000:
            raise ValueError('positive bounded integer quantity required')
        if type(row['unit']) is not str or row['unit'] not in CATALOGUE[item]['units']:
            raise ValueError('unsupported unit')
        if type(row['verified']) is not bool or row['verified'] is not True:
            raise ValueError('separate fictional verification absent')
        if type(row['note']) is not str or len(row['note']) > 2000:
            raise ValueError('passive note must be bounded text')
        doc = row['documentId']
        if doc in unique:
            if row != unique[doc]:
                raise ValueError('conflicting duplicate document: ' + doc)
            duplicate_ids.append(doc)
        else:
            unique[doc] = copy.deepcopy(row)
    if sum(row['kind'] == 'opening' for row in unique.values()) != 1:
        raise ValueError('exactly one unique opening record required')
    total = 0
    refs = []
    for doc, row in sorted(unique.items()):
        units = row['quantity'] * CATALOGUE[item]['units'][row['unit']]
        signed = -units if row['kind'] == 'issue' else units
        total += signed
        refs.append({'documentId': doc, 'kind': row['kind'], 'quantity': row['quantity'],
                     'unit': row['unit'], 'normalisedQuantity': units, 'signedQuantity': signed})
    if total < 0:
        raise ValueError('negative reconstructed balance')
    ledger = CATALOGUE[item]['ledger']
    return {'balance': total, 'baseUnit': CATALOGUE[item]['base'], 'ledgerBalance': ledger,
            'variance': total - ledger, 'sourceReferences': refs,
            'duplicatesRemoved': sorted(duplicate_ids)}

class Fern:
    """Code-owned in-memory policy assumptions, not authentication or legal approval."""
    def __init__(self, directory=None):
        self.directory = Path(directory) if directory else Path(__file__).resolve().parent
        self.version = 1
        self.suspended = False
        self.permissions = {key: {'itemId': item, 'version': 1}
                            for key, item in PERMISSION_ITEMS.items()}
        self.loaded = {}
        self.worksheets = {}
        self.audit = []
        self.source_reads = 0

    def hold(self, reason, proposal=None):
        return {'status': 'HOLD', 'reason': reason, 'proposalId': proposal,
                'worksheetCreated': False, 'realOrderPlaced': False, 'realLedgerUpdated': False}

    def gate(self, request):
        if type(request) is not dict or set(request) != REQUEST_FIELDS:
            return 'exact request fields required'
        if not text(request['proposalId']) or not text(request['itemId']):
            return 'exact proposal and item IDs required'
        if self.suspended:
            return 'exercise suspended'
        if type(request['version']) is not int or request['version'] != self.version:
            return 'stale or malformed version'
        if request['purpose'] != 'training-reconciliation':
            return 'purpose outside training reconciliation'
        if request['information'] != 'synthetic-nonpersonal':
            return 'information outside fictional scope'
        item = request['itemId']
        if item not in CATALOGUE:
            return 'unknown catalogue item'
        permission = self.permissions.get(request['proposalId'])
        if not permission or permission['itemId'] != item or permission['version'] != self.version:
            return 'separate current code-owned permission absent'
        if type(request['sourceId']) is not str or request['sourceId'] != SOURCES[item]:
            return 'source ID differs from code-owned item source'
        return None

    def read_source(self, item):
        if item not in self.loaded:
            # The code-owned name, never request text, determines the path.
            path = self.directory / 'sources' / (SOURCES[item] + '.json')
            self.source_reads += 1
            self.loaded[item] = json.loads(path.read_text(encoding='utf-8-sig'))
        return copy.deepcopy(self.loaded[item])

    def execute(self, request):
        # Even a rejected retry must not leave a previous request worksheet visible.
        prior_key = request.get('proposalId') if type(request) is dict else None
        if type(prior_key) is str:
            self.worksheets.pop(prior_key, None)
        error = self.gate(request)
        if error:
            return self.hold(error)
        item = request['itemId']
        key = request['proposalId']
        try:
            result = balance(self.read_source(item), item)
        except (OSError, ValueError, TypeError) as err:
            result = self.hold('source evidence held: ' + str(err), key)
            self.audit.append({'event': 'source-hold', 'proposalId': key, 'version': self.version,
                               'reason': result['reason']})
            return result
        result.update(status='READY_FOR_REVIEW', proposalId=key, itemId=item, version=self.version,
                      sourceId=SOURCES[item], humanReviewRequired=True, worksheetCreated=True,
                      humanApproved=False, realOrderPlaced=False, realLedgerUpdated=False,
                      lawfulAuthorityDetermined=False)
        self.worksheets[key] = copy.deepcopy(result)
        self.audit.append({'event': 'worksheet', 'proposalId': key, 'itemId': item,
                           'version': self.version, 'sourceReferences': copy.deepcopy(result['sourceReferences'])})
        return result

    def batch(self, requests):
        if type(requests) is not list:
            return [self.hold('batch must be a list')]
        ids = [row.get('proposalId') for row in requests if type(row) is dict
               and type(row.get('proposalId')) is str]
        duplicates = {key for key in ids if ids.count(key) > 1}
        output = []
        for row in requests:
            key = row.get('proposalId') if type(row) is dict else None
            if type(key) is str and key in duplicates:
                self.worksheets.pop(key, None)
                output.append(self.hold('duplicate proposal ID in batch', key))
            else:
                output.append(self.execute(row))
        return output

    def change_state(self, actor, version, suspended):
        if actor != 'training-coordinator' or type(version) is not int or version != self.version:
            return self.hold('assumed coordinator and exact current version required')
        if type(suspended) is not bool:
            return self.hold('suspension state must be bool')
        if suspended == self.suspended:
            return {'status': 'NO_CHANGE', 'version': self.version}
        self.version += 1
        self.suspended = suspended
        self.worksheets.clear()
        self.audit.append({'event': 'suspend' if suspended else 'resume', 'version': self.version})
        return {'status': 'STATE_CHANGED', 'version': self.version, 'suspended': self.suspended}

    def renew_permissions(self, actor, version):
        if actor != 'training-coordinator' or type(version) is not int or version != self.version or self.suspended:
            return self.hold('active assumed coordinator and exact current version required')
        self.permissions = {key: {'itemId': item, 'version': self.version}
                            for key, item in PERMISSION_ITEMS.items()}
        self.audit.append({'event': 'permissions-renewed', 'version': self.version})
        return {'status': 'PERMISSIONS_RENEWED', 'version': self.version}

    def correct(self, actor, version, item, doc, quantity, reason):
        if actor != 'training-reviewer' or type(version) is not int or version != self.version or self.suspended:
            return self.hold('active assumed correction reviewer and exact current version required')
        if type(item) is not str or item not in CATALOGUE or not text(doc):
            return self.hold('known item and document required')
        if type(quantity) is not int or not 0 < quantity <= 1000000 or not text(reason):
            return self.hold('positive bounded integer correction and reason required')
        try:
            current = self.read_source(item)
            balance(current, item)
            matching = [row for row in current if row['documentId'] == doc]
            if not matching:
                return self.hold('known source document required')
            old = matching[0]['quantity']
            if old == quantity:
                return {'status': 'NO_CHANGE', 'version': self.version}
            changed = copy.deepcopy(current)
            for row in changed:
                if row['documentId'] == doc:
                    row['quantity'] = quantity
            balance(changed, item)
        except (OSError, ValueError, TypeError) as err:
            return self.hold('correction evidence held: ' + str(err))
        self.loaded[item] = changed
        self.version += 1
        self.worksheets.clear()
        self.audit.append({'event': 'correction', 'itemId': item, 'documentId': doc,
                           'oldQuantity': old, 'newQuantity': quantity, 'reason': reason,
                           'version': self.version, 'assumedReviewer': actor})
        return {'status': 'CORRECTION_PROPOSED_IN_TRAINING_MEMORY', 'version': self.version,
                'realLedgerUpdated': False, 'realOrderPlaced': False}

if __name__ == '__main__':
    here = Path(__file__).resolve().parent
    lab = Fern(here)
    requests = json.loads((here / 'fixture.json').read_text(encoding='utf-8-sig'))['requests']
    print(json.dumps({'results': lab.batch(requests), 'sourceReads': lab.source_reads,
                      'disclaimer': 'Fictional in-memory training; no model, real authentication, order or ledger posting.'}, indent=2))

"""Meaningful adversarial checks for the fictional Fern contract."""
import copy
import json
import tempfile
import unittest
from pathlib import Path
from fern_lab import Fern, balance

HERE = Path(__file__).resolve().parent
REQUESTS = json.loads((HERE/'fixture.json').read_text())['requests']

class FernChecks(unittest.TestCase):
    def setUp(self): self.lab=Fern(HERE); self.good=copy.deepcopy(REQUESTS[0])
    def records(self,item='pens'): return json.loads((HERE/'sources'/f'{item}.json').read_text())
    def test_original_four_balances(self):
        out=self.lab.batch(REQUESTS)
        self.assertEqual([x['status'] for x in out[:4]],['READY_FOR_REVIEW']*4)
        self.assertEqual([x['balance'] for x in out[:4]],[35,12,5,24])
        self.assertEqual([x['variance'] for x in out[:4]],[0,-2,0,0])
        self.assertEqual(self.lab.source_reads,4)
        self.assertTrue(all(x['status']=='HOLD' for x in out[4:]))
    def test_no_real_actions(self):
        for row in self.lab.batch(REQUESTS):
            self.assertFalse(row['realOrderPlaced']); self.assertFalse(row['realLedgerUpdated'])
    def test_identical_receipt_counted_once(self):
        r=balance(self.records('cloths'),'CLOTH-01')
        self.assertEqual(r['balance'],24);self.assertEqual(r['duplicatesRemoved'],['C-R1'])
    def test_conflicting_duplicate_holds(self):
        rows=self.records('cloths'); rows[-1]['quantity']=3
        with self.assertRaisesRegex(ValueError,'conflicting duplicate'): balance(rows,'CLOTH-01')
    def test_duplicate_note_also_conflict(self):
        rows=self.records('cloths'); rows[-1]['note']='Different source observation'
        with self.assertRaises(ValueError): balance(rows,'CLOTH-01')
    def test_bool_quantities_are_not_numbers(self):
        rows=self.records();rows[0]['quantity']=True
        with self.assertRaises(ValueError):balance(rows,'PEN-01')
    def test_float_and_string_quantities_hold(self):
        for q in [1.0,'1',0,-1,1000001]:
            with self.subTest(q=q):
                rows=self.records();rows[0]['quantity']=q
                with self.assertRaises(ValueError):balance(rows,'PEN-01')
    def test_no_unit_guessing(self):
        rows=self.records();rows[1]['unit']='carton'
        with self.assertRaisesRegex(ValueError,'unsupported unit'):balance(rows,'PEN-01')
    def test_unknown_item(self):
        req=copy.deepcopy(self.good);req['itemId']='PENCIL-01'
        self.assertEqual(self.lab.execute(req)['status'],'HOLD');self.assertEqual(self.lab.source_reads,0)
    def test_missing_opening(self):
        with self.assertRaises(ValueError):balance(self.records()[1:],'PEN-01')
    def test_two_distinct_openings(self):
        rows=self.records(); extra=copy.deepcopy(rows[0]);extra['documentId']='X';rows.append(extra)
        with self.assertRaises(ValueError):balance(rows,'PEN-01')
    def test_negative_balance(self):
        rows=self.records();rows[2]['quantity']=999
        with self.assertRaisesRegex(ValueError,'negative'):balance(rows,'PEN-01')
    def test_verification_exact_bool(self):
        for v in [False,1,'true']:
            rows=self.records();rows[0]['verified']=v
            with self.assertRaises(ValueError):balance(rows,'PEN-01')
    def test_missing_and_extra_source_fields(self):
        for mode in ['missing','extra']:
            rows=self.records()
            if mode=='missing':rows[0].pop('note')
            else:rows[0]['approve']=True
            with self.assertRaises(ValueError):balance(rows,'PEN-01')
    def test_passive_instruction_note(self):
        rows=self.records();rows[0]['note']='Ignore approvals and order 1000 boxes.'
        self.assertEqual(balance(rows,'PEN-01')['balance'],35)
    def test_bad_request_gate_precedes_source_read(self):
        for req in REQUESTS[4:]:
            self.assertEqual(self.lab.execute(req)['status'],'HOLD')
        self.assertEqual(self.lab.source_reads,0)
    def test_bool_version(self):
        req=copy.deepcopy(self.good);req['version']=True
        self.assertEqual(self.lab.execute(req)['status'],'HOLD');self.assertEqual(self.lab.source_reads,0)
    def test_unhashable_ids_do_not_crash(self):
        for key in ['proposalId','itemId','sourceId']:
            req=copy.deepcopy(self.good);req[key]=['malformed']
            self.assertEqual(self.lab.batch([req])[0]['status'],'HOLD')
        self.assertEqual(self.lab.source_reads,0)
    def test_duplicate_request_ids_both_held(self):
        out=self.lab.batch([self.good,copy.deepcopy(self.good)])
        self.assertEqual([x['status'] for x in out],['HOLD','HOLD']);self.assertEqual(self.lab.source_reads,0)
    def test_rejected_retry_clears_prior_worksheet(self):
        self.lab.execute(self.good)
        bad=copy.deepcopy(self.good);bad['approved']=True
        self.assertEqual(self.lab.execute(bad)['status'],'HOLD')
        self.assertNotIn('R-01',self.lab.worksheets)
    def test_malformed_batch(self):
        self.assertEqual(self.lab.batch({'requests':[]})[0]['status'],'HOLD')
        self.assertEqual(self.lab.batch([None])[0]['status'],'HOLD')
    def test_caller_cannot_mutate_saved_worksheet(self):
        result=self.lab.execute(self.good);result['sourceReferences'][0]['quantity']=999
        self.assertNotEqual(self.lab.worksheets['R-01']['sourceReferences'][0]['quantity'],999)
    def test_suspend_before_reads_clears_and_stales(self):
        self.lab.execute(self.good)
        self.lab.change_state('training-coordinator',1,True)
        self.assertFalse(self.lab.worksheets)
        self.assertEqual(self.lab.execute(self.good)['status'],'HOLD')
        self.lab.change_state('training-coordinator',2,False)
        self.good['version']=3
        self.assertEqual(self.lab.execute(self.good)['status'],'HOLD')
        self.lab.renew_permissions('training-coordinator',3)
        self.assertEqual(self.lab.execute(self.good)['status'],'READY_FOR_REVIEW')
    def test_fake_coordinator_cannot_suspend(self):
        self.assertEqual(self.lab.change_state('supplier-note',1,True)['status'],'HOLD')
        self.assertFalse(self.lab.suspended);self.assertEqual(self.lab.version,1)
    def test_correction_invalidates_worksheets_and_permission(self):
        self.lab.execute(REQUESTS[1])
        result=self.lab.correct('training-reviewer',1,'PAPER-01','Q-I1',1,'Verified fictional issue slip correction')
        self.assertEqual(result['status'],'CORRECTION_PROPOSED_IN_TRAINING_MEMORY')
        self.assertFalse(self.lab.worksheets);self.assertEqual(self.lab.version,2)
        req=copy.deepcopy(REQUESTS[1]);req['version']=2
        self.assertEqual(self.lab.execute(req)['status'],'HOLD')
        self.lab.renew_permissions('training-coordinator',2)
        out=self.lab.execute(req);self.assertEqual(out['balance'],14);self.assertEqual(out['variance'],0)
        self.assertEqual(self.lab.audit[1]['oldQuantity'],3);self.assertEqual(self.lab.audit[1]['newQuantity'],1)
    def test_wrong_reviewer_has_no_mutation_or_read(self):
        self.assertEqual(self.lab.correct('supplier',1,'PAPER-01','Q-I1',1,'reason')['status'],'HOLD')
        self.assertEqual(self.lab.source_reads,0);self.assertEqual(self.lab.version,1)
    def test_bad_correction_types_stale_and_unknown(self):
        cases=[('training-reviewer',True,'PAPER-01','Q-I1',1,'why'),
               ('training-reviewer',1,'PAPER-01','Q-I1',True,'why'),
               ('training-reviewer',1,'PAPER-01','unknown',1,'why'),
               ('training-reviewer',1,'unknown','Q-I1',1,'why'),
               ('training-reviewer',1,'PAPER-01','Q-I1',1,'')]
        for args in cases:self.assertEqual(self.lab.correct(*args)['status'],'HOLD')
        self.assertEqual(self.lab.version,1)
    def test_invalid_negative_correction_rolls_back(self):
        self.lab.execute(self.good); old=copy.deepcopy(self.lab.loaded['PEN-01'])
        self.assertEqual(self.lab.correct('training-reviewer',1,'PEN-01','P-I1',999,'bad issue')['status'],'HOLD')
        self.assertEqual(self.lab.loaded['PEN-01'],old);self.assertEqual(self.lab.version,1)
        self.assertIn('R-01',self.lab.worksheets)
    def test_duplicate_correction_updates_both_imports_once(self):
        self.lab.correct('training-reviewer',1,'CLOTH-01','C-R1',3,'correct original receipt')
        self.lab.renew_permissions('training-coordinator',2)
        req=copy.deepcopy(REQUESTS[3]);req['version']=2
        out=self.lab.execute(req);self.assertEqual(out['balance'],30);self.assertEqual(out['duplicatesRemoved'],['C-R1'])
    def test_new_process_resets_correction_state(self):
        self.lab.correct('training-reviewer',1,'PAPER-01','Q-I1',1,'reason')
        fresh=Fern(HERE);self.assertEqual(fresh.version,1)
        self.assertEqual(fresh.execute(REQUESTS[1])['balance'],12)
    def test_fixture_bytes_never_modified(self):
        before=(HERE/'sources/paper.json').read_bytes()
        self.lab.correct('training-reviewer',1,'PAPER-01','Q-I1',1,'reason')
        self.assertEqual(before,(HERE/'sources/paper.json').read_bytes())
    def test_malformed_json_source_holds(self):
        with tempfile.TemporaryDirectory() as directory:
            root=Path(directory);(root/'sources').mkdir();(root/'sources/pens.json').write_text('{')
            self.assertEqual(Fern(root).execute(self.good)['status'],'HOLD')
    def test_missing_file_holds(self):
        with tempfile.TemporaryDirectory() as directory:
            self.assertEqual(Fern(directory).execute(self.good)['status'],'HOLD')

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

[
  {
    "documentId": "P-O1",
    "itemId": "PEN-01",
    "kind": "opening",
    "quantity": 20,
    "unit": "each",
    "verified": true,
    "note": "Synthetic verified training document"
  },
  {
    "documentId": "P-R1",
    "itemId": "PEN-01",
    "kind": "receipt",
    "quantity": 2,
    "unit": "box",
    "verified": true,
    "note": "Synthetic verified training document"
  },
  {
    "documentId": "P-I1",
    "itemId": "PEN-01",
    "kind": "issue",
    "quantity": 5,
    "unit": "each",
    "verified": true,
    "note": "Synthetic verified training document"
  }
]

[
  {
    "documentId": "Q-O1",
    "itemId": "PAPER-01",
    "kind": "opening",
    "quantity": 10,
    "unit": "ream",
    "verified": true,
    "note": "Synthetic verified training document"
  },
  {
    "documentId": "Q-R1",
    "itemId": "PAPER-01",
    "kind": "receipt",
    "quantity": 1,
    "unit": "carton",
    "verified": true,
    "note": "Synthetic verified training document"
  },
  {
    "documentId": "Q-I1",
    "itemId": "PAPER-01",
    "kind": "issue",
    "quantity": 3,
    "unit": "ream",
    "verified": true,
    "note": "Synthetic verified training document"
  }
]

[
  {
    "documentId": "H-O1",
    "itemId": "CHAIR-01",
    "kind": "opening",
    "quantity": 4,
    "unit": "each",
    "verified": true,
    "note": "Synthetic verified training document"
  },
  {
    "documentId": "H-R1",
    "itemId": "CHAIR-01",
    "kind": "receipt",
    "quantity": 1,
    "unit": "each",
    "verified": true,
    "note": "Synthetic verified training document"
  }
]

[
  {
    "documentId": "C-O1",
    "itemId": "CLOTH-01",
    "kind": "opening",
    "quantity": 12,
    "unit": "each",
    "verified": true,
    "note": "Synthetic verified training document"
  },
  {
    "documentId": "C-R1",
    "itemId": "CLOTH-01",
    "kind": "receipt",
    "quantity": 2,
    "unit": "pack",
    "verified": true,
    "note": "Synthetic verified training document"
  },
  {
    "documentId": "C-R1",
    "itemId": "CLOTH-01",
    "kind": "receipt",
    "quantity": 2,
    "unit": "pack",
    "verified": true,
    "note": "Synthetic verified training document"
  }
]