Rulings Must Become
Runtime Law

Dream.OS did not know those rulings as runtime law — you had to keep teaching it.

That is not a bug in one agent prompt. That is a missing platform capability. If approved rulings live only in conversation history, every new window is amnesia with tools attached...

Repository drift is familiar: blobs, obesity, broken history, wrong remotes. You can scan it. You can weigh it. You can refuse the push.

Policy drift is quieter. The agent still ships files. Tests still pass. And somehow the outbound email sounds like a competent AI imitating a marketer — because the standing ruling never became an executable gate.

Today that looked like:

• Voice SSOT ambiguity (voice_profile.md vs YAML vs salvage)
• Cold outreach rendered in blog polish instead of chat-led hybrid
• Drafts without ellipses after the operator already said that was identity-critical
• Bot Lab VERIFY gas resurrecting a lane that had been paused for VoicePrint

Three P0s showed up in the audit: VoicePrint gate, status pin lease, SSOT resolver. Shipping them as independent scripts would have repeated the same mistake — every subsystem remembering rules on its own...

Elevate one level. Every action asks one engine:

Action
  │
  ▼
Policy Engine
  ├── VoicePrint Gate
  ├── Human Approval Gate
  ├── Status Pin Lease
  ├── Parked Task Policy
  ├── Outbound Firewall
  └── SSOT Resolver

Subsystems do not get to invent local interpretations. They request a decision. The engine returns ALLOW or BLOCK. There is no alternate path.

The deeper fix is compilation. Operator rulings stop being chat folklore and become YAML law:

rule_id: outbound_voice
trigger:
  actions: [outbound_message, compose_open, send]
requirements:
  - verified_voiceprint
  - approved_persona
  - ellipses_for_cold_outreach
  - human_preview
failure:
  effect: block
  code: OUTBOUND_VOICEPRINT_REQUIRED
priority: P0

After approval and compile, every agent inherits the rule automatically. No reprompting. No "remember what we said yesterday." No agent-specific reimplementation of the same gate.

Resolve SSOT → Resolve VoicePrint → Resolve Runtime Policy → Resolve Human Approval → Send

If any step fails, send does not happen. Auto-send stays off by default — forever unless a future ruling explicitly changes that law through the same compiler, with the same fail-closed posture.

• runtime/scripts/runtime_policy_engine_001.py — compile / evaluate / outbound-preflight
• runtime/policies/rulings/*.yaml — outbound_voice, status_pin_lease
• SSOT resolver that refuses voice_profile.md for cold outreach
• Outbound gate wrapper now calls the engine (no parallel authority)
• Targeted tests: policy engine + outbound gate — green

This does not finish VoicePrint capture. Real Messenger corpus and calibration still matter. It does something more structural: the next agent cannot honestly claim ignorance of the ruling.

If Dream.OS solves this generally — turning approved rulings into executable policies — you eliminate an entire category of repeated human corrections. Not just VoicePrint. Governance. Deployments. Approvals. Planner behavior. Agent coordination.

The operator rules once. The platform enforces forever. That is the difference between a clever agent session and an operating system...