Context-Aware Content Policy Gates: Separating Blockers from Hash-Bound Advisories

A content-delivery pipeline used a conservative keyword scanner to stop financial copy from drifting into transaction guidance. The scanner was safe, but too coarse: objective terms such as “shareholder,” “valuation,” and “return” could block an otherwise factual sentence. Internal ranking notes could also trigger rules even though readers would never see them.

Relaxing the entire keyword list would have removed an important safety boundary. The repair took a narrower path. It separated reader-visible content from internal metadata, expressed the highest-risk meaning as a sentence-level relationship, and introduced an advisory: a non-blocking review signal that remains bound to the same evidence hashes as the rest of the QA report.

Evidence of the false-positive boundary

The failing cases fell into three groups:

Input	Intended result	Why
A historical valuation fact	Allow	It describes a completed observation without directing an action
A sentence predicting a price direction for investors	Block	It combines an affected audience, a security-related object, and a directional conclusion
An internal topic-ranking note	Exclude from content policy scanning	It is not delivered to readers, although it still needs privacy and secret scanning

The old design treated all three as flat text. That erased two distinctions: who can see the field, and whether several ordinary words form a risky meaning only when they occur together.

Root cause: one scanner was answering different questions

The pipeline had one undifferentiated input set and one undifferentiated severity. It was effectively trying to answer all of these questions at once:

1. Could this text expose a credential or private identifier?
2. Will a reader receive this text?
3. Does a visible sentence contain prohibited guidance?
4. Does a visible phrase merely deserve extra editorial attention?

Those questions need different scopes and outcomes. Privacy checks should cover the complete artifact, including internal metadata. Content-policy checks should cover only the fields sent to readers: title, summary, body, author text, image copy, captions, and interaction copy. A hard violation must stop delivery; an ambiguous but reviewable phrase should remain visible to the reviewer without pretending that it is a confirmed violation.

Separate visibility from repository safety

The repaired flow builds two views of the same content package:

all_text = collect_every_text_field(package)
visible_text = collect_reader_visible_fields(package)

scan_privacy_and_secrets(all_text)
scan_content_policy(visible_text)

This split does not create a blind spot. Internal rankings, deduplication notes, and selection rationale remain inside the privacy and secret scan. They are excluded only from rules that claim to describe what the publishing platform or reader will receive.

The visibility contract is explicit and versioned. If a new output surface is added, such as text embedded in a cover image, the current policy requires a visible-text inventory before the artifact can pass. Older artifacts retain their historical contract instead of being reinterpreted by a later rule set.

Model high-risk meaning as a semantic chain

Some expressions remain unconditional blockers because their operational meaning is clear, including direct buy or sell instructions, position changes, and target prices. Ordinary financial nouns no longer fail by themselves.

For sentences that depend on context, the scanner requires a complete semantic chain in the same sentence:

affected audience
  + security or valuation object
  + action, recommendation, or future direction
  = blocker

This catches both common word orders. “Investors should validate the share-price target” places the audience first. “A higher valuation will amplify downside risk for shareholders” places the directional mechanism first. Tests must cover both directions because a regular expression that assumes one phrase order creates an easy gap.

The scanner is still deterministic. It does not claim to understand arbitrary prose. It detects a bounded vocabulary and relationship, while a separate logic review confirms the subject, affected object, mechanism, and strength of the conclusion.

Keep advisories non-blocking and tamper-evident

Medium-confidence phrases can be legitimate in industry analysis while still deserving attention. Each match becomes a structured advisory:

{
  "code": "industry-framing-review",
  "severity": "advisory",
  "location": "body:paragraph-7",
  "match": "capital recovery threshold",
  "required_logic_check": "industry_information_positioning"
}

An advisory does not change a review_ready result or the command exit code. It does change the QA report hash. The normalized advisory list is copied into the draft plan and review packet, then reconstructed from the exact source revision during later verification. Deleting, changing, or omitting one makes the evidence comparison fail.

This design keeps severity honest. Reviewers can see uncertain signals without silently converting every signal into a blocker, and downstream automation cannot drop those signals after QA.

Verification covered behavior and evidence transport

A sanitized implementation was checked at several boundaries:

• content QA accepted standalone factual terms and rejected transaction guidance, future direction, and both semantic-chain word orders;
• the repository guard required reader-visible image text for new artifacts while preserving the historical compatibility boundary;
• draft planning and synchronization preserved the normalized advisory list;
• review-packet reconstruction from an exact source revision rejected missing or modified advisories;
• internal metadata stayed outside content-policy matches while remaining subject to repository safety checks;
• 338 automated tests passed across content QA, repository guards, the delivery controller, synchronization logic, and historical compatibility checks;
• a separate repository safety scan passed for 124 tracked files.

The useful evidence is the transition coverage. Tests prove that an advisory remains non-blocking at creation, becomes hash-bound in QA, survives delivery planning, and is rejected if it changes during reconstruction.

Reusable design rules

1. Define reader-visible fields as a contract instead of scanning every string as if it were published.
2. Keep privacy and secret scanning broader than content-policy scanning.
3. Reserve unconditional blockers for expressions whose operational meaning is clear.
4. Express context-dependent risk as an explicit relationship between subject, object, and mechanism.
5. Give review-only signals their own severity and schema.
6. Include non-blocking evidence in hashes and downstream reconstruction checks.
7. Version policy boundaries so that a new rule does not silently invalidate historical artifacts.

Limits

A deterministic semantic chain handles known patterns; it cannot establish the meaning of unrestricted natural language. Ambiguous claims still require human or model-led logic review, and facts still need source verification.

Hash binding proves that downstream records retained the reviewed advisory bytes. It does not prove that a reviewer made the right editorial judgment. The boundary remains clear: automation preserves evidence and enforces declared rules; accountable review decides how a permitted but sensitive statement should be written.