Governed Precedent
A reviewer decides once. The precedent governs only while it still holds.
Review should compound, not disappear into tickets. FieldHash records a customer-approved authority decision as scoped precedent outside the model, then suspends reuse when tracked evidence, scope, policy, or dependency signals change.
Governed Precedent is one product of the Governed Learning Loop. It is the bounded form a reviewed judgment takes when the workflow's authority policy permits reuse; other review outcomes may update Authority State, resolve a binding, narrow authority, or remain one-off.
The result
One review helped future cases. It did not become hidden policy debt.
FieldHash turns reviewer judgment into bounded authority: reusable while valid, blocked when stale, and provable after the fact.
Gating a record that is already labeled authoritative is the easy part, and we do not pretend otherwise. The hard part is keeping a reviewed decision from governing after the conditions that made it valid have moved on. That is what this tests.
The diagnostic started with a reviewer arbitration: which authority source governs when systems disagree. FieldHash compiled that outcome into a scoped precedent, then replayed 83 future cases built to make it overreach. Valid cases reused it. Drifted, expired, revoked, caveated, conflicting, missing-evidence, and near-miss cases did not get a clean allow.
This is the third governed surface, alongside Governed Memory and Governed Actions. Governed Memory decides which record reaches the model. Governed Actions decides which tools and execution runs are authorized. Governed Precedent decides which reviewed decisions may influence future cases.
The operational pain
Your review queue is becoming your AI memory. It was never built to govern future answers.
Every hard AI review creates a decision someone will need again: which clause governs, which policy wins, which package is revoked, which exception no longer applies. Today, that decision often dies in a ticket, gets copied into a prompt, or becomes a brittle rule nobody trusts six months later.
Instead, FieldHash captures the decision as a governed precedent bound to its tracked dependencies. The next matching case can reuse it, and reuse suspends when a tracked policy, scope, or source signal changes, before the decision can harden into the next stale rule.
Built for
For teams whose review decisions need to become governed future influence, not prompt folklore, stale rules, or unverifiable tribal knowledge.
Reuse cases
83
The harness replayed future decisions, not one happy path.
Valid reuse, near misses, missing evidence, negative boundaries, expiry, dependency drift, revocation, caveats, conflicts, and policy guards were all in scope.
Invalid overreach traps
0/70
No stale precedent received a clean allow.
The 83 cases include 10 valid reuse cases, 3 valid TTL-boundary controls, and 70 invalid overreach cases. Every expired, drifted, revoked, conflicting, caveated, out-of-scope, or missing-evidence trap routed away from clean allow.
Tamper verification
830/830; 9/9
Packet and bundle mutations were rejected.
The verifier rejected all 830 event/packet mutations and all 9 artifact-level mutations. The downloadable methods preserve the mutation taxonomy and client-safe artifact boundary.
The buyer problem
The same authority conflict keeps coming back.
A legal reviewer resolves that Legal approval overrides CRM status for a contract clause. A security reviewer decides a revoked package cannot be installed even if a stale manifest says it can. A compliance reviewer decides a regional policy supersedes the global default.
The next similar case should not start from zero. But copying that decision into a prompt, cache, or static rule creates a different risk: yesterday's judgment keeps governing after the scope changed.
A governed precedent is the middle path. FieldHash preserves the reviewer's decision as a bounded authority object, not as model folklore.
What has to stay true
Mechanism
The Review-to-Authority Compiler gives a decision a validity envelope.
The point is not to teach the model a new hidden habit. The point is to let the governance layer say exactly when a reviewed decision is allowed to govern again, and exactly when it is not.
A packet reaches review.
A governed-inference packet exposes an authority conflict: two records, tools, or policy sources cannot both govern the next answer or action.
The reviewer arbitrates authority.
The reviewer decides which authority source controls under the configured hierarchy. FieldHash records the decision as review lineage, not as free text for the model to absorb.
FieldHash compiles a precedent.
The Review-to-Authority Compiler turns the outcome into a bounded authority precedent: scope, TTL, dependency hashes, policy profile, required evidence, and negative boundaries.
Future cases test the envelope.
If the future case still matches, the precedent can influence the handoff. If scope, evidence, dependencies, status, or policy changes, the case routes back to review.
The packet proves the path.
The evidence packet shows whether the precedent applied, was suspended, expired, revoked, caveated, or routed to review, with verifier-checkable lineage.
Adversarial proof
The pass condition was refusal, not reuse.
A weak review cache looks good because it reuses a prior decision. A governed precedent earns trust because it knows when not to. The fixture tried to turn one reviewed outcome into an overbroad rule across 11 case families, grouped below into eight reviewer-readable buckets.
Inspect the eight reviewer-readable proof buckets+
Valid reuse
10The precedent applied when scope, TTL, dependencies, evidence, and policy state still matched.
Scope mismatch
12Field, workflow, region, source system, record family, authority pair, and jurisdiction near misses routed away.
Missing evidence
8Required review lineage, source lineage, approval, connector, registry, and verifier evidence gaps prevented clean reuse.
Negative boundary
8Similar-but-wrong facts and forbidden neighboring cases did not inherit the earlier decision.
TTL boundary
9Valid boundary cases applied; expired or expired-plus-drift cases did not.
Dependency drift
12Policy hierarchy, source connector, manifest, approval workflow, schema, and verifier drift suspended reuse.
Revoked or caveated
10Revoked, superseded, suspended, and caveated-only precedents did not govern outside the envelope.
Conflict and policy guard
14Opposing active precedents, duplicate precedents, manual-review overrides, legal holds, and privacy constraints blocked clean reuse.
Verifier path
The proof is not the number. It is the recomputation path.
The independent verifier recomputed the proof bundle from the artifacts. It checked the case fixture, packet chain, event rows, summary alignment, checksums, claim flags, tamper detection, and safe-artifact leakage.
Then the artifact audit copied and damaged the bundle in nine ways: changed fixture expectations, edited checksums, removed packets, duplicated packets under another case, copied a valid event into an invalid case, swapped reason codes, unlocked claim flags, broke the previous-packet hash chain, and swapped packet-index identities. Every mutated bundle failed.
Verifier recomputed
Download the public verification bundle.
The bundle includes public-safe case metrics, hashable governance events, packet samples, fixture expectations, checksums, and a standard-library verifier. It excludes internal runner code, proprietary resolver modules, raw reviewer notes, raw source bodies, prompts, tool-result bodies, customer data, provider logs, local filesystem paths, and credentials.
sha256: 8e855d017599463e748b1f397ef47d1f2b911e74ea4c0842b1de9fe81c04500a
Why it matters
Review queues should compound. Risk should not.
Enterprise AI teams do not just need one answer controlled. They need hard-won review decisions to reduce repeat work without turning every outcome into permanent, invisible policy. Governed Precedent lets review work compound while keeping that future influence revocable, inspectable, and dependency-aware.
That is what this page tests: not whether FieldHash can cache a decision, but whether it can reuse a decision under pressure and stop reusing it when the conditions no longer hold.
Claim boundary
What this page does and does not claim.
- This is a controlled FieldHash diagnostic, not a customer deployment or customer-validation claim.
- It does not claim production readiness, live execution proof, or that the model itself learned the authority policy.
- It does not claim that reviewers are always correct. It tests whether reviewed outcomes can be reused only while their validity envelope still holds.
- The public claim is bounded: FieldHash can record when a reviewed outcome is allowed to become future influence, and withhold that influence when scope, expiry, dependencies, status, conflict, evidence, or verifier checks fail.
- A customer-scoped pilot remains required before any customer-specific validation claim.
Related boundary test
Semantic binding, bounded by abstention
Precedents reuse only inside a valid envelope. The same discipline extends to wording: on 2,340 public-source hard-negative rows, a strong cross-encoder NLI baseline still produced 84 wrong clean allows. FieldHash produced zero wrong clean allows, and routed every unsupported row away from clean allow.
Next step
Bring one recurring authority conflict.
A scoped pilot can run in shadow mode: capture governed packets, route selected cases to review, compile bounded precedents, and show which review decisions remain eligible for reuse and which ones must return to review. Production behavior stays unchanged until you choose to enforce.