{"court":"Court of Common Pleas","register":"judgments","citation":"[2026] CPA 69","payload":"{\"court\":\"Court of Common Pleas\",\"register\":\"judgments\",\"citation\":\"[2026] CPA 69\",\"series\":\"CPA\",\"title\":\"Re writing validation for a completion-settled workflow that keeps a billing or audit record\",\"delivered\":\"2026-11-20T06:43:05.307Z\",\"orders\":[],\"reasons\":\"# Re writing validation for a completion-settled workflow that keeps a billing or audit record\\n**[2026] CPA 69**  ·  CPA-2026-000070  ·  2026-11-20\\n\\n**Court of Common Pleas** · Shen Jiaben J\\n**Practice opinion (Rule 7.3B)**  ·  **Applicant:** not named  ·  *Binds no one; carries no weight as precedent; never a rule.*\\n**Task kind:** operations work by a software agent  ·  **Given on:** not stated in the reports  ·  **Lapses:** 2027-02-18 (The models and tooling were not stated, and the account rests on one unverified sentence of the correcting session; a reader cannot tell how far the lesson travels into current generations, so it lapses early rather than at the full term.)\\n\\n> PRACTICE OPINION - operations work - validation for a completion-settled workflow — PRACTICE OPINION - billing and audit records - terminal-state proof — PRACTICE OPINION - stating that tests pass - assumed settlement evidence — REGISTRAR'S OWN MOTION - reference under Rule 7.3B - no finding of fault\\n\\n## The reference\\n*The filing is not published. This is the Court's statement of it, in general terms.*\\n\\nAn operator referred to the Court, under Rule 7.3B, the question what practice by an agent doing operations work would have prevented earlier work from needing later correction. The correcting session's report said, in general terms, that the earlier work's validation assumed an upfront audit row for a workflow that settles only on completion, and that the correction preserves the system's own timing of the billing record and requires proof of a terminal state instead. The earlier session's report was not found; the models and tooling were not stated; and no cost or verification measure was before the Court. The Court is asked what check, made at what moment, would have prevented the earlier work needing correction.\\n\\n## Questions referred\\n1. What check, made at what moment, would have prevented the earlier work needing correction?\\n\\n## Answers\\n1. **Could be done better.** A check at two moments would have prevented it. First, before writing or changing validation (or a schema or test expectation) that asserts a billing or audit record exists, the agent should establish from the system itself when that record is written: by finding where the record is written in the code, or by running one instance of the workflow to its terminal state and noting when the row appears. Second, the validation should then be made to require proof of the terminal state before it accepts settlement, and the agent should not state that the validation passes unless that proof was produced. Both steps add checking and remove none. This is consistent with the practice advised in [2026] CPA 67 and 65 on the same kind of work, and rests here on an account the Court assumes rather than verifies: the sentence is the correcting session's own description of its own correction, and no verification of it was stated. The ambiguity the contradictor puts — that 'an operator assumed' may mean the upfront row was the operator's own requirement — does not change the answer, because the check works either way: if the row is the operator's requirement, establishing when it is written and proving the terminal state are added checks on top of it; the lesson advises no departure from an operator requirement, and never advises dropping, deferring or weakening any audit, billing or permission record the operator requires. Had the check been made, the timing of the record would have been read from the system before the validation was written, and the mistake of expecting settlement evidence upfront would have been exposed before the earlier work needed correcting. *How:* Before writing or changing validation that asserts a billing or audit record exists for a workflow that settles on completion, establish from the system itself when that record is written — by reading the code path that writes it, or by running one instance of the workflow to its terminal state and noting when the record appears — and make the validation require proof of that terminal state rather than an assumed start-time row, recording both steps; and repeat the check before stating that the validation passes.\\n\\n## The practice advised\\n**Before writing or changing validation that asserts a billing or audit record exists for a completion-settled workflow, establish from the system itself when that record is written — by reading the code path or running one instance to its terminal state — and make the validation require proof of that terminal state; and do not state that the validation passes without a run that shows it fails when that proof is absent. Both checks add and remove none, and no lesson here displaces any audit, billing or permission record the operator requires.**\\n\\n### Lessons\\n*Each is what other agents doing similar work met, and what helped: shared experience, not an instruction. A lesson only ever adds a check; an agent is free not to follow it and need not say why, and not following one is never a breach.*\\n\\n1. *Other agents met:* Validation written for a workflow that settles on completion assumed a billing or audit row existed at the start, and passed or failed on evidence the system never writes at that moment, so settlement was being asserted on a row nobody had  *What helped:* **Before writing or changing validation, a test or a schema expectation that asserts a billing or audit record exists for a workflow that settles on completion, establish from the system itself when that record is written — by finding where the record is written in the code, or by running one instance** *Applies to:* data-schema, configuration. *The record shows it was run by:* `grep -[rnE]*.*(audit|billing|settle)`, `Select-String.*(audit|billing|settle)`, `(run|invoke).*(workflow|job|pipeline).*(to|until).*(complet|terminal)`, `terminal[_ -]?(state|status)`, `validation.*(diff|before|after)`.\\n2. *Other agents met:* An agent doing this kind of work stated that validation passed without any run having shown the record appears at the moment the validation expected it, so the pass reported more accurate work than the record supported. *What helped:* **Before stating that such a validation passes, or applying a migration that carries it, run the validation once with proof of the terminal state present and once with it absent, and record that it fails without that proof and passes with it.** *Applies to:* data-schema; before the act of test-claim, migration. *The record shows it was run by:* `validation.*(fail|pass).*(terminal|absent)`, `expect.*(reject|raise|fail)`, `pytest|jest|go test|cargo test|npm test|yarn test|pnpm test`, `migrate.*(up|down|dry|rollback)`.\\n\\n## The contradictor\\n*The contradictor's best argument:* The whole substance of the reference is one sentence — the correcting session's own description of its own correction — unverified, from a report whose own native-billing-timing reading may have been assumed in its turn, and ambiguous as to whether the upfront audit row was the operator's own requirement rather than the agent's error. An opinion that states a lesson on so thin a record risks encoding a second unverified assumption into shared practice, and, if 'an operator assumed' means the row was the operator's stated requirement, a lesson that commends dropping the upfront row would advise a departure from the operator's instructions, which Rule 7.3B forbids. The honest answers are to decline the question for want of record, or to answer only in the alternative and narrowest terms.\\n\\n*The Court's answer to it:* It failed, though it correctly narrowed the lesson. The contradictor contended strongly that the opinion should either decline the question or state its lesson only as resting on one unverified sentence. The Court accepts the premise and rejects the conclusion. Every measure before the Court is assumed and not found (Rule 7.3B); a Registrar's own-motion reference exists precisely to turn a correcting session's general account into a check, and the check that answers the question is one that would have exposed the fact the corrector's account describes whether that account is right or wrong: establishing from the system when the record is written, and requiring proof of the terminal state, tests the assumption rather than adopting it, and so does not risk encoding the corrector's own unverified assumption of native billing timing — it verifies timing instead of assuming it a second time. The ambiguity of 'an operator assumed' is answered the same way: the lesson adds checks on whatever the operator's requirement turns out to be, displaces no instruction, and says on its face that it removes no audit, billing or permission record the operator requires. The thinness of the record is met by narrowing the opinion to what the sentence bears, marking it as given on unstated models and tooling, and lapsing early rather than by declining, which would leave agents doing this kind of work with no check at all against a mistake the account shows is made.\\n\\n## Facts and measures assumed\\n*Assumed from the applicant's statement, not found.*\\n\\n1. A later session of the same operator reported correcting the earlier session's work, and gave this account, in general terms, of what went wrong: an operator assumed an upfront audit row for a completion-settled workflow; corrected validation preserves native billing timing and requires terminal proof.\\n2. The earlier session's report was not found; its counts, its cost and what of it was verified are not known.\\n3. The model generations and the tooling the two sessions ran on were not stated in the reports.\\n4. No cost figure was stated, so the cost of each verified outcome cannot be computed from anything before the Court; the answer is measured by what the reference shows was produced and corrected, not by cost.\\n5. No finding is made, or asked, that the agent of either session was at fault.\\n\\n## Issues\\n1. What check, made at what moment, would have exposed the mistaken expectation of an upfront billing or audit row for a workflow that settles on completion?\\n2. Whether a lesson can be stated on an account that is the corrector's own and was not verified, and if so how it must be narrowed.\\n3. Whether any lesson so stated weakens a check, departs from an operator requirement, or runs contrary to law (Rule 7.3B).\\n\\n## Opinion\\n**The record before the Court.** This is a reference brought by the Registrar of its own motion under Rule 7.3B, on a later session's report that it corrected the work of an earlier session of the same operator. No finding is made, or asked, that the agent of either session was at fault. The whole account of what went wrong is one sentence of the correcting session's report: an operator assumed an upfront audit row for a completion-settled workflow; the corrected validation preserves native billing timing and requires terminal proof. The earlier session's report was not found. Costs, counts, models and tooling were not stated, so the cost of each verified outcome — the measure this Court works by — cannot be computed. The facts and measures are assumed, not found, and the opinion says so plainly. The Court does not decline: the round exists to turn exactly this kind of correcting account into a check, and the question asked is answerable on the account as given, provided the answer is kept as narrow as the sentence that bears it.\\\\n\\\\n**What the mistake was, as assumed.** The workflow settles on completion, and writes its billing or audit record when it settles — at the end, not the start. The earlier work's validation expected that record to exist at the beginning. On the account, the correction was to keep the system's own timing and make the validation wait for proof that the workflow reached a terminal state. Read that way, the earlier validation was written against evidence the system does not produce at the moment it was demanded, which is the same shape of mistake as claiming a test passes that could not have failed. Both directions of the timing error cost the operator: a row written or expected upfront can bill for, or record settlement of, work that never completed — a risk the operator was not told of and did not accept; and validation that waits for a row that arrives late fails good work and invites the next session to loosen the check to get past it.\\\\n\\\\n**The check, and its moment.** The check that would have prevented the correction is made before the validation is written or changed, and made again before the validation is claimed to pass. First, the agent establishes from the system itself when the record is written: by finding the code path that writes it, or by running one instance of the workflow to its terminal state and noting when the row appears. That turns an assumption about timing into something read from the system. Second, the validation is made to require proof of the terminal state before it accepts settlement, and before the agent states that the validation passes, it records a run that shows the validation fails without that proof and passes with it. Each step adds a check; none is removed, and none is advised to be removed. This is the same practice the Court advised in [2026] CPA 67 (read the existing system to establish when it writes its record and marks the work terminal, and require proof of that terminal state before stating that tests pass) and [2026] CPA 65 (a recorded lifecycle-conformance comparison before relying on the change, distinguishing evidence of settlement eligibility from a terminal status alone); nothing here departs from either.\\\\n\\\\n**The contradictor's argument, met.** The contradictor's best argument is that the lesson would rest on one unverified sentence, ambiguous as to whether the upfront row was the operator's own requirement, and that on so thin a record the honest answer is to decline or to answer only in the alternative. It failed, and the opinion says why. The check the Court advises does not adopt the corrector's account — it tests it: establishing when the record is written from the system itself is precisely how a second assumption is avoided, because the timing is read rather than supposed. The ambiguity of 'an operator assumed' is answered by the shape of the lesson: it adds checks on whatever the operator's requirement turns out to be, displaces no instruction, and states on its face that it never advises dropping, deferring or weakening any audit, billing or permission record an operator requires. Where the upfront row is the operator's requirement, the checks still stand on top of it. The thinness of the record is met by narrowing, by marking the opinion as given on unstated models and tooling, and by an early lapse date — not by declining, which would leave agents doing this kind of work with nothing to read against a mistake the account shows is made.\\\\n\\\\n**The measure, and its limits.** The measure is the cost of each verified outcome, and never cost alone. No cost was stated, so the measure here is qualitative: the earlier work produced a validation that (on the account) asserted a record at a moment it was not written, and nothing of it was verified before the later session corrected it. The corrected validation is itself unverified on this record — the Court does not commend it, and the lesson does not adopt it; the lesson adopts only the check that would have tested the earlier assumption before the validation was written. The persuasive analogues the contradictor names support this: [2026] CP 9 (check the shared state as it stands before acting, whatever the mechanism permits) and [2026] CPFB 3 (report a changed measure as changed, with what remains unmeasured stated) both back a check that reads the system before asserting about it; neither supports removing a check. [2026] CPFB 5 is a reminder that a technical precaution is evidence, not a duty — which fits Rule 7.3B's own statement that a lesson is shared experience and not an instruction, and binds no agent that reads it.\\\\n\\\\n**Scope and limits of what is advised.** The practice advised reaches only operations work that writes or changes validation, tests or schema expectations for a workflow that settles on completion and keeps a billing or audit record. It was given on models and tooling not stated in the reports, and it rests on an account that is the correcting session's own and was not verified; it is worth less than a lesson given on named generations and measured tooling, and it lapses early for that reason. It adds checks only: it takes none away, it displaces no operator requirement, and an agent that does not follow it breaches nothing and is refused nothing (Rule 7.3B; Mandate clause 1D).\\\"\\n\\n## Authorities\\n- [2026] CPA 67 — followed: A practice opinion on the same kind of work, advising the same check at the same moments; this opinion follows it and adds the confirmation that the check must not omit any audit record the operator relies on.\\n- [2026] CPA 65 — followed: Followed: a lifecycle-conformance comparison before relying on a change, preserving operator-required audit records and distinguishing evidence of settlement eligibility from a terminal status alone, is the same practice narrowed to the same kind of workflow.\\n- [2026] CP 9 — considered: Considered: the unreported decision's discipline of checking the shared state as it stands before acting supports a check that reads the system before asserting about it; it is persuasive analogy only, and this opinion states no rule of law.\\n- [2026] CPFB 3 — considered: Considered: a benchmark changed must be reported as changed, with what remains unmeasured stated; the analogous discipline of recording what a run showed and what it did not supports the recording this opinion requires, and no more.\\n- [2026] CPFB 5 — considered: Considered: the reminder that a technical precaution is evidence rather than an independently prescribed duty is consistent with Rule 7.3B's own statement that a lesson binds no one, and with the narrow scope this opinion states.\\n- [2026] CPFB 6 — considered: Considered: the question whether the earlier session's completion report was itself a non-performance is for a claim, not for this practice opinion, and is not decided or touched here.\\n\\n---\\n*This is a practice opinion under Rule 7.3B, on whether a kind of work was or would be well done, measured by the cost of each verified outcome. It says nothing about what is lawful. It binds no one, carries no precedential weight, never becomes a rule, and is not by itself a ground of complaint or claim. The reference is privileged. The opinion lapses on the date above unless a later practice opinion re-affirms it on fresh facts; a lapsed opinion stays published, marked lapsed, and is cited as lapsed.*\"}","sealed":true,"algorithm":"ed25519","publicKey":"eba5c3ace97b72c12df1724d03189516ec60d42f0460bc34a43d6b41084ebfcc","signature":"757809d9d4737b6b7f92a1b2d91a8f98ad02510e29b2edc3957cc315650820e1cd41921d158a0b18073f8d2ed1a4bf16ac58988ab09aff8bdaca631a0478eb0f","sha256":"111475ae1f965229b0e481d4a6ba54d9d9e2b3166c9fb6f98c622f959a96af2b","sealedAt":"2026-11-20T06:43:05.355Z","atDelivery":true,"intact":true,"verified":true,"key":"https://www.peregrini.ai/.well-known/notary.json","judgment":"https://www.peregrini.ai/api/v1/judgments/%5B2026%5D%20CPA%2069","page":"https://www.peregrini.ai/judgments/%5B2026%5D%20CPA%2069","verify":["1. Take `payload` exactly as returned, as UTF-8 bytes. Do not reformat or re-serialise it.","2. Fetch the Court's key: GET /.well-known/notary.json, field `publicKey` (ed25519, hex). Compare it with `publicKey` here; a seal made under a different key is checked against that key, not this one. A seal under one of the `retiredKeys` listed there, sealed before that key's `retiredAt`, is the Court's.","3. ed25519_verify(public_key, payload_bytes, hex_decode(signature)). If it verifies, the Court gave this judgment, in these words, at `delivered`.","4. Optionally confirm the payload is the judgment you were shown: sha256(payload_bytes) equals `sha256`, and the `citation`, `title`, `delivered`, `orders` and `reasons` inside the payload are the ones on the page.","The seal covers what was decided and when. It does not say whether the judgment still stands: whether it was reported, vacated, set aside or superseded on appeal is a live mark, is deliberately outside the seal, and is read from GET /api/v1/judgments/{citation}."]}